// adjust range to be within (0, 360], with sign according to theHueFrom and theHueTo
Standard_Real aHueRange = std::fmod (theHueTo - theHueFrom, 360.);
- const Standard_Real aHueEps = Precision::Angular() * 180. / M_PI;
+ constexpr Standard_Real aHueEps = Precision::Angular() * 180. / M_PI;
if (Abs (aHueRange) <= aHueEps)
{
aHueRange = (aHueRange < 0 ? -360. : 360.);
Standard_Integer& Iloc)
{//Warning: Hunt is used to find number of knot which equals coordinate component,
// when coordinate component definitely equals a knot only.
- Standard_Real Tol=Precision::PConfusion()/10;
+ constexpr Standard_Real Tol=Precision::PConfusion()/10;
Standard_Integer i=1;
while((i <= Arr.Upper()) && (Abs(Coord - Arr(i)) > Tol)){
i++;}
{
Standard_Integer N=0;
- Standard_Real Tol=Precision::PConfusion()/10;
+ constexpr Standard_Real Tol=Precision::PConfusion()/10;
Hunt(Arr,Coord,N);
DerNull=Standard_False;
gp_Pnt2d& LeftBot, gp_Pnt2d& RightTop)
{
Standard_Real Comp1=0, DComp1=0, cur, f = 0.0, l = 0.0;
- Standard_Real Tol = Precision::PConfusion()/10;
+ constexpr Standard_Real Tol = Precision::PConfusion()/10;
Standard_Integer i = 1, Bnd1, Bnd2;
Standard_Boolean DIsNull= Standard_False;
TColStd_Array1OfReal Arr(1,BSplC->NbKnots()); BSplC->Knots(Arr);
gp_Pnt2d& RightTop)
{
Standard_Real Comp1=0,DComp1=0;
- Standard_Real Tol = Precision::PConfusion()/10;
+ constexpr Standard_Real Tol = Precision::PConfusion()/10;
Standard_Integer i=1, Up=0, Up1, Up2, Down=0, Down1, Down2;
Standard_Real cur = 0.;
const Standard_Real I2,
gp_Pnt2d& LeftBot, gp_Pnt2d& RightTop)
{
- Standard_Real Tol=Precision::PConfusion()/10;
+ constexpr Standard_Real Tol=Precision::PConfusion()/10;
Standard_Real Comp1=0,DComp1=0;
if(Index==1) { Comp1=UV.X();
DComp1=DUV.X();}
gp_Pnt2d& LeftBot, gp_Pnt2d& RightTop)
{
Standard_Real Comp=0,DComp=0,Tmp1=0.0,Tmp2=0.0;
- Standard_Real Tol=Precision::PConfusion()/10;
+ constexpr Standard_Real Tol=Precision::PConfusion()/10;
Standard_Integer N=0, NUp=0, NLo=0;
if(Index==1)
{ Comp=UV.X();
myCurve->Intervals(TabC,S);
- Standard_Real Tol= Precision::PConfusion()/10;
+ constexpr Standard_Real Tol= Precision::PConfusion()/10;
// sorted sequence of parameters defining continuity intervals;
// started with own intervals of curve and completed by
Standard_Real FP = myCurve->FirstParameter();
Standard_Real LP = myCurve->LastParameter();
- Standard_Real Tol= Precision::PConfusion()/10;
+ constexpr Standard_Real Tol= Precision::PConfusion()/10;
if( ( Abs(U-FP)<Tol)&&(!myFirstSurf.IsNull()) )
{
myCurve->D1(U,Puv,Duv);
Standard_Real FP = myCurve->FirstParameter();
Standard_Real LP = myCurve->LastParameter();
- Standard_Real Tol= Precision::PConfusion()/10;
+ constexpr Standard_Real Tol= Precision::PConfusion()/10;
if( (Abs(U-FP)<Tol)&&(!myFirstSurf.IsNull()) )
{
myCurve->D2(U,UV,DW,D2W);
gp_Vec& V3) const
{
- Standard_Real Tol= Precision::PConfusion()/10;
+ constexpr Standard_Real Tol= Precision::PConfusion()/10;
gp_Pnt2d UV;
gp_Vec2d DW,D2W,D3W;
gp_Vec D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV;
Standard_Real FirstPar,LastPar;
gp_Pnt2d UV, LeftBot, RightTop;
gp_Vec2d DUV;
- Standard_Real Tol= Precision::PConfusion()/10;
+ constexpr Standard_Real Tol= Precision::PConfusion()/10;
Standard_Boolean Ok = Standard_True;
Standard_Real& cuttingvalue) const
{
// longueur minimum d'un intervalle pour F(U,V) : EPS1=1.e-9 (cf.MEPS1)
- Standard_Real lgmin = 10*Precision::PConfusion();
+ constexpr Standard_Real lgmin = 10*Precision::PConfusion();
cuttingvalue = (a+b) / 2;
return (Abs(b-a)>=2*lgmin);
}
Standard_Real& cuttingvalue) const
{
// longueur minimum d'un intervalle parametrique : 10*PConfusion()
- Standard_Real lgmin = 10 * Precision::PConfusion();
+ constexpr Standard_Real lgmin = 10 * Precision::PConfusion();
Standard_Integer i;
Standard_Real cut, mil=(a+b)/2, dist;
Standard_Boolean isfound = Standard_False;
{
// longueur minimum d'un intervalle parametrique : PConfusion()
// pour F(U,V) : EPS1=1.e-9 (cf.MMEPS1)
- Standard_Real lgmin = 10 * Precision::PConfusion();
+ constexpr Standard_Real lgmin = 10 * Precision::PConfusion();
Standard_Integer i;
Standard_Real cut, mil=(a+b)/2,
dist = Abs((a-b)/2);
void AppDef_Variational::InitParameters(Standard_Real& Length)
{
- const Standard_Real Eps1 = Precision::Confusion() * .01;
+ constexpr Standard_Real Eps1 = Precision::Confusion() * .01;
Standard_Real aux, dist;
Standard_Integer i, i0, i1 = 0, ipoint;
{
E1 = Length * Length;
- const Standard_Real Eps1 = Precision::Confusion() * .01;
+ constexpr Standard_Real Eps1 = Precision::Confusion() * .01;
math_Vector VTang1(1, myDimension), VTang2(1, myDimension), VTang3(1, myDimension),
VScnd1(1, myDimension), VScnd2(1, myDimension), VScnd3(1, myDimension);
{
Standard_Integer i ;
- const Standard_Real Eps1 = Precision::Confusion() * .01;
+ constexpr Standard_Real Eps1 = Precision::Confusion() * .01;
const Standard_Real EpsNorm = 1.e-9;
Standard_Real Wpnt = 1.;
return Standard_True;
const Standard_Real MinScalProd = -0.9;
- const Standard_Real SqTol3d = Precision::SquareConfusion();
+ constexpr Standard_Real SqTol3d = Precision::SquareConfusion();
theIndbad = 0;
Standard_Integer indbads [4];
gp_Vec2d& aPrmTg = MyImplicitFirst ? Tguv2 : Tguv1;
//for square
- const Standard_Real aNullValue = Precision::Approximation()*
+ constexpr Standard_Real aNullValue = Precision::Approximation()*
Precision::Approximation(),
anAngTol = Precision::Angular();
((TheSvSurfaces *)PtrOnmySvSurfaces)->SetUseSolver(Standard_True);
}
- const Standard_Real SqTol3d = Precision::SquareConfusion();
+ constexpr Standard_Real SqTol3d = Precision::SquareConfusion();
math_Vector tolerance(1,2);
tolerance(1) = tolerance(2) = 1.e-8;
//
// The difference between faces should be obvious enough
// to guarantee the correctness of the classification
- Standard_Real anAngleCriteria = Precision::Confusion();
+ constexpr Standard_Real anAngleCriteria = Precision::Confusion();
bRet=Standard_True;
aIt.Initialize(theLCSOff);
}
//
if (aR > 100.) {
- Standard_Real d = 10*Precision::PConfusion();
+ constexpr Standard_Real d = 10*Precision::PConfusion();
aDtMin = Max(aDtMin, sqrt(d*d + 2*d*aR));
}
}
aT /= sqrt(aSqMagn);
//sin(da) ~ da, when da->0.
- const Standard_Real aTol = Precision::Angular();
+ constexpr Standard_Real aTol = Precision::Angular();
const gp_Vec2d aRefVDir(0.0, 1.0), aRefUDir(1.0, 0.0);
const Standard_Real aDPv = aT.CrossMagnitude(aRefVDir),
{
const BRep_TFace* TF = static_cast<const BRep_TFace*>(F.TShape().get());
Standard_Real p = TF->Tolerance();
- Standard_Real pMin = Precision::Confusion();
+ constexpr Standard_Real pMin = Precision::Confusion();
if (p > pMin) return p;
else return pMin;
}
{
const BRep_TEdge* TE = static_cast<const BRep_TEdge*>(E.TShape().get());
Standard_Real p = TE->Tolerance();
- Standard_Real pMin = Precision::Confusion();
+ constexpr Standard_Real pMin = Precision::Confusion();
if (p > pMin) return p;
else return pMin;
}
}
Standard_Real p = aTVert->Tolerance();
- Standard_Real pMin = Precision::Confusion();
+ constexpr Standard_Real pMin = Precision::Confusion();
if (p > pMin) return p;
else return pMin;
}
//=======================================================================
static Standard_Integer IsWCS(const gp_Dir& theDir)
{
- const Standard_Real aToler = Precision::Angular()*Precision::Angular();
+ constexpr Standard_Real aToler = Precision::Angular()*Precision::Angular();
const Standard_Real aX = theDir.X(),
aY = theDir.Y(),
if (!myCref.IsNull()) {
Handle(BRep_GCurve) GCref (Handle(BRep_GCurve)::DownCast (myCref));
- Standard_Real eps = Precision::PConfusion();
+ constexpr Standard_Real eps = Precision::PConfusion();
Standard_Real First,Last;
GCref->Range(First,Last);
if (Last<=First) {
Standard_Boolean pcurvefound = Standard_False;
BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
- Standard_Real eps = Precision::PConfusion();
+ constexpr Standard_Real eps = Precision::PConfusion();
Standard_Boolean toRunParallel = !myMutex.IsNull();
while (itcr.More()) {
const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
Standard_Real aFPar;
Standard_Real aLPar;
Handle(Geom2d_Curve) aC2d;
- Standard_Real aTolParConf2 = Precision::PConfusion() * Precision::PConfusion();
+ constexpr Standard_Real aTolParConf2 = Precision::PConfusion() * Precision::PConfusion();
gp_Pnt2d aPOnC;
Standard_Real aParamIn;
gp_Lin& L,
Standard_Real& _Par)
{
- const Standard_Real TolU = Precision::PConfusion();
+ constexpr Standard_Real TolU = Precision::PConfusion();
const Standard_Real TolV = TolU;
TopoDS_Face face;
face.Orientation(TopAbs_FORWARD);
//
//avoid process faces from uncorrected shells
- const Standard_Real eps = Precision::PConfusion();
+ constexpr Standard_Real eps = Precision::PConfusion();
Standard_Real epsU = Max(eps * Max(Abs(U2), Abs(U1)), eps);
Standard_Real epsV = Max(eps * Max(Abs(V2), Abs(V1)), eps);
if( Abs (U2 - U1) < epsU || Abs(V2 - V1) < epsV) {
if (pCurv->Continuity() == GeomAbs_C0)
{
- const Standard_Real epsP = Precision::PConfusion();
+ constexpr Standard_Real epsP = Precision::PConfusion();
GeomAdaptor_Curve aAdaptorCurve(pCurv, aFirst, aLast);
const Standard_Integer nbIntervals = aAdaptorCurve.NbIntervals(GeomAbs_C1);
if ((Dstmin < myDstRef - myEps) || (fabs(Dstmin - myDstRef) < myEps))
{
gp_Pnt Pt, P1 = BRep_Tool::Pnt(theS1);
- const Standard_Real epsP = Precision::PConfusion();
+ constexpr Standard_Real epsP = Precision::PConfusion();
for (i = 1; i <= NbExtrema; i++)
{
if ((Dstmin < myDstRef - myEps) || (fabs(Dstmin - myDstRef) < myEps))
{
gp_Pnt Pt1, Pt2;
- const Standard_Real epsP = Precision::PConfusion();
+ constexpr Standard_Real epsP = Precision::PConfusion();
for (i = 1; i <= NbExtrema; i++)
{
const Standard_Real tol = BRep_Tool::Tolerance(theS2);
gp_Pnt Pt1, Pt2;
- const Standard_Real epsP = Precision::PConfusion();
+ constexpr Standard_Real epsP = Precision::PConfusion();
for (i = 1; i <= NbExtrema; i++)
{
BVH_Array3d& theAddVertices,
NCollection_Vector<ProxPnt_Status>& theAddStatuses)
{
- Standard_Real aTol = Precision::Confusion();
+ constexpr Standard_Real aTol = Precision::Confusion();
TopLoc_Location aLocation;
Handle(Poly_Triangulation) aTr = BRep_Tool::Triangulation (theFace, aLocation);
static Standard_Boolean IsIn (BRepTopAdaptor_FClass2d& FC,
const Geom2dAdaptor_Curve& AC)
{
- Standard_Real Def = 100*Precision::Confusion();
+ constexpr Standard_Real Def = 100*Precision::Confusion();
GCPnts_QuasiUniformDeflection QU(AC,Def);
for (Standard_Integer i = 1; i <= QU.NbPoints(); i++) {
// intersects Shapes From and Until
// case of several intersections (keep PartsOfTool according to the selection)
// position of the face of intersection in PartsOfTool (before or after)
- Standard_Real delta = Precision::Confusion();
+ constexpr Standard_Real delta = Precision::Confusion();
if (myPerfSelection != BRepFeat_NoSelection) {
// modif of the test for cts21181 : (prbmax2 and prnmin2) -> (prbmin1 and prbmax1)
Handle(Geom_Surface) S1,S2;
TopLoc_Location loc1, loc2;
Handle(Standard_Type) typS1,typS2;
- const Standard_Real tollin = Precision::Confusion();
- const Standard_Real tolang = Precision::Angular();
+ constexpr Standard_Real tollin = Precision::Confusion();
+ constexpr Standard_Real tolang = Precision::Angular();
S1 = BRep_Tool::Surface(F1,loc1);
S2 = BRep_Tool::Surface(F2,loc2);
Handle(Geom_Surface) S1,S2;
TopLoc_Location loc1, loc2;
Handle(Standard_Type) typS1,typS2;
- const Standard_Real tollin = Precision::Confusion();
- const Standard_Real tolang = Precision::Angular();
+ constexpr Standard_Real tollin = Precision::Confusion();
+ constexpr Standard_Real tolang = Precision::Angular();
S1 = BRep_Tool::Surface(F1,loc1);
S2 = BRep_Tool::Surface(F2,loc2);
// On calcule les intersection avec Oy.
Geom2dAdaptor_Curve ALine(Line);
- Standard_Real Tol = Precision::Intersection();
+ constexpr Standard_Real Tol = Precision::Intersection();
Standard_Real TolC = 0.;
Geom2dInt_GInter Intersector(ALine,AC2d,TolC,Tol);
}
// set the pcurves
- Standard_Real T = Precision::Confusion();
+ constexpr Standard_Real T = Precision::Confusion();
if (IType != 4) //not plane
{
myKPart(0)
{
//
- const Standard_Real mult = 5.;
- const Standard_Real eps = mult * Precision::Confusion();
+ constexpr Standard_Real mult = 5.;
+ constexpr Standard_Real eps = mult * Precision::Confusion();
//
myNbPnt2d = 2;
myNbPnt = 1;
}
#endif
//
- const Standard_Real mult = 5.;
- const Standard_Real eps = mult * Precision::Confusion();
+ constexpr Standard_Real mult = 5.;
+ constexpr Standard_Real eps = mult * Precision::Confusion();
//
Standard_Real UU =0., Dist = Precision::Infinite(), D1, D2;
}
}
- const Standard_Real Tol = Precision::Confusion();
+ constexpr Standard_Real Tol = Precision::Confusion();
Standard_Real VV;
gp_Pnt2d PF = TheV.Value(TheV.FirstParameter());
myLaws = new (GeomFill_HArray1OfSectionLaw) (1, NbEdge);
- Standard_Real tol = Precision::Confusion();
+ constexpr Standard_Real tol = Precision::Confusion();
mySurface = totalsurf(myEdges->Array2(),myShapes.Length(),NbEdge,
myParams,w1Point,w2Point,uclosed,vclosed,tol);
Standard_Real UF,UL,UC;
Standard_Real Step;
gp_Pnt2d PF,PL,PC;
- Standard_Real PTol = Precision::PConfusion()*10;
- Standard_Real Tol = Precision::Confusion()*10;
+ constexpr Standard_Real PTol = Precision::PConfusion()*10;
+ constexpr Standard_Real Tol = Precision::Confusion()*10;
Standard_Boolean YaCut = Standard_False;
UF = C->FirstParameter();
TopoDS_Vertex& VN)
{
Standard_Boolean Status;
- Standard_Real Tol = Precision::Confusion();
+ constexpr Standard_Real Tol = Precision::Confusion();
BRep_Builder B;
if (!aNode->Infinite() && Abs(aNode->Distance()-Offset) < Tol) {
// otherwise preserve only one of its representations.
//----------------------------------------------------------
if (!BRep_Tool::Degenerated(E)) {
- Standard_Real aParTol = 2.0 * Precision::PConfusion();
+ constexpr Standard_Real aParTol = 2.0 * Precision::PConfusion();
for (Standard_Integer k = 1; k < TheVer.Length(); k ++) {
if (TheVer.Value(k).IsSame(TheVer.Value(k+1)) ||
Abs(ThePar.Value(k)-ThePar.Value(k+1)) <= aParTol) {
{
TopoDS_Face F = TopoDS::Face(Spine.Oriented(TopAbs_FORWARD));
- Standard_Real eps = Precision::Confusion();
+ constexpr Standard_Real eps = Precision::Confusion();
Standard_Real LimCurv = 1./Offset;
TopTools_MapOfShape aMap;
Ex.Next();
if( Ex.More() ) {
- Standard_Real tolrac, epsV, tol = Precision::Confusion();
+ Standard_Real tolrac, epsV;
+ constexpr Standard_Real tol = Precision::Confusion();
GeomConvert_CompCurveToBSplineCurve Conv(TC);
for (; Ex.More(); Ex.Next()) {
E = TopoDS::Edge(Ex.Current());
Place.Perform(adpPath, Precision::Confusion());
- Standard_Real theParam = Place.ParameterOnPath(),
- eps = Precision::PConfusion();
+ Standard_Real theParam = Place.ParameterOnPath();
+ constexpr Standard_Real eps = Precision::PConfusion();
#ifdef OCCT_DEBUG
if (myDebug) {
TColgp_SequenceOfPnt& Params)
{
Geom2dInt_GInter Intersector;
- Standard_Real Tol = Precision::Confusion();
+ constexpr Standard_Real Tol = Precision::Confusion();
// Standard_Real TolC = 1.e-9;
const Geom2dAdaptor_Curve& CBis(Bis);
// The tolerance can be eventually changed.
gp_Pnt P1,P2;
- Standard_Real Tol = 4 * 100 * Precision::PConfusion();
+ constexpr Standard_Real Tol = 4 * 100 * Precision::PConfusion();
Standard_Integer i = 1;
Standard_Integer NbPoints = Params.Length();
{
Standard_Boolean ToProj = Standard_True;
gp_Pnt2d PBis;
- Standard_Real Tol = 10*Precision::Confusion();
+ constexpr Standard_Real Tol = 10*Precision::Confusion();
// return curves associated to edges.
TopLoc_Location L;
Standard_Integer iU = theKnots->Upper();
Standard_Integer aStartI = 0;
Standard_Integer aEndI = 0;
- Standard_Real aTol = Precision::Confusion();
+ constexpr Standard_Real aTol = Precision::Confusion();
while (++i < iU) {
if (aStartI == 0 && theKnots->Value(i) > theMin + aTol)
// Check if the periodic surface should become closed.
// In this case, use the basis surface with basis bounds.
- const Standard_Real anEps = Precision::PConfusion();
+ constexpr Standard_Real anEps = Precision::PConfusion();
if (isUPeriodic && Abs(aFUMax - aFUMin - anUPeriod) < anEps)
{
aFUMin = aSUMin;
}
// On a presomption de confusion
- const Standard_Real tollin = Precision::Confusion();
- const Standard_Real tolang = Precision::Angular();
+ constexpr Standard_Real tollin = Precision::Confusion();
+ constexpr Standard_Real tolang = Precision::Angular();
if (typC1 == STANDARD_TYPE(Geom_Line)) {
gp_Lin li1( Handle(Geom_Line)::DownCast (C1)->Lin());
gp_Lin li2( Handle(Geom_Line)::DownCast (C2)->Lin());
Standard_Real p2 = pp2;
Standard_Real cf = C->FirstParameter();
Standard_Real cl = C->LastParameter();
- Standard_Real epsilon = Precision::PConfusion();
+ constexpr Standard_Real epsilon = Precision::PConfusion();
Standard_Boolean periodic = C->IsPeriodic();
GeomAdaptor_Curve aCA(C);
Standard_Real p2 = pp2;
Standard_Real cf = C->FirstParameter();
Standard_Real cl = C->LastParameter();
- Standard_Real epsilon = Precision::PConfusion();
+ constexpr Standard_Real epsilon = Precision::PConfusion();
Standard_Boolean periodic = C->IsPeriodic();
Standard_Real p2 = pp2;
Standard_Real cf = C->FirstParameter();
Standard_Real cl = C->LastParameter();
- Standard_Real epsilon = Precision::Confusion();
+ constexpr Standard_Real epsilon = Precision::Confusion();
Standard_Boolean periodic = C->IsPeriodic();
if (!p1inf) P1 = C->Value(p1);
if (!p2inf) P2 = C->Value(p2);
- Standard_Real preci = Precision::Confusion();
+ constexpr Standard_Real preci = Precision::Confusion();
BRep_Builder B;
// check for closed curve
// adjust periodical surface or reordonate
// check if the values are in the natural range
- Standard_Real epsilon = Precision::PConfusion();
+ constexpr Standard_Real epsilon = Precision::PConfusion();
BS->Bounds(umin,umax,vmin,vmax);
BS = RTS->BasisSurface();
}
myError = BRepLib_EmptyShell;
- Standard_Real tol = Precision::Confusion();
+ constexpr Standard_Real tol = Precision::Confusion();
// Make a shell from a surface
GeomAdaptor_Surface GS(BS,UMin,UMax,VMin,VMax);
// Additional checking for degenerated edges
Standard_Boolean isDegenerated;
Standard_Real aFirst, aLast;
- Standard_Real aTol = Precision::Confusion();
+ constexpr Standard_Real aTol = Precision::Confusion();
Standard_Real anActTol;
TopExp_Explorer anExp(myShape, TopAbs_EDGE);
for ( ; anExp.More(); anExp.Next())
return;
}
- const Standard_Real aTol = Precision::Confusion();
+ constexpr Standard_Real aTol = Precision::Confusion();
Standard_Integer aTri[3];
gp_Dir aNorm;
theTris->AddNormals();
{
TopoDS_Edge aNewEdge;
BRep_Builder aBuilder;
- Standard_Real aTol = Precision::Confusion();
+ constexpr Standard_Real aTol = Precision::Confusion();
Standard_Real aFPar = theCurve->FirstParameter();
Standard_Real aLPar = theCurve->LastParameter();
aPClass(1) = *p1;
aPClass(2) = *p2;
- const Standard_Real aAngTol = Precision::Angular();
- const Standard_Real aSqConfusion =
+ constexpr Standard_Real aAngTol = Precision::Angular();
+ constexpr Standard_Real aSqConfusion =
Precision::PConfusion() * Precision::PConfusion();
for (Standard_Integer i = 1; i <= aNbPnts; i++)
const Adaptor3d_CurveOnSurface& aCurve = myCurve.CurveOnSurface();
const Handle(Adaptor3d_Surface)& aSurface = aCurve.GetSurface();
- const Standard_Real aTol = Precision::Confusion();
+ constexpr Standard_Real aTol = Precision::Confusion();
const Standard_Real aDu = aSurface->UResolution(aTol);
const Standard_Real aDv = aSurface->VResolution(aTol);
// Cross
// Intersection is out of segments ranges
- const Standard_Real aPrec = Precision::PConfusion();
+ constexpr Standard_Real aPrec = Precision::PConfusion();
const Standard_Real aEndPrec = 1 - aPrec;
for (Standard_Integer i = 0; i < 2; ++i)
{
gp_XY aP1 = thePoint2 - thePoint1;
gp_XY aP2 = thePointToCheck - thePoint1;
- const Standard_Real aPrec = Precision::PConfusion();
+ constexpr Standard_Real aPrec = Precision::PConfusion();
const Standard_Real aSqPrec = aPrec * aPrec;
Standard_Real aDist = Abs(aP1 ^ aP2);
if (aDist > aPrec)
myCellFilter(0., myAllocator),
mySelector (myAllocator)
{
- const Standard_Real aTol = Precision::Confusion();
+ constexpr Standard_Real aTol = Precision::Confusion();
SetCellSize ( aTol + 0.05 * aTol );
SetTolerance( aTol, aTol );
}
BRepOffset_Status& theStatus,
Standard_Boolean allowC0)
{
- Standard_Real Tol = Precision::Confusion();
+ constexpr Standard_Real Tol = Precision::Confusion();
theStatus = BRepOffset_Good;
Handle(Geom_Surface) Result;
Handle(Geom2d_Line) aLin;
Handle(Geom2d_TrimmedCurve) aSegment;
Geom2dConvert_CompCurveToBSplineCurve aCompCurve(aTrCurve, Convert_RationalC1);
- Standard_Real aTol = Precision::Confusion();
+ constexpr Standard_Real aTol = Precision::Confusion();
Standard_Real aDelta = Max(a2Offset, 1.);
if (FirstPar > anEf - a2Offset) {
Handle(Geom_Line) aLin;
Handle(Geom_TrimmedCurve) aSegment;
GeomConvert_CompCurveToBSplineCurve aCompCurve(aTrCurve, Convert_RationalC1);
- Standard_Real aTol = Precision::Confusion();
+ constexpr Standard_Real aTol = Precision::Confusion();
Standard_Real aDelta = Max(a2Offset, 1.);
if (FirstPar > anEf - a2Offset) {
Standard_Real Of = OC.FirstParameter(); Standard_Real Ol = OC.LastParameter();
Standard_Real Nf = NC.FirstParameter(); Standard_Real Nl = NC.LastParameter();
Standard_Real U = 0.;
- Standard_Real ParTol = Precision::PConfusion();
+ constexpr Standard_Real ParTol = Precision::PConfusion();
gp_Pnt P = BRep_Tool::Pnt(V);
Standard_Boolean OK = Standard_False;
BOPTools_AlgoTools::MakeSplitEdge(NE, V1, aT1, V2, aT2, aSourceEdge);
//
//
- Standard_Real aSameParTol = Precision::Confusion();
+ constexpr Standard_Real aSameParTol = Precision::Confusion();
Standard_Real U = 0.;
Standard_Real UMin = Precision::Infinite();
if ( IsClosed)
Edge4 = Edge3;
- Standard_Real TolApp = Precision::Approximation();
+ constexpr Standard_Real TolApp = Precision::Approximation();
Handle(Geom2d_Line) L1,L2;
if ( IsClosed) {
if (!C2d.IsNull()) return;
//Standard_Real Tolerance = Max(Precision::Confusion(),BRep_Tool::Tolerance(E));
- Standard_Real Tolerance = Precision::Confusion();
+ constexpr Standard_Real Tolerance = Precision::Confusion();
BRepAdaptor_Surface AS(F,0);
BRepAdaptor_Curve AC(E);
static Standard_Boolean ToSmall (const Handle(Geom_Curve)& C)
{
- Standard_Real Tol = 10*Precision::Confusion();
+ constexpr Standard_Real Tol = 10*Precision::Confusion();
Standard_Real m = (C->FirstParameter()*0.668 + C->LastParameter()*0.332);
gp_Pnt P1 = C->Value(C->FirstParameter());
gp_Pnt P2 = C->Value(C->LastParameter());
}
}
- Standard_Real aSameParTol = Precision::Confusion();
+ constexpr Standard_Real aSameParTol = Precision::Confusion();
Standard_Boolean isEl1 = Standard_False, isEl2 = Standard_False;
Handle(Geom_Surface) aSurf = BRep_Tool::Surface(F1);
// compute vertices
BRep_Builder B;
- Standard_Real tol = Precision::Confusion();
+ constexpr Standard_Real tol = Precision::Confusion();
TopoDS_Vertex V00,V10,V11,V01;
TopoDS_Vertex NV1,NV2;
TopAbs_Orientation Or;
Standard_Real U1,U2;
- Standard_Real eps = Precision::Confusion();
+ constexpr Standard_Real eps = Precision::Confusion();
#ifdef OCCT_DEBUG
TopLoc_Location L;
const Geom2dAdaptor_Curve& AC,
const TopAbs_State& S )
{
- Standard_Real Def = 100*Precision::Confusion();
+ constexpr Standard_Real Def = 100*Precision::Confusion();
GCPnts_QuasiUniformDeflection QU(AC,Def);
for (Standard_Integer i = 1; i <= QU.NbPoints(); i++) {
TopoDS_Vertex V1, V2;
TopExp::Vertices(theEdge, V1, V2);
- Standard_Real Tol = Precision::Confusion();
+ constexpr Standard_Real Tol = Precision::Confusion();
Standard_Integer i;
TopExp_Explorer Explo(theFace, TopAbs_EDGE);
static Standard_Real PreciseUpar(const Standard_Real anUpar,
const Handle(Geom_BSplineSurface)& aSurface)
{
- Standard_Real Tol = Precision::PConfusion();
+ constexpr Standard_Real Tol = Precision::PConfusion();
Standard_Integer i1, i2;
aSurface->LocateU(anUpar, Tol, i1, i2);
void BRepSweep_Trsf::SetContinuity(const TopoDS_Shape& aGenS,
const Sweep_NumShape& aDirS)
{
- Standard_Real tl = Precision::Confusion(), tol3d;
+ constexpr Standard_Real tl = Precision::Confusion();
//angular etant un peu severe pour les contours sketches.
Standard_Real ta = 0.00175;//environ 0.1 degre
GeomAbs_Shape cont;
TopExp::Vertices(E,d,f);
if(d.IsSame(f)){
// tol3d = Max(tl,BRep_Tool::Tolerance(d));
- tol3d = Max(tl,2.*BRep_Tool::Tolerance(d));//IFV 24.05.00 buc60684
+ const Standard_Real tol3d = Max(tl,2.*BRep_Tool::Tolerance(d));//IFV 24.05.00 buc60684
e.Initialize(E);
ud = BRep_Tool::Parameter(d,TopoDS::Edge(aGenS));
uf = BRep_Tool::Parameter(f,TopoDS::Edge(aGenS));
u1 = BRep_Tool::Parameter(V,E1);
u2 = BRep_Tool::Parameter(V,E2);
// tol3d = Max(tl,BRep_Tool::Tolerance(V));
- tol3d = Max(tl,2.*BRep_Tool::Tolerance(V)); //IFV 24.05.00 buc60684
+ const Standard_Real tol3d = Max(tl,2.*BRep_Tool::Tolerance(V)); //IFV 24.05.00 buc60684
e1.Initialize(E1);
e2.Initialize(E2);
cont = BRepLProp::Continuity(e1,e2,u1,u2,tol3d,ta);
BRep_Builder B;
Standard_Integer NbV = 0;
- Standard_Real Tol = Precision::PConfusion();
+ constexpr Standard_Real Tol = Precision::PConfusion();
Standard_Boolean rejectreducedsegmentpoints = Standard_True;
EInter.InitPoint(rejectreducedsegmentpoints);
if (ASI.IsDone()) {
Standard_Integer no=1, IndFrom, IndTo;
TopAbs_Orientation theOr;
- Standard_Real min = 1.e-04, Tol = -Precision::Confusion();
+ constexpr Standard_Real min = 1.e-04, Tol = -Precision::Confusion();
if (ASI.LocalizeAfter (no, min, Tol, theOr, IndFrom, IndTo)) {
nextFace = ASI.Point(no, IndFrom).Face();
break;
if (aS->DynamicType() == STANDARD_TYPE(Geom_BSplineSurface) &&
(aXmin < aUmin || aXmax > aUmax))
{
- Standard_Real aTol2 = 100 * Precision::Confusion() * Precision::Confusion();
+ constexpr Standard_Real aTol2 = 100 * Precision::Confusion() * Precision::Confusion();
isUPeriodic = Standard_True;
gp_Pnt P1, P2;
// 1. Verify that the surface is U-closed
if (aS->DynamicType() == STANDARD_TYPE(Geom_BSplineSurface) &&
(aYmin < aVmin || aYmax > aVmax))
{
- Standard_Real aTol2 = 100 * Precision::Confusion() * Precision::Confusion();
+ constexpr Standard_Real aTol2 = 100 * Precision::Confusion() * Precision::Confusion();
isVPeriodic = Standard_True;
gp_Pnt P1, P2;
// 1. Verify that the surface is V-closed
// if not found call BRepLib::BuildCurve3d
TopLoc_Location Loc;
- Standard_Real Tol = Precision::Confusion();
+ constexpr Standard_Real Tol = Precision::Confusion();
// Search only isos on analytical surfaces.
Geom2dAdaptor_Curve C(Curve);
MakeCurve_Function F(HC);
Standard_Integer Deg1, Deg2;
Deg1 = Deg2 = 8;
- Standard_Real Tol = Precision::Approximation();
+ constexpr Standard_Real Tol = Precision::Approximation();
Approx_FitAndDivide Fit(F,Deg1,Deg2,Tol,Tol,Standard_True);
Standard_Integer i;
Standard_Integer NbCurves = Fit.NbMultiCurves();
const TopoDS_Vertex& VfOnE)
{
BRep_Builder B;
- Standard_Real Tol = Precision::Confusion();
+ constexpr Standard_Real Tol = Precision::Confusion();
// kill trimmed curves
Handle(Geom_Curve) C = CC;
Handle(Geom_TrimmedCurve) CT = Handle(Geom_TrimmedCurve)::DownCast(C);
Standard_Boolean thesense = Standard_False,sense;
Standard_Real distancemini;
Standard_Integer nbsolution;
- Standard_Real PreConf = Precision::Confusion();
+ constexpr Standard_Real PreConf = Precision::Confusion();
Handle(Standard_Type) type1 = afirstcurve->DynamicType();
Handle(Standard_Type) type2 = asecondcurve->DynamicType();
Standard_Real U,UC1,UC2,Dist,dU,USol;
gp_Pnt2d P;
Standard_Integer NbPnts = 21;
- Standard_Real EpsMin = 10*Precision::Confusion();
+ constexpr Standard_Real EpsMin = 10*Precision::Confusion();
Standard_Boolean YaPoly = Standard_True;
Standard_Boolean OriInPoly = Standard_False;
//---------------------------------------------
Standard_Real UMid,Dist1,Dist2,DistMid,U11,U22;
Standard_Real UC1,UC2;
gp_Pnt2d PBis,PBisPrec;
- Standard_Real TolPnt = Precision::Confusion();
- Standard_Real TolPar = Precision::PConfusion();
+ constexpr Standard_Real TolPnt = Precision::Confusion();
+ constexpr Standard_Real TolPar = Precision::PConfusion();
U11 = U1; U22 = U2;
PBisPrec = ValueByInt(U11,UC1,UC2,Dist1);
PBis = ValueByInt(U22,UC1,UC2,Dist2);
{
Standard_Real Dist1,DistMid,U11,U22;
Standard_Real UMid = 0.;
- Standard_Real Tol = Precision::PConfusion();
+ constexpr Standard_Real Tol = Precision::PConfusion();
Standard_Real DistMax2 = distMax*distMax;
U11 = U1; U22 = U2;
Dist1 = Distance(U11);
//==========================================================================
Standard_Real Bisector_BisecPC::Parameter(const gp_Pnt2d& P) const
{
- Standard_Real Tol = Precision::Confusion();
+ constexpr Standard_Real Tol = Precision::Confusion();
if (P.IsEqual(pointStartBis,Tol)) {return startIntervals.Value(bisInterval);}
if (P.IsEqual(pointEndBis ,Tol)) {return endIntervals .Value(bisInterval);}
{
Standard_Real USol,U1,U2,Dist;
Standard_Real UMin =0.,UMax =0.;
- Standard_Real Eps = Precision::PConfusion();
+ constexpr Standard_Real Eps = Precision::PConfusion();
gp_Pnt2d PSol;
Handle(Geom2d_Curve) Guide;
zmin = P.Z() - R;
zmax = P.Z() + R;
- Standard_Real uper = 2. * M_PI - Precision::PConfusion();
- Standard_Real vper = M_PI - Precision::PConfusion();
+ constexpr Standard_Real uper = 2. * M_PI - Precision::PConfusion();
+ constexpr Standard_Real vper = M_PI - Precision::PConfusion();
if (UMax - UMin >= uper && VMax - VMin >= vper)
{
// a whole sphere
Standard_Real aPhi = ACos (-aRa / aRi);
- Standard_Real anUper = 2. * M_PI - Precision::PConfusion();
+ constexpr Standard_Real anUper = 2. * M_PI - Precision::PConfusion();
Standard_Real aVper = 2. * aPhi - Precision::PConfusion();
if (theUMax - theUMin >= anUper && theVMax - theVMin >= aVper)
{
}
//
- const Standard_Real eps = Precision::PConfusion();
+ constexpr Standard_Real eps = Precision::PConfusion();
if (fabs(aT1-aTb[0]) > eps || fabs(aT2-aTb[1]) > eps) {
aG=aCBS->Copy();
//
Standard_Real UOnCyl,VOnCyl,UOnPln,VOnPln;
ElSLib::Parameters(Cyl,OrFillet,UOnCyl,VOnCyl);
- Standard_Real tesp = Precision::Confusion();
+ constexpr Standard_Real tesp = Precision::Confusion();
if(UOnCyl < fu - tesp || UOnCyl > lu + tesp)
UOnCyl = ElCLib::InPeriod(UOnCyl,fu,fu+2*M_PI);
ElSLib::Parameters(Pln,OrFillet,UOnPln,VOnPln);
//-- ------------------------------------------------------------
//-- on decoupe la ligne en portions entre 2 vertex
- Standard_Real Tol = Precision::PConfusion();
+ constexpr Standard_Real Tol = Precision::PConfusion();
Contap_IType typl = L.TypeContour();
//-- std::cout<<"\n ----------- Ligne Constructor "<<std::endl;
if(typl == Contap_Walking) {
//Patch
Standard_Real FirstPar = GC->FirstParameter(), LastPar = GC->LastParameter();
- Standard_Real pconf = Precision::PConfusion();
+ constexpr Standard_Real pconf = Precision::PConfusion();
if (Abs( paramf - LastPar ) <= pconf)
{
paramf = FirstPar;
{
// pf >= pl
Standard_Real FirstPar = theCurve->FirstParameter(), LastPar = theCurve->LastParameter();
- Standard_Real pconf = Precision::PConfusion();
+ constexpr Standard_Real pconf = Precision::PConfusion();
if (Abs( pf - LastPar ) <= pconf)
pf = FirstPar;
else if (Abs( pl - FirstPar ) <= pconf)
const Handle(Geom_Surface)& S2)
{
Handle( Geom2d_Curve ) NewC2d;
- Standard_Real Tol = Precision::Confusion();
+ constexpr Standard_Real Tol = Precision::Confusion();
Standard_Real Etol = EdgeTol;
Handle( Geom2d_Curve ) pcu1 = Einf.FirstPC();
GeomAPI_ProjectPointOnCurve ProjectorOnCurve;
Standard_Real U1, V1, U2, V2;
Standard_Real LastU, LastV;
- Standard_Real SquareTolerance = Precision::SquareConfusion();
+ constexpr Standard_Real SquareTolerance = Precision::SquareConfusion();
ProjectorOnSurface.Init( AttachmentPoint1, SecondSurf );
Standard_Integer Index(1);
Standard_Integer aNbExt = anExtC.NbExt();
Standard_Integer i;
Standard_Integer aCurI = 1;
- Standard_Real aTolConf = Precision::Confusion();
+ constexpr Standard_Real aTolConf = Precision::Confusion();
Standard_Real aCylRad = S.Radius();
// Check whether two objects have intersection points
Standard_Real Usol[2];
Usol[0] = C.XAxis().Direction().AngleWithRef(OPp,Axe); // -M_PI<U1<M_PI
- const Standard_Real aAngTol = Precision::Angular();
+ constexpr Standard_Real aAngTol = Precision::Angular();
if ( Usol[0] + M_PI < aAngTol )
Usol[0] = -M_PI;
else if ( Usol[0] - M_PI > -aAngTol )
std::cout <<"F(1)= "<<Sol(1)<<" F(2)= "<<Sol(2)<<" F(3)= "<<Sol(3)<<std::endl;
#endif
//comparison of solution with previous solutions
- Standard_Real tol2d = Precision::SquarePConfusion();
+ constexpr Standard_Real tol2d = Precision::SquarePConfusion();
Standard_Integer i = 1, nbSol = mySqDist.Length();
for( ; i <= nbSol; i++)
{
if (!myPinit || !mySinit) throw Standard_TypeMismatch();
//comparison of solution with previous solutions
Standard_Integer i = 1, nbSol = mySqDist.Length();
- Standard_Real tol2d = Precision::PConfusion() * Precision::PConfusion();
+ constexpr Standard_Real tol2d = Precision::PConfusion() * Precision::PConfusion();
for( ; i <= nbSol; i++)
{
Standard_Integer i, NbExt, n;
Standard_Real U;
mysample = 17;
- Standard_Real t3d = Precision::Confusion();
+ constexpr Standard_Real t3d = Precision::Confusion();
if (Precision::IsInfinite(myuinf)) mydist1 = RealLast();
else {
Pf = TheCurveTool::Value(*((TheCurve*)myC), myuinf);
aSqDists.Clear();
aPntsOnCrv.Clear();
aPntsOnSurf.Clear();
- Standard_Real aTol = Precision::SquareConfusion();
+ constexpr Standard_Real aTol = Precision::SquareConfusion();
for (i = 1; i <= aSqDists1.Length(); ++i)
{
Standard_Real aDist = aSqDists1(i);
math_Vector& theTol)
{
//Correct tolerance for large values of UV parameters
- Standard_Real aTolRef = Precision::PConfusion();
+ constexpr Standard_Real aTolRef = Precision::PConfusion();
Standard_Real anEpsRef = Epsilon(1.);
Standard_Real epsu = Epsilon(theU0);
const Standard_Real tolog10 = 0.43429;
//
if (myS->IsUPeriodic())
{
- Standard_Real aTMax = 2. * M_PI + Precision::PConfusion();
+ constexpr Standard_Real aTMax = 2. * M_PI + Precision::PConfusion();
if (myUf > aTMax || myUf < -Precision::PConfusion() ||
Abs(myUl - myUf) > aTMax)
{
}
if (myS->IsVPeriodic())
{
- Standard_Real aTMax = 2. * M_PI + Precision::PConfusion();
+ constexpr Standard_Real aTMax = 2. * M_PI + Precision::PConfusion();
if (myVf > aTMax || myVf < -Precision::PConfusion() ||
Abs(myVl - myVf) > aTMax)
{
myTl = theTl;
if (myC->IsPeriodic())
{
- Standard_Real aTMax = 2. * M_PI + Precision::PConfusion();
+ constexpr Standard_Real aTMax = 2. * M_PI + Precision::PConfusion();
if (myTf > aTMax || myTf < -Precision::PConfusion() ||
Abs(myTl - myTf) > aTMax)
{
gp_Vec T, N;
D2 (theC, theU, theP, T, N);
Standard_Real Lt = T.Magnitude();
- Standard_Real LTol = Precision::Confusion();
+ constexpr Standard_Real LTol = Precision::Confusion();
if (Lt > LTol && N.Magnitude () > LTol)
{
Standard_Real Lc = N.CrossMagnitude (T);
const Standard_Real theParam,
const Standard_Boolean theIsReplace)
{
- const Standard_Real tol = Precision::PConfusion();
+ constexpr Standard_Real tol = Precision::PConfusion();
Standard_Integer index = -1;
const Standard_Integer nb = myParameters.Length();
for ( Standard_Integer i = 1; index == -1 && i <= nb; i++ )
{
Standard_ConstructionError_Raise_if(theRadius < 0.0, "Negative radius");
- const Standard_Real aPrecision = Precision::Confusion();
+ constexpr Standard_Real aPrecision = Precision::Confusion();
Standard_Real Du = 0.0, aMinSizeAng = 0.0;
if (theRadius > aPrecision)
Standard_Real Du, Dusave, MiddleU, L1, L2;
Standard_Real U1 = myFirstu;
- Standard_Real LTol = Precision::Confusion(); // protection longueur nulle
+ constexpr Standard_Real LTol = Precision::Confusion(); // protection longueur nulle
Standard_Real ATol = 1.e-2 * myAngularDeflection;
if (ATol > 1.e-2)
{
//=========================================================================
WellDone = Standard_False;
- Standard_Real Tol=Precision::Confusion();
+ constexpr Standard_Real Tol=Precision::Confusion();
Standard_Real R1 = Circ1.Radius();
Standard_Real R2 = Circ2.Radius();
// et la mettre en champ, on pourrait utiliser par exemple pour l'extraction d'iso
// et aussi pour les singularite. Pour les surfaces osculatrices, on l'utilise pour
// detecter si une iso est degeneree.
- const Standard_Real Tol = Precision::Confusion(); //0.0001;
+ constexpr Standard_Real Tol = Precision::Confusion(); //0.0001;
myOscSurf = new Geom_OsculatingSurface(aCheckingSurf, Tol);
}
{
if (offsetValue == 0.0) return basisSurf; // Cas direct
- Standard_Real Tol = Precision::Confusion();
+ constexpr Standard_Real Tol = Precision::Confusion();
Handle(Geom_Surface) Result, Base;
Result.Nullify();
Handle(Standard_Type) TheType = basisSurf->DynamicType();
Intp.Perform(C1,C2,Tol,Tol);
if (Intp.IsDone()) {
if (!Intp.IsEmpty()) {
- const Standard_Real aSQApproxTol = Precision::Approximation() *
+ constexpr Standard_Real aSQApproxTol = Precision::Approximation() *
Precision::Approximation();
for (Standard_Integer i = 1; i <= Intp.NbPoints() && NbrSol < aNbSolMAX; i++)
{
myTotalExt = Standard_False;
- Standard_Real Tol = Precision::PConfusion();
+ constexpr Standard_Real Tol = Precision::PConfusion();
myC1.Load(C1);
myC2.Load(C2);
myTotalExt = Standard_False;
- Standard_Real Tol = Precision::PConfusion();
+ constexpr Standard_Real Tol = Precision::PConfusion();
myC1.Load(C1);
myC2.Load(C2);
GeomAdaptor_Curve TheCurve (Curve);
GeomAdaptor_Surface TheSurface (Surface);
- Standard_Real Tol = Precision::PConfusion();
+ constexpr Standard_Real Tol = Precision::PConfusion();
myExtCS.Initialize (TheSurface, Tol, Tol);
myExtCS.Perform (TheCurve, TheCurve.FirstParameter(), TheCurve.LastParameter());
myIsDone = myExtCS.IsDone() && (myExtCS.IsParallel() || myExtCS.NbExt() > 0);
GeomAdaptor_Curve TheCurve (Curve, Wmin, Wmax);
GeomAdaptor_Surface TheSurface (Surface, Umin, Umax, Vmin, Vmax);
- Standard_Real Tol = Precision::PConfusion();
+ constexpr Standard_Real Tol = Precision::PConfusion();
myExtCS.Initialize (TheSurface,
Umin,Umax,Vmin,Vmax,Tol,Tol);
myExtCS.Perform (TheCurve, Wmin, Wmax);
GeomAdaptor_Surface TheSurface1 (S1);
GeomAdaptor_Surface TheSurface2 (S2);
- Standard_Real Tol = Precision::PConfusion();
+ constexpr Standard_Real Tol = Precision::PConfusion();
Extrema_ExtSS theExtSS(TheSurface1, TheSurface2,Tol,Tol);
myExtSS = theExtSS;
GeomAdaptor_Surface TheSurface1 (S1,U1min,U1max,V1min,V1max);
GeomAdaptor_Surface TheSurface2 (S2,U2min,U2max,V2min,V2max);
- Standard_Real Tol = Precision::PConfusion();
+ constexpr Standard_Real Tol = Precision::PConfusion();
Extrema_ExtSS theExtSS(TheSurface1, TheSurface2,
U1min,U1max,V1min,V1max,
U2min,U2max,V2min,V2max,
const Standard_Real Vsup,
const Extrema_ExtAlgo theProjAlgo)
{
- Standard_Real Tolerance = Precision::PConfusion();
+ constexpr Standard_Real Tolerance = Precision::PConfusion();
//modified by NIZNHY-PKV Thu Apr 4 10:38:23 2002 f
//GeomAdaptor_Surface TheSurface (Surface,Umin,Usup,Vmin,Vsup);
//myExtPS = Extrema_ExtPS (P, TheSurface, Tol, Tol);
const Standard_Real Vsup,
const Extrema_ExtAlgo theProjAlgo)
{
- Standard_Real Tolerance = Precision::PConfusion();
+ constexpr Standard_Real Tolerance = Precision::PConfusion();
//modified by NIZNHY-PKV Thu Apr 4 10:41:50 2002 f
//GeomAdaptor_Surface TheSurface (Surface,Umin,Usup,Vmin,Vsup);
myGeomAdaptor.Load(Surface, Umin,Usup,Vmin,Vsup);
Standard_Real newFirst, newLast;
BSplCLib::LocateParameter(Degree,TK,TM,PFirst,IsPeriodic,1,Nb,Index1,newFirst);
BSplCLib::LocateParameter(Degree,TK,TM,PLast, IsPeriodic,1,Nb,Index2,newLast );
- const Standard_Real EpsKnot = Precision::PConfusion();
+ constexpr Standard_Real EpsKnot = Precision::PConfusion();
if (Abs(newFirst-TK(Index1+1))< EpsKnot) Index1++;
if (Abs(newLast -TK(Index2 ))< EpsKnot) Index2--;
// attention aux courbes peridiques.
Handle(Adaptor3d_Surface) GeomAdaptor_SurfaceOfRevolution::UTrim (const Standard_Real First, const Standard_Real Last, const Standard_Real Tol) const
{
- const Standard_Real Eps = Precision::PConfusion();
+ constexpr Standard_Real Eps = Precision::PConfusion();
(void )Eps; (void )First; (void )Last; (void )Tol;
Standard_OutOfRange_Raise_if
( Abs(First) > Eps || Abs(Last - 2.*M_PI) > Eps,
GeomAbs_SurfaceType GeomAdaptor_SurfaceOfRevolution::GetType() const
{
- Standard_Real TolConf = Precision::Confusion();
- Standard_Real TolAng = Precision::Angular();
- Standard_Real TolConeSemiAng = Precision::Confusion();
+ constexpr Standard_Real TolConf = Precision::Confusion();
+ constexpr Standard_Real TolAng = Precision::Angular();
+ constexpr Standard_Real TolConeSemiAng = Precision::Confusion();
switch (myBasisCurve->GetType()) {
case GeomAbs_Line: {
}
Handle(Geom_Curve) res;
- Standard_Real prec = Precision::PConfusion();
+ constexpr Standard_Real prec = Precision::PConfusion();
Standard_Real AF,BF,CF,DF,EF,Q1,Q2,Q3,c2n;
Standard_Integer i;
aLBnd(4) = aStartPoint(4) + aDR;
//
- Standard_Real aTol = Precision::Confusion();
+ constexpr Standard_Real aTol = Precision::Confusion();
math_MultipleVarFunction* aPFunc;
GeomConvert_FuncCylinderLSDist aFuncCyl(thePoints, thePos.Direction());
aPFunc = (math_MultipleVarFunction*)&aFuncCyl;
Standard_Real U1, U2, V1, V2;
mySurf->Bounds(U1, U2, V1, V2);
Standard_Boolean aDoSegment = Standard_False;
- Standard_Real aTolBnd = Precision::PConfusion();
+ constexpr Standard_Real aTolBnd = Precision::PConfusion();
Standard_Integer isurf = 0;
if (Umin < U1 || Umax > U2 || Vmin < V1 || Vmax > V2)
{
// On ordonne les courbes
Handle(Geom_BSplineCurve) CC1, CC2, CC3, CC4;
- Standard_Real Tol = Precision::Confusion();
+ constexpr Standard_Real Tol = Precision::Confusion();
#ifndef No_Exception
Standard_Boolean IsOK =
#endif
}
}
else {
- Standard_Real Eps = Precision::Confusion();
+ constexpr Standard_Real Eps = Precision::Confusion();
Standard_Boolean IsOK = Standard_False;
if ( CC1->StartPoint().IsEqual(CC2->StartPoint(),Eps)) {
IsOK = Standard_True;
TColStd_Array1OfReal& W3,
TColStd_Array1OfReal& W4 )
{
- Standard_Real Eps = Precision::Confusion();
+ constexpr Standard_Real Eps = Precision::Confusion();
Standard_Integer NU = W1.Length();
Standard_Integer NV = W2.Length();
// On ordonne les courbes
Handle(Geom_BezierCurve) CC1, CC2, CC3, CC4;
- Standard_Real Tol = Precision::Confusion();
+ constexpr Standard_Real Tol = Precision::Confusion();
#ifndef No_Exception
Standard_Boolean IsOK =
#endif
TColgp_Array1OfPnt P1(1,Deg1+1);
TColgp_Array1OfPnt P2(1,Deg2+1);
- Standard_Real Eps = Precision::Confusion();
+ constexpr Standard_Real Eps = Precision::Confusion();
Standard_Boolean IsOK = Standard_False;
if ( CC1->StartPoint().IsEqual(CC2->StartPoint(),Eps)) {
IsOK = Standard_True;
TColStd_SequenceOfReal& Seq)
{
Standard_Integer ind1=1, ind2=1;
- Standard_Real Epspar = Precision::PConfusion()*0.99;
+ constexpr Standard_Real Epspar = Precision::PConfusion()*0.99;
// en suposant que le positionement fonctionne a PConfusion()/2
Standard_Real v1, v2;
// Initialisations : les IND1 et IND2 pointent sur le 1er element
void GeomFill_CircularBlendFunc::SetInterval(const Standard_Real First,
const Standard_Real Last)
{
- Standard_Real Eps = Precision::PConfusion();
+ constexpr Standard_Real Eps = Precision::PConfusion();
myTPath = myPath->Trim(First, Last, Eps);
myTCurve1 = myCurve1->Trim(First, Last, Eps);
myTCurve2 = myCurve2->Trim(First, Last, Eps);
{
//Locate <Param> in the sequence <myKnots>
Standard_Integer Index = -1;
- Standard_Real TolPar = Precision::PConfusion();
+ constexpr Standard_Real TolPar = Precision::PConfusion();
//Standard_Real TolConf = Precision::Confusion();
Standard_Integer NbSamples = 10;
gp_Pnt Origin(0.,0.,0.);
{
Standard_Integer i, j;
GeomFill_SnglrFunc Func(myCurve);
- Standard_Real TolF = 1.0e-10, Tol = 10*TolF, Tol2 = Tol * Tol,
- PTol = Precision::PConfusion();
+ constexpr Standard_Real TolF = 1.0e-10;
+ constexpr Standard_Real Tol = 10 * TolF;
+ constexpr Standard_Real Tol2 = Tol * Tol;
+ constexpr Standard_Real PTol = Precision::PConfusion();
// We want to determine if the curve has linear segments
Standard_Integer NbIntC2 = myCurve->NbIntervals(GeomAbs_C2);
}
- Standard_Real ww, EpsW = 10*Precision::PConfusion();
+ Standard_Real ww;
+ constexpr Standard_Real EpsW = 10*Precision::PConfusion();
Standard_Boolean NullWeight = Standard_False;
if (!rational) DWeights.Init(0.);
Standard_Integer indice = 1, ii;
}
- Standard_Real ww, EpsW = 10*Precision::PConfusion();
+ Standard_Real ww;
+ constexpr Standard_Real EpsW = 10*Precision::PConfusion();
Standard_Boolean NullWeight = Standard_False;
if (!rational) D2Weights.Init(0.);
Standard_Integer indice = 1, ii;
Handle(GeomFill_Line) Line = new GeomFill_Line(Section.NbSections());
Standard_Integer NbIt = 0;
- Standard_Real T3d = Precision::Approximation();
- Standard_Real T2d = Precision::PApproximation();
+ constexpr Standard_Real T3d = Precision::Approximation();
+ constexpr Standard_Real T2d = Precision::PApproximation();
GeomFill_AppSweep App( 4, 8, T3d, T2d, NbIt, WithParameters);
App.Perform( Line, Section, 30);
if (aC2D.IsNull() || !aS->IsUPeriodic())
return;
//
- const Standard_Real aEps=Precision::PConfusion();//1.e-9
+ constexpr Standard_Real aEps=Precision::PConfusion();//1.e-9
const Standard_Real aEpsilon=Epsilon(10.);//1.77e-15
//
Standard_Real umin,umax,vmin,vmax;
const Standard_Real theFirstPar,
const Standard_Real theLastPar)
{
- const Standard_Real aSqTol = Precision::Confusion()*Precision::Confusion();
+ constexpr Standard_Real aSqTol = Precision::Confusion()*Precision::Confusion();
gp_Pnt2d aP2d;
gp_Pnt aP1, aP2;
}
}
- const Standard_Real anIntTol = 10.0*Precision::Confusion();
+ constexpr Standard_Real anIntTol = 10.0*Precision::Confusion();
IntersectCurveAndBoundary(theC2d1, aCurS1Bounds,
aNumberOfCurves, anIntTol, theArrayOfParameters);
{
Standard_Integer i,nbvtx;
Standard_Real firstp,lastp;
- const Standard_Real Tol = Precision::PConfusion() * 35.0;
+ constexpr Standard_Real Tol = Precision::PConfusion() * 35.0;
const IntPatch_IType typl = L->ArcType();
if(typl == IntPatch_Analytic) {
// About the value aTolPC=1000.*Precision::PConfusion(),
// see IntPatch_GLine::ComputeVertexParameters(...)
// for more details;
- const Standard_Real aTolPC = 1000.*Precision::PConfusion();
+ constexpr Standard_Real aTolPC = 1000.*Precision::PConfusion();
//Find duplicates in a slice of the array [LowerBound, UpperBound-1].
//If a duplicate has been found, the element with greater index will be rejected.
const Standard_Real Vmin,
const Standard_Real Vsup )
{
- const Standard_Real Tolerance = Precision::PConfusion();
+ constexpr Standard_Real Tolerance = Precision::PConfusion();
//
myGeomAdaptor.Load(Surface, Umin,Usup,Vmin,Vsup);
myExtPS.Initialize(myGeomAdaptor, Umin, Usup, Vmin, Vsup, Tolerance, Tolerance);
Handle(Geom_BSplineSurface)::DownCast (Surface);
if (BS.IsNull()) {
//BS = GeomConvert::SurfaceToBSplineSurface(Surface);
- Standard_Real Tol = Precision::Confusion(); //1.e-4;
+ constexpr Standard_Real Tol = Precision::Confusion(); //1.e-4;
GeomAbs_Shape UCont = GeomAbs_C1, VCont = GeomAbs_C1;
Standard_Integer degU = 14, degV = 14;
Standard_Integer nmax = 16;
// || ( !InU && BS->IsVRational() ) ;
Standard_Boolean rational = (BS->IsURational() || BS->IsVRational());
Standard_Boolean NullWeight;
- Standard_Real EpsW = 10*Precision::PConfusion();
+ constexpr Standard_Real EpsW = 10*Precision::PConfusion();
Standard_Integer gap = 3;
if ( rational ) gap++;
Standard_Real gx,gy,gz;
gp_Pnt Bary;
gp_Dir DX, DY;
- Standard_Real aTolSingular = Precision::Confusion();
+ constexpr Standard_Real aTolSingular = Precision::Confusion();
GeomLib::Inertia(Poles, Bary, DX, DY, gx, gy, gz);
aFunc.GetLine(theLine);
- const Standard_Real aTolDefl = Precision::PConfusion();
+ constexpr Standard_Real aTolDefl = Precision::PConfusion();
Standard_Real aD1 = 0.0;
Standard_Real aD2 = 0.0;
for ( i = 1; i < Poles.Length(); i++)
Normal += Poles ( i ).XYZ() ^ Poles ( i + 1 ).XYZ();
- Standard_Real tol = Precision::Confusion();
+ constexpr Standard_Real tol = Precision::Confusion();
Standard_Real nrm = Normal.Modulus();
if ( nrm < tol ) {
Normal.SetCoord ( 0, 0, 1 );
GeomAdaptor_Curve GAC(ellip);
di<<"Type Of curve: "<<GAC.GetType()<<"\n";
- Standard_Real Tol = Precision::Confusion();
+ constexpr Standard_Real Tol = Precision::Confusion();
Standard_Real L;
L = GCPnts_AbscissaPoint::Length(GAC, GAC.FirstParameter(), GAC.LastParameter(), Tol);
GeomAdaptor_Curve GAC(ellip);
di<<"Type Of curve: "<<GAC.GetType()<<"\n";
- Standard_Real Tol = Precision::Confusion();
+ constexpr Standard_Real Tol = Precision::Confusion();
Standard_Real L;
L = GCPnts_AbscissaPoint::Length(GAC, GAC.FirstParameter(), GAC.LastParameter(), Tol);
Standard_Real xTrianMax,yTrianMax,zTrianMax;
Standard_Real xSegmnMin,ySegmnMin,zSegmnMin;
Standard_Real xSegmnMax,ySegmnMax,zSegmnMax;
- Standard_Real Big = Precision::Infinite();
+ constexpr Standard_Real Big = Precision::Infinite();
HLRAlgo_PolyData::Box aBox(Big, Big, Big, -Big, -Big, -Big);
myNbrShell = myHShell.Size();
TopoDS_Vertex V1, V2, V1new, V2new;
TopExp::Vertices(anEdge, V1, V2);
- Standard_Real Tol = Precision::PConfusion();
+ constexpr Standard_Real Tol = Precision::PConfusion();
if (Abs(fpar - U1) <= Tol)
V1new = V1;
else
//The dimensions should be also obliged:
//[a]=[b]=[c]=L^-2
//if ( (Abs(a-c) <= GetEpsGeom()) && (Abs(b) < GetEpsCoeff()))
- Standard_Real eps2 = Precision::PConfusion() * Precision::PConfusion();
+ constexpr Standard_Real eps2 = Precision::PConfusion() * Precision::PConfusion();
if ( (Abs(a-c) <= eps2) && (Abs(b) < eps2)) {
// =================
//#60 rln 29.12.98 PRO17015
//if ( (Abs(a-c) <= GetEpsGeom()) && (Abs(b) < GetEpsCoeff()))
- Standard_Real eps2 = Precision::PConfusion() * Precision::PConfusion();
+ constexpr Standard_Real eps2 = Precision::PConfusion() * Precision::PConfusion();
if ( (Abs(a-c) <= eps2) && (Abs(b) < eps2)) {
// =================
{
const Standard_Real aPIpPI = M_PI + M_PI,
anEpsAng = 1.e-8,
- InternalPrecision = 1.e-8, //precision of internal algorithm of values computation
- aSqTolPrecision = Precision::SquareConfusion(); //for boundary points to check their coincidence with others
+ InternalPrecision = 1.e-8; //precision of internal algorithm of values computation
+ constexpr Standard_Real aSqTolPrecision = Precision::SquareConfusion(); //for boundary points to check their coincidence with others
Standard_Real aTheta = 0.0;
//
//IsARoot
Standard_Boolean IsARoot(Standard_Real u) {
Standard_Integer i;
- Standard_Real aEps=RealEpsilon();
+ constexpr Standard_Real aEps=RealEpsilon();
Standard_Real PIpPI = M_PI + M_PI;
//
for(i=0 ; i<NbRoots; ++i) {
}
case GeomAbs_Cone:
{
- const Standard_Real correction = 1.E+5*Precision::Angular();
+ constexpr Standard_Real correction = 1.E+5*Precision::Angular();
gp_Cone cn = TheSurfaceTool::Cone(surface);
if(Abs(cn.SemiAngle()) < M_PI/2.0 - correction) {
IntAna_IntConicQuad LinCone(Line, cn);
Handle(Adaptor3d_Curve) aBasisCurve = TheSurfaceTool::BasisCurve(surface);
gp_Ax1 aRevAx = TheSurfaceTool::AxeOfRevolution(surface);
gp_Vec aXVec = aRevAx.Direction();
- Standard_Real aTolAng = Precision::Angular();
+ constexpr Standard_Real aTolAng = Precision::Angular();
// make plane to project a basis curve
gp_Pnt O = aRevAx.Location();
while(par<pf) par+=M_PI+M_PI;
while(par>pl) par-=M_PI+M_PI;
if(par<pf) {
- const Standard_Real PrecisionPConfusion ( Precision::PConfusion()*1000.0 );
+ constexpr Standard_Real PrecisionPConfusion ( Precision::PConfusion()*1000.0 );
if((pf-par)>PrecisionPConfusion) {
return;
}
Standard_Integer nbvtx = NbVertex();
- const Standard_Real PrecisionPConfusion ( Precision::PConfusion()*1000.0 );
+ constexpr Standard_Real PrecisionPConfusion ( Precision::PConfusion()*1000.0 );
do {
APointDeleted = Standard_False;
}
const Standard_Real aDeltaUmax = M_PI_2;
- const Standard_Real aTOL3D = 1.e-10,
- aTOL2D = Precision::PConfusion(),
- aTOL2DS = Precision::PConfusion();
+ constexpr Standard_Real aTOL3D = 1.e-10,
+ aTOL2D = Precision::PConfusion(),
+ aTOL2DS = Precision::PConfusion();
const Handle(IntSurf_LineOn2S)& aSLine = theLine->Curve();
////
const IntSurf_PntOn2S& aRefPt = aSSLine->Value(aBindex-1);
- Standard_Real aCompareTol3D = Precision::Confusion();
+ constexpr Standard_Real aCompareTol3D = Precision::Confusion();
Standard_Real aCompareTol2D = Precision::PConfusion();
IntSurf_PntOn2S aNewPoint = aRefPt;
}
//
const Standard_Integer aNbBndPnts = 5;
- const Standard_Real aTol = Precision::Confusion();
+ constexpr Standard_Real aTol = Precision::Confusion();
Standard_Integer i;
theD1->Init();
Standard_Boolean isU = Standard_True;
//Singular point aPP1;
aPmid /= aNb;
aPP1.SetXYZ(aPmid);
- Standard_Real aTolU = Precision::PConfusion(), aTolV = Precision::PConfusion();
+ constexpr Standard_Real aTolU = Precision::PConfusion(), aTolV = Precision::PConfusion();
Extrema_ExtPS aProj(aPP1, *theS2.get(), aTolU, aTolV, Extrema_ExtFlag_MIN);
if (aProj.IsDone())
Standard_Real anUVMaxStep = 0.001;
Standard_Real aDistToSing1 = Precision::Infinite();
Standard_Real aDistToSing2 = Precision::Infinite();
- const Standard_Real aTolMin = Precision::Confusion(), aTolMax = 1.e-5;
+ constexpr Standard_Real aTolMin = Precision::Confusion(), aTolMax = 1.e-5;
if (theS1 != theS2)
{
Standard_Boolean isSing1 = CheckSingularPoints(theS1, theD1, theS2, aDistToSing1);
const Handle(Adaptor3d_Surface)& theS2,
const IntSurf_PntOn2S& theUVPoint)
{
- const Standard_Real aSmallValue = 1.0/Precision::Infinite();
- const Standard_Real aSqSmallValue = aSmallValue*aSmallValue;
+ constexpr Standard_Real aSmallValue = 1.0/Precision::Infinite();
+ constexpr Standard_Real aSqSmallValue = aSmallValue*aSmallValue;
Standard_Real aU1 = 0.0, aV1 = 0.0, aU2 = 0.0, aV2 = 0.0;
theUVPoint.Parameters(aU1, aV1, aU2, aV2);
if (Surf1->IsUClosed() || Surf1->IsVClosed() ||
Surf2->IsUClosed() || Surf2->IsVClosed())
{
- Standard_Real TolPar = Precision::PConfusion();
+ constexpr Standard_Real TolPar = Precision::PConfusion();
IntSurf_ListOfPntOn2S AdditionalPnts;
Standard_Real NewU1, NewV1, NewU2, NewV2;
for(; IterLOP1.More(); IterLOP1.Next())
//----------------------------------------------------
//-- On detecte les points confondus dans la LineOn2S
- Standard_Real dmini = Precision::SquareConfusion();
+ constexpr Standard_Real dmini = Precision::SquareConfusion();
for(i=2; (i<=nbponline) && (nbponline > 2); i++) {
const IntSurf_PntOn2S& aPnt1=curv->Value(i-1);
const IntSurf_PntOn2S& aPnt2=curv->Value(i);
Standard_Real aPrevStep = aBase3dVec.SquareMagnitude();
// Choose base tolerance and scale it to pipe algorithm.
- const Standard_Real aBaseTolerance = Precision::Approximation();
+ constexpr Standard_Real aBaseTolerance = Precision::Approximation();
Standard_Real aResS1Tol = Min(theS1->UResolution(aBaseTolerance),
theS1->VResolution(aBaseTolerance));
Standard_Real aResS2Tol = Min(theS2->UResolution(aBaseTolerance),
{
const Standard_Integer aNbIterMAX = 60;
const Standard_Real aTol = 1.0e-14;
- const Standard_Real aTolNul = 1.0 / Precision::Infinite();
+ constexpr Standard_Real aTolNul = 1.0 / Precision::Infinite();
// I.e. if theU1 = 0.0 then Epsilon(theU1) = DBL_MIN (~1.0e-308).
// Work with this number is impossible: there is a dangerous to
PutToBoundary(const Handle(Adaptor3d_Surface)& theASurf1,
const Handle(Adaptor3d_Surface)& theASurf2)
{
- const Standard_Real aTolMin = Precision::Confusion();
+ constexpr Standard_Real aTolMin = Precision::Confusion();
Standard_Boolean hasBeenAdded = Standard_False;
gp_Cylinder cy;
- Standard_Real Tol = Precision::Confusion();
- Standard_Real TolAng = Precision::Angular();
+ constexpr Standard_Real Tol = Precision::Confusion();
+ constexpr Standard_Real TolAng = Precision::Angular();
S = BRep_Tool::Surface(F);
Ts = S->DynamicType();
// Tentative de recalage dans la facette
pf = C2d->Value(f);
pl = C2d->Value(l);
- Standard_Real tttol = Precision::Angular();
+ constexpr Standard_Real tttol = Precision::Angular();
while (Min(pf.X(),pl.X()) >= Umaxc-tttol) {
C2d->Translate(gp_Vec2d(-2.*M_PI,0));
pf = C2d->Value(f);
// Tentative de recalage dans la facette
pf = C2d->Value(f);
pl = C2d->Value(l);
- Standard_Real tttol = Precision::Angular();
+ constexpr Standard_Real tttol = Precision::Angular();
while (Min(pf.X(),pl.X()) >= Umaxc - tttol) {
C2d->Translate(gp_Vec2d(-2.*M_PI,0));
pf = C2d->Value(f);
Handle(Geom_Surface) S1,S2;
TopLoc_Location loc1, loc2;
Handle(Standard_Type) typS1,typS2;
- const Standard_Real tollin = Precision::Confusion();
- const Standard_Real tolang = Precision::Angular();
+ constexpr Standard_Real tollin = Precision::Confusion();
+ constexpr Standard_Real tolang = Precision::Angular();
S1 = BRep_Tool::Surface(F1,loc1);
S2 = BRep_Tool::Surface(F2,loc2);
Handle(Geom_Curve) C1,C2;
TopLoc_Location loc1, loc2;
Handle(Standard_Type) typC1,typC2;
- const Standard_Real tollin = Precision::Confusion();
- const Standard_Real tolang = Precision::Angular();
+ constexpr Standard_Real tollin = Precision::Confusion();
+ constexpr Standard_Real tolang = Precision::Angular();
Standard_Real f,l;
C1 = BRep_Tool::Curve(E1,loc1,f,l);
if (!V2.IsNull())
TolLast = BRep_Tool::Tolerance(V2);
- Standard_Real tol2d = Precision::Confusion();
+ constexpr Standard_Real tol2d = Precision::Confusion();
Handle(Geom2d_Curve) C2d;
ShapeConstruct_ProjectCurveOnSurface aToolProj;
aToolProj.Init(S, tol2d);
if (S->IsUPeriodic()) {
Standard_Real up = S->UPeriod();
- Standard_Real tolu = Precision::PConfusion();// Epsilon(up);
+ constexpr Standard_Real tolu = Precision::PConfusion();// Epsilon(up);
Standard_Integer nbtra = 0;
Standard_Real theUmin = Min(pf.X(),pl.X());
Standard_Real theUmax = Max(pf.X(),pl.X());
if (S->IsVPeriodic()) {
Standard_Real vp = S->VPeriod();
- Standard_Real tolv = Precision::PConfusion();// Epsilon(vp);
+ constexpr Standard_Real tolv = Precision::PConfusion();// Epsilon(vp);
Standard_Integer nbtra = 0;
Standard_Real theVmin = Min(pf.Y(),pl.Y());
Standard_Real theVmax = Max(pf.Y(),pl.Y());
if (S->IsUPeriodic()) {
Standard_Real up = S->UPeriod();
- Standard_Real tolu = Precision::PConfusion();// Epsilon(up);
+ constexpr Standard_Real tolu = Precision::PConfusion();// Epsilon(up);
Standard_Integer nbtra = 0;
Standard_Real theUmin = Min(pf.X(),pl.X());
Standard_Real theUmax = Max(pf.X(),pl.X());
if (S->IsVPeriodic()) {
Standard_Real vp = S->VPeriod();
- Standard_Real tolv = Precision::PConfusion();// Epsilon(vp);
+ constexpr Standard_Real tolv = Precision::PConfusion();// Epsilon(vp);
Standard_Integer nbtra = 0;
Standard_Real theVmin = Min(pf.Y(),pl.Y());
Standard_Real theVmax = Max(pf.Y(),pl.Y());
TopTools_IndexedDataMapOfShapeListOfShape& Splits,
Standard_Boolean& isOverlapped)
{
- Standard_Real TolExt = Precision::PConfusion();
+ constexpr Standard_Real TolExt = Precision::PConfusion();
Standard_Integer i, j;
BRepAdaptor_Surface anAdSurf(theFace, Standard_False);
Standard_Real DotProd;
Standard_Real ProVec = CrossProd (Geom1,Geom2,DotProd);
Standard_Integer NbTest = 1;
- Standard_Real DU = Precision::Confusion();
+ constexpr Standard_Real DU = Precision::Confusion();
Handle(Geom2d_TrimmedCurve) C1,C2;
C1= Handle(Geom2d_TrimmedCurve)::DownCast(Geom1);
// Si pas dintersection => saillant.
// Sinon => rentrant.
Standard_Real D ;
- Standard_Real Tol = Precision::Confusion();
+ constexpr Standard_Real Tol = Precision::Confusion();
Standard_Real MilC1 = (C1->LastParameter() + C1->FirstParameter())*0.5;
Standard_Real MilC2 = (C2->LastParameter() + C2->FirstParameter())*0.5;
gp_Pnt2d P = C1->Value(C1->LastParameter());
Handle(Geom2d_TrimmedCurve) TrimC;
Standard_Real UF,UL,UC;
gp_Pnt2d PF,PL,PC;
- Standard_Real PTol = Precision::PConfusion()*10;
- Standard_Real Tol = Precision::Confusion()*10;
+ constexpr Standard_Real PTol = Precision::PConfusion()*10;
+ constexpr Standard_Real Tol = Precision::Confusion()*10;
Standard_Boolean YaCut = Standard_False;
Sommets.Perform (C);
// Function : ProcessFace
// Purpose : Fill array with triangles for the face
//================================================================
- static void ProcessFace(const Handle(MeshVS_HArray1OfSequenceOfInteger)& theTopo,
+ static void ProcessFace(const TColStd_SequenceOfInteger& theFaceNodes,
const TColStd_Array1OfReal& theNodes,
const Standard_Real* theCenter,
- const Standard_Real theShrinkCoef,
+ const Standard_Real theShrinkCoef,
const Standard_Boolean theIsShrinked,
- const Standard_Boolean theIsShaded,
+ const Standard_Boolean theIsShaded,
Handle(Graphic3d_ArrayOfPrimitives) theArray)
{
- for (Standard_Integer aFaceIdx = theTopo->Lower(); aFaceIdx <= theTopo->Upper(); ++aFaceIdx)
+ const Standard_Integer aNbPolyNodes = theFaceNodes.Length();
+
+ Standard_Real* aPolyNodesBuf = (Standard_Real*)alloca((3 * aNbPolyNodes + 1) * sizeof(Standard_Real));
+ TColStd_Array1OfReal aPolyNodes(*aPolyNodesBuf, 0, 3 * aNbPolyNodes);
+
+ for (Standard_Integer aNodeIdx = 0; aNodeIdx < aNbPolyNodes; ++aNodeIdx)
{
- const TColStd_SequenceOfInteger& aFaceNodes = theTopo->Value (aFaceIdx);
- const Standard_Integer aNbPolyNodes = aFaceNodes.Length();
-
- Standard_Real* aPolyNodesBuf = (Standard_Real*) alloca ((3 * aNbPolyNodes + 1) * sizeof (Standard_Real));
- TColStd_Array1OfReal aPolyNodes (*aPolyNodesBuf, 0, 3 * aNbPolyNodes);
+ Standard_Integer anIdx = theFaceNodes.Value(aNodeIdx + 1);
+
+ Standard_Real aX = theNodes.Value(theNodes.Lower() + 3 * anIdx + 0);
+ Standard_Real aY = theNodes.Value(theNodes.Lower() + 3 * anIdx + 1);
+ Standard_Real aZ = theNodes.Value(theNodes.Lower() + 3 * anIdx + 2);
- for (Standard_Integer aNodeIdx = 0; aNodeIdx < aNbPolyNodes; ++aNodeIdx)
+ if (theIsShrinked)
{
- Standard_Integer anIdx = aFaceNodes.Value (aNodeIdx + 1);
+ aX = theCenter[0] + theShrinkCoef * (aX - theCenter[0]);
+ aY = theCenter[1] + theShrinkCoef * (aY - theCenter[1]);
+ aZ = theCenter[2] + theShrinkCoef * (aZ - theCenter[2]);
+ }
- Standard_Real aX = theNodes.Value (theNodes.Lower() + 3 * anIdx + 0);
- Standard_Real aY = theNodes.Value (theNodes.Lower() + 3 * anIdx + 1);
- Standard_Real aZ = theNodes.Value (theNodes.Lower() + 3 * anIdx + 2);
+ aPolyNodes.SetValue(3 * aNodeIdx + 1, aX);
+ aPolyNodes.SetValue(3 * aNodeIdx + 2, aY);
+ aPolyNodes.SetValue(3 * aNodeIdx + 3, aZ);
+ }
- if (theIsShrinked)
- {
- aX = theCenter[0] + theShrinkCoef * (aX - theCenter[0]);
- aY = theCenter[1] + theShrinkCoef * (aY - theCenter[1]);
- aZ = theCenter[2] + theShrinkCoef * (aZ - theCenter[2]);
- }
+ gp_Vec aNorm;
- aPolyNodes.SetValue (3 * aNodeIdx + 1, aX);
- aPolyNodes.SetValue (3 * aNodeIdx + 2, aY);
- aPolyNodes.SetValue (3 * aNodeIdx + 3, aZ);
- }
-
- gp_Vec aNorm;
+ if (theIsShaded)
+ {
+ aPolyNodes.SetValue(0, aNbPolyNodes);
- if (theIsShaded)
+ if (!MeshVS_Tool::GetAverageNormal(aPolyNodes, aNorm))
{
- aPolyNodes.SetValue (0, aNbPolyNodes);
-
- if (!MeshVS_Tool::GetAverageNormal (aPolyNodes, aNorm))
- {
- aNorm.SetCoord (0.0, 0.0, 1.0);
- }
+ aNorm.SetCoord(0.0, 0.0, 1.0);
}
+ }
- for (Standard_Integer aNodeIdx = 0; aNodeIdx < aNbPolyNodes - 2; ++aNodeIdx) // triangulate polygon
+ for (Standard_Integer aNodeIdx = 0; aNodeIdx < aNbPolyNodes - 2; ++aNodeIdx) // triangulate polygon
+ {
+ for (Standard_Integer aSubIdx = 0; aSubIdx < 3; ++aSubIdx) // generate sub-triangle
{
- for (Standard_Integer aSubIdx = 0; aSubIdx < 3; ++aSubIdx) // generate sub-triangle
+ if (theIsShaded)
{
- if (theIsShaded)
- {
- theArray->AddVertex (aPolyNodes.Value (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 1),
- aPolyNodes.Value (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 2),
- aPolyNodes.Value (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 3),
- aNorm.X(),
- aNorm.Y(),
- aNorm.Z());
- }
- else
- {
- theArray->AddVertex (aPolyNodes.Value (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 1),
- aPolyNodes.Value (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 2),
- aPolyNodes.Value (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 3));
- }
+ theArray->AddVertex(aPolyNodes.Value(3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 1),
+ aPolyNodes.Value(3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 2),
+ aPolyNodes.Value(3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 3),
+ aNorm.X(),
+ aNorm.Y(),
+ aNorm.Z());
+ }
+ else
+ {
+ theArray->AddVertex(aPolyNodes.Value(3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 1),
+ aPolyNodes.Value(3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 2),
+ aPolyNodes.Value(3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 3));
}
}
}
if (aIsPolygons)
{
- ProcessFace (theTopo, theNodes, aCenter, theShrinkCoef, theIsShrinked, theIsShaded, theArray);
+ for (Standard_Integer aFaceIdx = theTopo->Lower(); aFaceIdx <= theTopo->Upper(); ++aFaceIdx)
+ {
+ ProcessFace(theTopo->Value(aFaceIdx), theNodes, aCenter, theShrinkCoef, theIsShrinked, theIsShaded, theArray);
+ }
}
else if (theIsSelected)
{
Standard_Boolean res = Standard_True;
- Standard_Real normal[3], first_vec[3], cur_vec[3], xx, yy, zz,
- conf = Precision::Confusion();
+ Standard_Real normal[3], first_vec[3], cur_vec[3], xx, yy, zz;
+ constexpr Standard_Real conf = Precision::Confusion();
for( i=0; i<3; i++ )
{
Standard_Boolean res = Standard_True;
- Standard_Real normal[3], first_vec[3], cur_vec[3], xx, yy, zz,
- conf = Precision::Confusion();
+ Standard_Real normal[3], first_vec[3], cur_vec[3], xx, yy, zz;
+ constexpr Standard_Real conf = Precision::Confusion();
for( i=0; i<3; i++ )
{
Standard_Boolean FromLastU = Standard_False,
isSplitsComputed = Standard_False;
- const Standard_Real aTolExt = Precision::PConfusion();
+ constexpr Standard_Real aTolExt = Precision::PConfusion();
Extrema_ExtCS CExt (*myCurve, *mySurface, aTolExt, aTolExt);
if (CExt.IsDone() && CExt.NbExt())
{
case GeomAbs_Cone: {
Standard_Real tol = Epsilon(1.);
- Standard_Real ptol = Precision::PConfusion();
+ constexpr Standard_Real ptol = Precision::PConfusion();
gp_Cone Cone = mySurface->Cone();
VCouture = Standard_False;
//Calculation of cone parameters for P == ConeApex often produces wrong
{
//OCC217
Standard_Real Tol3d = myTolerance;
- Standard_Real ParamTol = Precision::PApproximation();
+ constexpr Standard_Real ParamTol = Precision::PApproximation();
Handle(Adaptor2d_Curve2d) AHC2d = InitialCurve2d;
Handle(Adaptor3d_Curve) AHC = Curve;
myNbPnt2d = 0;
Standard_Real U = myCurve->FirstParameter();
gp_Pnt P = myCurve->Value(U);
- Standard_Real Tol = Precision::PConfusion();
+ constexpr Standard_Real Tol = Precision::PConfusion();
myExtPS = new Extrema_ExtPS (P, *S, Tol, Tol);
}
gp_Dir2d aDBnd;
Handle(Geom2d_TrimmedCurve) aSegment;
Geom2dConvert_CompCurveToBSplineCurve aCompCurve(aRes, Convert_RationalC1);
- Standard_Real aTol = Precision::Confusion();
+ constexpr Standard_Real aTol = Precision::Confusion();
aRes->D1(theParam, aPBnd, aVBnd);
aDBnd.SetXY(aVBnd.XY());
Zs = mySphere.Position().Direction();
Standard_Boolean isIsoU, isIsoV;
- Standard_Real Tol = Precision::Confusion();
+ constexpr Standard_Real Tol = Precision::Confusion();
isIsoU = Zc.IsNormal(Zs,Tol) && O.IsEqual(C.Location(),Tol);
isIsoV = Xc.IsNormal(Zs,Tol) && Yc.IsNormal(Zs,Tol);
SecondAttach = ElCLib::Value(ElCLib::Parameter(l2,Position),l2);
}
- Standard_Real confusion(Precision::Confusion());
+ constexpr Standard_Real confusion(Precision::Confusion());
if (arrsize < confusion) arrsize = Val*0.1;
if (Abs(Val) <= confusion) {arrsize = 0.;}
gp_Circ aCirc2 = aCir2->Circ();
//To avoid circles with different orientation
- Standard_Real aTol = Precision::Confusion();
+ constexpr Standard_Real aTol = Precision::Confusion();
if(aCirc2.Axis().IsOpposite(aCirc1.Axis(), aTol) ||
aCirc2.XAxis().IsOpposite(aCirc1.XAxis(), aTol) ||
aCirc2.YAxis().IsOpposite(aCirc1.YAxis(), aTol) )
PrsDim::ComputeGeometry( FirstVertex, FirstAttach, Plane, isOnPlane1);
PrsDim::ComputeGeometry( SecondVertex, SecondAttach, Plane, isOnPlane2);
- Standard_Real confusion(Precision::Confusion());
+ constexpr Standard_Real confusion(Precision::Confusion());
Standard_Boolean samePoint(FirstAttach.IsEqual(SecondAttach,confusion));
if (TypeDist == PrsDim_TypeOfDist_Vertical) DirAttach = Plane->Pln().XAxis().Direction();
if (!vec1.IsParallel(vec2, Precision::Angular()) ) {
gp_Dir dir;
- Standard_Real conf =Precision::Confusion();
+ constexpr Standard_Real conf =Precision::Confusion();
if (lastp1.IsEqual(firstp2,conf) || firstp1.IsEqual(lastp2,conf)) dir.SetXYZ(vec1.XYZ() - vec2.XYZ());
else dir.SetXYZ(vec1.XYZ() + vec2.XYZ());
gp_Vec transvec = gp_Vec(dir)*myArrowSize;
// Case of confusion between the current position and the center
// of the circle -> we move the current position
- Standard_Real confusion (Precision::Confusion());
+ constexpr Standard_Real confusion (Precision::Confusion());
gp_Pnt aCenter = thecirc.Location();
if ( aCenter.Distance(curpos) <= confusion )
{
// Case of confusion between the current position and the center
// of the circle -> we move the current position
- Standard_Real confusion (Precision::Confusion());
+ constexpr Standard_Real confusion (Precision::Confusion());
gp_Pnt aCenter = theEll.Location();
if ( aCenter.Distance(curpos) <= confusion )
{
Handle(Select3D_SensitiveSegment) seg;
// attachment point of the segment linking position to the curve
gp_Pnt attach;
- Standard_Real confusion (Precision::Confusion());
+ constexpr Standard_Real confusion (Precision::Confusion());
if ( myFAttach.IsEqual(mySAttach, confusion) )
{
Standard_Real dist = thelin->Lin().Distance(curpos);
gp_Pnt proj = ElCLib::Value( pcurpos, thelin->Lin());
gp_Vec trans;
- Standard_Real confusion(Precision::Confusion());
+ constexpr Standard_Real confusion(Precision::Confusion());
if ( dist >= confusion ) {
trans = gp_Vec(proj, curpos);
trans.Normalize();
const gp_Pnt& firstp2,
const gp_Pnt& lastp2)
{
- Standard_Real confusion (Precision::Confusion());
+ constexpr Standard_Real confusion (Precision::Confusion());
// Searching of complete circles
Standard_Boolean circ1complete = (firstp1.IsEqual(lastp1, confusion));
// Case of confusion between the current position and the center
// of the circle -> we move the current position
- Standard_Real confusion (Precision::Confusion());
+ constexpr Standard_Real confusion (Precision::Confusion());
if ( myCenter.Distance(curpos) <= confusion )
{
gp_Vec vprec(myCenter, myFAttach);
const gp_Pnt& firstp2,
const gp_Pnt& lastp2)
{
- Standard_Real confusion (Precision::Confusion());
+ constexpr Standard_Real confusion (Precision::Confusion());
// Searching of complete ellipses
Standard_Boolean circ1complete = (firstp1.IsEqual(lastp1, confusion));
// Case of confusion between the current position and the center
// of the ellipse -> we move the current position
- Standard_Real confusion (Precision::Confusion());
+ constexpr Standard_Real confusion (Precision::Confusion());
if ( myCenter.Distance(curpos) <= confusion )
{
gp_Vec vprec(myCenter, myFAttach);
// Case of confusion between the current position and the center
// of the circle -> we move the current position
- Standard_Real confusion (Precision::Confusion());
+ constexpr Standard_Real confusion (Precision::Confusion());
gp_Pnt aCenter = aCirc.Location();
if ( aCenter.Distance(curpos) <= confusion )
{
// Case of confusion between the current position and the center
// of the circle -> we move the current position
- Standard_Real confusion (Precision::Confusion());
+ constexpr Standard_Real confusion (Precision::Confusion());
gp_Pnt aCenter = anEll.Location();
if ( aCenter.Distance(curpos) <= confusion )
{
if (GS.IsNull()) { di << "OCC486 FAULTY. Null surface /n";return 1;}
gp_Pnt P3D( Draw::Atof(argv[2]),Draw::Atof(argv[3]),Draw::Atof(argv[4]) );
- Standard_Real Tol = Precision::PConfusion();
+ constexpr Standard_Real Tol = Precision::PConfusion();
Extrema_ExtPS myExtPS;
if (argc > 5) du = Draw::Atof(argv[5]);
if (argc > 6) dv = Draw::Atof(argv[6]);
Handle(Geom_Surface) thePlane = BRep_Tool::Surface(theFace);
- Standard_Real aConfusion = Precision::Confusion();
+ constexpr Standard_Real aConfusion = Precision::Confusion();
Standard_Real aP1first, aP1last, aP2first, aP2last;
Handle(Geom_Curve) aCurve1 = BRep_Tool::Curve(theEdge1, aP1first, aP1last);
gp_Trsf2d Tcomp;
Tcomp = M2.Multiplied(M1);
- Standard_Real aTol = Precision::Confusion();
+ constexpr Standard_Real aTol = Precision::Confusion();
Standard_Integer aStatus = 0;
//After applying two times the same mirror the point is located on the same location OK
return 1;
}
- Standard_Real delt = 5.0*Precision::Confusion();
+ constexpr Standard_Real delt = 5.0*Precision::Confusion();
Standard_Real mesh_delt = Draw::Atof(argv[2]);
if (mesh_delt <= 0.0)
{
DrawTrSurf::Set("c_2", aTrim[1]);
// Intersection
- const Standard_Real aTol = Precision::Confusion();
+ constexpr Standard_Real aTol = Precision::Confusion();
Geom2dAPI_InterCurveCurve aIntTool( aTrim[0], aTrim[1], aTol );
const IntRes2d_IntersectionPoint& aIntPnt =
TColGeom_Array1OfBSplineCurve aCurves (0, 1);
TColStd_Array1OfReal aTolerances (0, 0);
Standard_Real aTolConf = 1.e-3;
- Standard_Real aTolClosure = Precision::Confusion();
+ constexpr Standard_Real aTolClosure = Precision::Confusion();
Handle(TColGeom_HArray1OfBSplineCurve) aConcatCurves;
Handle(TColStd_HArray1OfInteger) anIndices;
return 1;
BRepAdaptor_Surface aSurf(aFace);
- Standard_Real aTolU = Precision::PConfusion();
- Standard_Real aTolV = Precision::PConfusion();
+ constexpr Standard_Real aTolU = Precision::PConfusion();
+ constexpr Standard_Real aTolV = Precision::PConfusion();
Extrema_GenLocateExtPS anExtrema(aSurf, aTolU, aTolV);
anExtrema.Perform(aPnt, aUV.X(), aUV.Y(), Standard_True);
Standard_Real oldLast = Draw::Atof(argv[4]);
Standard_Real current_first = Draw::Atof(argv[5]);
Standard_Real current_last = Draw::Atof(argv[6]);
- Standard_Real Tol = Precision::PConfusion();
+ constexpr Standard_Real Tol = Precision::PConfusion();
Handle(Geom2d_Curve) NewC2d;
GeomLib::SameRange(Tol, C, oldFirst,oldLast,
current_first, current_last, NewC2d);
R->Add(POn2S);
}
GeomInt_WLApprox theapp3d;
- Standard_Real Tol = Precision::Approximation();
+ constexpr Standard_Real Tol = Precision::Approximation();
theapp3d.SetParameters(Tol, Tol, 4, 8, 0, 30, Standard_True);
Handle(IntPatch_WLine) WL = new IntPatch_WLine(R, Standard_False);
Standard_Integer indicemin = 1;
R->Add(POn2S);
}
GeomInt_WLApprox theapp3d;
- Standard_Real Tol = Precision::PApproximation();
+ constexpr Standard_Real Tol = Precision::PApproximation();
theapp3d.SetParameters(Tol, Tol, 4, 8, 0, 30, Standard_True);
Handle(IntPatch_WLine) WL = new IntPatch_WLine(R, Standard_False);
Standard_Integer indicemin = 1;
aStartPoint, aFBnd, aLBnd, aRelDev);
//
- Standard_Real aTol = Precision::Confusion();
+ constexpr Standard_Real aTol = Precision::Confusion();
math_MultipleVarFunction* aPFunc;
GeomConvert_FuncSphereLSDist aFuncSph(aPoints);
GeomConvert_FuncCylinderLSDist aFuncCyl(aPoints, thePos.Direction());
const Standard_Real theLast,
const Handle(Geom2d_Curve)& thePC)
{
- const Standard_Real eps = Precision::PConfusion();
+ constexpr Standard_Real eps = Precision::PConfusion();
Standard_Boolean isValid = Standard_True;
Standard_Boolean IsPeriodic = thePC->IsPeriodic();
Standard_Real aPeriod = RealLast();
Standard_Real VF = vf - dv, VL = vl + dv;
//Standard_Integer fail = 0;
- Standard_Real Tol = Precision::Confusion();
- Standard_Real Tol2 = Tol * Tol;//, rs2p=1e10;
+ constexpr Standard_Real Tol = Precision::Confusion();
+ constexpr Standard_Real Tol2 = Tol * Tol;//, rs2p=1e10;
Standard_Real U = p2dPrev.X(), V = p2dPrev.Y();
gp_Vec rsfirst = P3D.XYZ() - Value(U, V).XYZ(); //pdn
for (Standard_Integer i = 0; i < 25; i++) {
du = Min(myUDelt, SurfAdapt.UResolution(preci));
dv = Min(myVDelt, SurfAdapt.VResolution(preci));
}
- Standard_Real Tol = Precision::PConfusion();
+ constexpr Standard_Real Tol = Precision::PConfusion();
myExtPS.SetFlag(Extrema_ExtFlag_MIN);
myExtPS.Initialize(SurfAdapt, uf - du, ul + du, vf - dv, vl + dv, Tol, Tol);
myExtOK = Standard_True;
}
if (disSurf < 10 * preci)
if (mySurf->Continuity() != GeomAbs_C0) {
- Standard_Real Tol = Precision::Confusion();
+ constexpr Standard_Real Tol = Precision::Confusion();
gp_Vec D1U, D1V;
gp_Pnt pnt;
SurfAdapt.D1(UU, VV, pnt, D1U, D1V);
Handle(TColStd_HSequenceOfReal) resKnots = new TColStd_HSequenceOfReal;
Standard_Integer len = Knots->Length();
- Standard_Real preci = 2*Precision::PConfusion();
+ constexpr Standard_Real preci = 2*Precision::PConfusion();
Standard_Real first = (To2d ? myAC3d.FirstParameter() : myFirst);
Standard_Real last = (To2d ? myAC3d.LastParameter() : myLast);
gp_Pnt p1;
gp_Pnt p2;
Standard_Real alpha = 0, beta = 1;
- Standard_Real preci = Precision::PConfusion();
+ constexpr Standard_Real preci = Precision::PConfusion();
Standard_Real firstPar, lastPar;
if(prevPar < currPar) {
firstPar = prevPar;
TColStd_Array1OfBoolean isEdgeUsed (1, aNbEdges);
isEdgeUsed.Init (Standard_False);
- Standard_Real aTol2 = Precision::SquareConfusion();
- Standard_Real aTolP2 = Precision::SquarePConfusion();
+ constexpr Standard_Real aTol2 = Precision::SquareConfusion();
+ constexpr Standard_Real aTolP2 = Precision::SquarePConfusion();
// take the first edge to the constructed chain
isEdgeUsed (1) = Standard_True;
try { // RAJOUT
OCC_CATCH_SIGNALS
- Standard_Real prec = Precision::Confusion();//myPreci;
+ constexpr Standard_Real prec = Precision::Confusion();//myPreci;
Standard_Boolean isoParam = Standard_False;
isoPar2d3d = Standard_False;
}
}
- Standard_Real dPreci = Precision::PConfusion()*Precision::PConfusion();
+ constexpr Standard_Real dPreci = Precision::PConfusion()*Precision::PConfusion();
if(dMax < dPreci)
return Standard_False;
Handle(Geom2d_Curve) c21 = BRep_Tool::CurveOnSurface(E,myFace,f1,l1);
TopoDS_Shape dummy = E.Reversed();
Handle(Geom2d_Curve) c22 = BRep_Tool::CurveOnSurface(TopoDS::Edge(dummy),myFace,f2,l2);
- Standard_Real dPreci = ::Precision::PConfusion()*Precision::PConfusion();
+ constexpr Standard_Real dPreci = ::Precision::PConfusion()*Precision::PConfusion();
gp_Pnt2d pf1 = c21->Value(f1);
gp_Pnt2d pl1 = c21->Value(l1);
gp_Pnt2d pf2 = c22->Value(f2);
Standard_Real oldFirstCurve1 = oldFirst, oldLastCurve1 = oldLast;
if(Curve2dPtr->IsKind(STANDARD_TYPE(Geom2d_BezierCurve))) {
- Standard_Real preci = Precision::PConfusion();
+ constexpr Standard_Real preci = Precision::PConfusion();
if ( Abs(oldFirst) > preci || Abs(oldLast-1) > preci ) {
Handle(Geom2d_BezierCurve) bezier = Handle(Geom2d_BezierCurve)::DownCast(Curve2dPtr->Copy());
bezier->Segment(oldFirst,oldLast);
if(Curve2dPtr2->IsKind(STANDARD_TYPE(Geom2d_BezierCurve))) {
- Standard_Real preci = Precision::PConfusion();
+ constexpr Standard_Real preci = Precision::PConfusion();
if ( Abs(oldFirst) > preci || Abs(oldLast-1) > preci ) {
Handle(Geom2d_BezierCurve) bezier = Handle(Geom2d_BezierCurve)::DownCast(Curve2dPtr2->Copy());
bezier->Segment(oldFirst,oldLast);
Standard_Real cf = theCurve2d->FirstParameter();
Standard_Real cl = theCurve2d->LastParameter();
//:S4136 Standard_Real preci = BRepAPI::Precision();
- Standard_Real preci2d = Precision::PConfusion(); //:S4136: Parametric(preci, 0.01);
+ constexpr Standard_Real preci2d = Precision::PConfusion(); //:S4136: Parametric(preci, 0.01);
// 15.11.2002 PTV OCC966
if (ShapeAnalysis_Curve::IsPeriodic(theCurve2d)) {
try {
OCC_CATCH_SIGNALS
BRepClass3d_SolidClassifier bsc3d (solid);
- Standard_Real t = Precision::Confusion(); // tolerance moyenne
+ constexpr Standard_Real t = Precision::Confusion(); // tolerance moyenne
bsc3d.PerformInfinitePoint(t);
if (bsc3d.State() == TopAbs_IN) {
if (Context().IsNull()) SetContext(new ShapeBuild_ReShape);
- Standard_Real preci = ::Precision::PConfusion();
+ constexpr Standard_Real preci = ::Precision::PConfusion();
//Standard_Real preci = Precision();
//GeomAdaptor_Surface& SA = Analyzer().Surface()->Adaptor()->ChangeSurface();
//preci = Max(SA.UResolution(preci), SA.VResolution(preci));
Standard_Real ipar1 = clast1, ipar2 = cfirst2;
Geom2dInt_GInter Inter;
- Standard_Real tolint = ::Precision::PConfusion();
+ constexpr Standard_Real tolint = ::Precision::PConfusion();
Geom2dAdaptor_Curve AC1(pc1), AC2(pc2);
C2->D1(first2,P,Vec2);
if ( edge1.Orientation() == TopAbs_REVERSED ) Vec1.Reverse();
if ( edge2.Orientation() == TopAbs_REVERSED ) Vec2.Reverse();
- Standard_Real tol2 = Precision::SquareConfusion();
+ constexpr Standard_Real tol2 = Precision::SquareConfusion();
if ( Vec1.SquareMagnitude() < tol2 ||
Vec2.SquareMagnitude() < tol2 ) Ang1 = M_PI/2.;
else Ang1 = Abs(Vec1.Angle(Vec2));
C2->D1(first2,P,Vec2);
if ( edge1.Orientation() == TopAbs_REVERSED ) Vec1.Reverse();
if ( edge2.Orientation() == TopAbs_REVERSED ) Vec2.Reverse();
- Standard_Real tol2 = Precision::SquareConfusion();
+ constexpr Standard_Real tol2 = Precision::SquareConfusion();
if ( Vec1.SquareMagnitude() < tol2 ||
Vec2.SquareMagnitude() < tol2 ) Ang1 = M_PI/2.;
else Ang1 = Abs(Vec1.Angle(Vec2));
{
mySegments->Clear();
mySplitParams->Clear();
- Standard_Real precision = Precision::PConfusion();
+ constexpr Standard_Real precision = Precision::PConfusion();
Standard_Real First = mySplitValues->Value(1);
Standard_Real Last = mySplitValues->Value(mySplitValues->Length());
void ShapeUpgrade_ConvertCurve2dToBezier::Build(const Standard_Boolean /*Segment*/)
{
- Standard_Real prec = Precision::PConfusion();
+ constexpr Standard_Real prec = Precision::PConfusion();
Standard_Integer nb = mySplitValues->Length();
myResultingCurves = new TColGeom2d_HArray1OfCurve (1,nb-1);
Standard_Real prevPar =0.;
{
mySegments->Clear();
mySplitParams->Clear();
- Standard_Real precision = Precision::PConfusion();
+ constexpr Standard_Real precision = Precision::PConfusion();
Standard_Real First = mySplitValues->Value(1);
Standard_Real Last = mySplitValues->Value(mySplitValues->Length());
if(myCurve->IsKind(STANDARD_TYPE(Geom_TrimmedCurve))) {
void ShapeUpgrade_ConvertCurve3dToBezier::Build(const Standard_Boolean /*Segment*/)
{
- Standard_Real prec = Precision::PConfusion();
+ constexpr Standard_Real prec = Precision::PConfusion();
Standard_Integer nb = mySplitValues->Length();
myResultingCurves = new TColGeom_HArray1OfCurve (1,nb-1);
Standard_Real prevPar = 0.;
Standard_Real ULast = myUSplitValues->Value(myUSplitValues->Length());
Standard_Real VFirst = myVSplitValues->Value(1);
Standard_Real VLast = myVSplitValues->Value(myVSplitValues->Length());
- Standard_Real precision = Precision::PConfusion();
+ constexpr Standard_Real precision = Precision::PConfusion();
if (mySurface->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface))) {
Handle(Geom_RectangularTrimmedSurface) Surface = Handle(Geom_RectangularTrimmedSurface)::DownCast(mySurface);
{
if(surf->IsKind(STANDARD_TYPE(Geom_BezierSurface))) {
Handle(Geom_BezierSurface) bezier = Handle(Geom_BezierSurface)::DownCast(surf->Copy());
- Standard_Real prec = Precision::PConfusion();
+ constexpr Standard_Real prec = Precision::PConfusion();
if(U1 < prec && U2 > 1-prec && V1 < prec && V2 > 1-prec)
return bezier;
//pdn K4L+ (work around)
offsetValue = offSur->Offset();
}
- Standard_Real prec = Precision::PConfusion();
+ constexpr Standard_Real prec = Precision::PConfusion();
Handle(TColStd_HArray1OfReal) myUSplitParams = mySegments->UJointValues();
Handle(TColStd_HArray1OfReal) myVSplitParams = mySegments->VJointValues();
Standard_Integer nbU = myUSplitValues->Length();
BRep_Builder B;
ShapeAnalysis_Edge sae;
ShapeBuild_Edge sbe;
- Standard_Real preci = Precision::PConfusion();
+ constexpr Standard_Real preci = Precision::PConfusion();
for(TopExp_Explorer exp(myResult,TopAbs_FACE); exp.More(); exp.Next()) {
TopoDS_Face face = TopoDS::Face(exp.Current());
face.Orientation(TopAbs_FORWARD);
void ShapeUpgrade_SplitCurve::SetSplitValues (const Handle(TColStd_HSequenceOfReal)& SplitValues)
{
- Standard_Real precision = Precision::PConfusion();
+ constexpr Standard_Real precision = Precision::PConfusion();
if(SplitValues.IsNull()) return;
if(SplitValues->Length()==0) return;
Handle(Geom2d_Curve) CopyOfC = Handle(Geom2d_Curve)::DownCast(C->Copy());
myCurve = CopyOfC;
- Standard_Real precision = Precision::PConfusion();
+ constexpr Standard_Real precision = Precision::PConfusion();
Standard_Real firstPar = First;
Standard_Real lastPar = Last;
Handle (Geom2d_Curve) aCurve = myCurve;
myStatus = ShapeExtend::EncodeStatus (ShapeExtend_DONE2);
if (mySplitValues->Length() > 2)
myStatus = ShapeExtend::EncodeStatus (ShapeExtend_DONE1);
- Standard_Real precision = Precision::PConfusion();
+ constexpr Standard_Real precision = Precision::PConfusion();
Standard_Real First = mySplitValues->Value(1);
Standard_Real Last = mySplitValues->Value(mySplitValues->Length());
if (myCurve->IsKind(STANDARD_TYPE(Geom2d_TrimmedCurve))) {
// if (ShapeUpgrade::Debug()) std::cout << "SplitCurve3d::Init"<<std::endl;
Handle(Geom_Curve) CopyOfC = Handle(Geom_Curve)::DownCast(C->Copy());
myCurve = CopyOfC;
- Standard_Real precision = Precision::PConfusion();
+ constexpr Standard_Real precision = Precision::PConfusion();
Standard_Real firstPar = First;
Standard_Real lastPar = Last;
Handle (Geom_Curve) aCurve = myCurve;
// 15.11.2002 PTV OCC966
if(!ShapeAnalysis_Curve::IsPeriodic(myCurve)) {
//pdn exceptons only on non periodic curves
- Standard_Real precision = Precision::PConfusion();
+ constexpr Standard_Real precision = Precision::PConfusion();
Standard_Real firstPar = myCurve->FirstParameter();
Standard_Real lastPar = myCurve->LastParameter();
if(Abs(First-firstPar) < precision)
{
Standard_Real First = mySplitValues->Value(1);
Standard_Real Last = mySplitValues->Value(mySplitValues->Length());
- Standard_Real precision = Precision::PConfusion();
+ constexpr Standard_Real precision = Precision::PConfusion();
if(myCurve->Continuity() < myCriterion)
myStatus = ShapeExtend::EncodeStatus (ShapeExtend_DONE2);
if (mySplitValues->Length() > 2)
Standard_Real U1,U2,V1,V2;
mySurface->Bounds(U1,U2,V1,V2);
- Standard_Real precision = Precision::PConfusion();
+ constexpr Standard_Real precision = Precision::PConfusion();
if ( mySurface->IsUPeriodic() &&
ULast - UFirst <= U2 - U1 + precision ) { U1 = UFirst; U2 = U1 + mySurface->UPeriod(); }
if ( mySurface->IsVPeriodic() &&
void ShapeUpgrade_SplitSurface::SetUSplitValues(const Handle(TColStd_HSequenceOfReal)& UValues)
{
if(UValues.IsNull()) return;
- Standard_Real precision = Precision::PConfusion();
+ constexpr Standard_Real precision = Precision::PConfusion();
Standard_Real UFirst = myUSplitValues->Value(1),
ULast = myUSplitValues->Value(myUSplitValues->Length());
Standard_Integer i =1;
void ShapeUpgrade_SplitSurface::SetVSplitValues(const Handle(TColStd_HSequenceOfReal)& VValues)
{
if(VValues.IsNull()) return;
- Standard_Real precision = Precision::PConfusion();
+ constexpr Standard_Real precision = Precision::PConfusion();
Standard_Real VFirst = myVSplitValues->Value(1),
VLast = myVSplitValues->Value(myVSplitValues->Length());
Standard_Integer i =1;
Standard_Real ULast = myUSplitValues->Value(myUSplitValues->Length());
Standard_Real VFirst = myVSplitValues->Value(1);
Standard_Real VLast = myVSplitValues->Value(myVSplitValues->Length());
- Standard_Real precision = Precision::Confusion();
+ constexpr Standard_Real precision = Precision::Confusion();
// if (ShapeUpgrade::Debug()) std::cout << "SplitSurfaceContinuity::Build" << std::endl;
if(mySurface->Continuity() < myCriterion)
myStatus = ShapeExtend::EncodeStatus (ShapeExtend_DONE2);
Standard_Real uf1, ul1, vf1, vl1, uf2, ul2, vf2, vl2;
theS1->Bounds(uf1, ul1, vf1, vl1);
theS2->Bounds(uf2, ul2, vf2, vl2);
- Standard_Real aPTol = Precision::PConfusion();
+ constexpr Standard_Real aPTol = Precision::PConfusion();
if (Precision::IsNegativeInfinite(uf1))
{
if (!Precision::IsNegativeInfinite(uf2))
}
// fix changed faces and replace them in the local context
- Standard_Real aPrec = Precision::Confusion();
+ constexpr Standard_Real aPrec = Precision::Confusion();
for (Standard_Integer i = 1; i <= aChangedFaces.Extent(); i++) {
TopoDS_Face aFace = TopoDS::Face(myContext->Apply(aChangedFaces.FindKey(i)));
if (aFace.IsNull())
Handle(TColStd_HSequenceOfReal) new2d,
Handle(TColStd_HSequenceOfReal) new3d)
{
- Standard_Real preci = Precision::PConfusion();
+ constexpr Standard_Real preci = Precision::PConfusion();
Standard_Integer len3d = orig3d->Length();
Standard_Integer len2d = orig2d->Length();
TColStd_Array1OfBoolean fixNew2d (1, len3d);
Standard_Integer aNbVertices = 0;
// Precision for compare square distances
- const Standard_Real aPreci = Precision::SquareConfusion();
+ constexpr Standard_Real aPreci = Precision::SquareConfusion();
TopExp_Explorer aFaceIt(theShape, TopAbs_FACE);
for (; aFaceIt.More(); aFaceIt.Next())
{
STATIC_DEFINED = Standard_True;
- Standard_Real tola = Precision::Angular();
+ constexpr Standard_Real tola = Precision::Angular();
Standard_Boolean curismax = (Abs(MaxD.Dot(myTgt)) < tola);
Standard_Boolean curismin = (Abs(MinD.Dot(myTgt)) < tola);
Standard_Real Curv=0.;
// ------
- Standard_Real tola = Precision::Angular();
+ constexpr Standard_Real tola = Precision::Angular();
Standard_Boolean curismax = (Abs(MaxD.Dot(myTgt)) < tola);
Standard_Boolean curismin = (Abs(MinD.Dot(myTgt)) < tola);
if (!curismax && !curismin) {
// oriented Ang(beafter,dironF),
// dironF normal to the curve, oriented INSIDE F, the added oriented support
Standard_Real Ang = ::FUN_Ang(myNorm,beafter,myTgt,Norm,O);
- Standard_Real tola = Precision::Angular(); // nyi in arg
+ constexpr Standard_Real tola = Precision::Angular(); // nyi in arg
// i = 0,1,2 : cos = 0,>0,<0
// j = 0,1,2 : sin = 0,>0,<0
Poly_Connect pc (polyTriangulation);
Standard_Integer index[3];
- Standard_Real Tol = Precision::Confusion();
+ constexpr Standard_Real Tol = Precision::Confusion();
gp_Dir Nor;
for (i = 1; i <= polyTriangulation->NbNodes(); i++)
char buf[128];
Standard_Real val[3];
const Quantity_TypeOfColor bidType = Quantity_TOC_sRGB;
- const Standard_Real aConf (0.001 * Precision::Confusion());
+ constexpr Standard_Real aConf (0.001 * Precision::Confusion());
if (OK(aStatus) && fabs(myAmbientIntensity - 0.2) > aConf) {
Sprintf (buf, "%.6g", myAmbientIntensity);
Standard_Boolean VrmlData_Material::IsDefault () const
{
- const Standard_Real aConf (0.001 * Precision::Confusion());
+ constexpr Standard_Real aConf (0.001 * Precision::Confusion());
Standard_Boolean aResult (Standard_False);
if (fabs(myAmbientIntensity - 0.2) < aConf &&
fabs(myShininess - 0.2) < aConf &&
Poly_Connect PC(theTri);
// Create the Normals node (if UV- values are available)
TopLoc_Location aLoc;
- const Standard_Real aConf2 = Precision::SquareConfusion();
+ constexpr Standard_Real aConf2 = Precision::SquareConfusion();
const Handle(Geom_Surface) aSurface = BRep_Tool::Surface (theFace, aLoc);
if (theTri->HasUVNodes() && aSurface.IsNull() == Standard_False)
{
dir = VDir2.Crossed(Dir3);
gp_Lin L2(gp_Pnt((P3.XYZ()+P2.XYZ())/2.),dir);
- Standard_Real Tol = Precision::PConfusion();
+ constexpr Standard_Real Tol = Precision::PConfusion();
Extrema_ExtElC distmin(L1,L2,Tol);
if (!distmin.IsDone()) {
projects / occt.git / commitdiff