#include <IntTools_PntOn2Faces.hxx>
#include <IntTools_Context.hxx>
#include <IntSurf_ListIteratorOfListOfPntOn2S.hxx>
+#include <GeomInt.hxx>
static
void RefineVector(gp_Vec2d& aV2D);
-#ifdef DEB_DUMPWLINE
+#ifdef OCCT_DEBUG_DUMPWLINE
static
void DumpWLine(const Handle(IntPatch_WLine)& aWLine);
#endif
const Handle(GeomAdaptor_HSurface)& theSurface2,
const TopoDS_Face& theFace1,
const TopoDS_Face& theFace2,
- const IntTools_LineConstructor& theLConstructor,
+ const GeomInt_LineConstructor& theLConstructor,
const Standard_Boolean theAvoidLConstructor,
IntPatch_SequenceOfLine& theNewLines,
Standard_Real& theReachedTol3d,
Standard_Integer IndexType(const GeomAbs_SurfaceType aType);
//
-static
- Standard_Real MaxSquareDistance (const Standard_Real aT,
- const Handle(Geom_Curve)& aC3D,
- const Handle(Geom2d_Curve)& aC2D1,
- const Handle(Geom2d_Curve)& aC2D2,
- const Handle(GeomAdaptor_HSurface) myHS1,
- const Handle(GeomAdaptor_HSurface) myHS2,
- const TopoDS_Face& aF1,
- const TopoDS_Face& aF2,
- const Handle(IntTools_Context)& aCtx);
-
static
Standard_Boolean CheckPCurve(const Handle(Geom2d_Curve)& aPC,
const TopoDS_Face& aFace);
//
static
- Standard_Real FindMaxSquareDistance (const Standard_Real aA,
- const Standard_Real aB,
- const Standard_Real aEps,
- const Handle(Geom_Curve)& aC3D,
- const Handle(Geom2d_Curve)& aC2D1,
- const Handle(Geom2d_Curve)& aC2D2,
- const Handle(GeomAdaptor_HSurface)& myHS1,
- const Handle(GeomAdaptor_HSurface)& myHS2,
- const TopoDS_Face& aF1,
- const TopoDS_Face& aF2,
- const Handle(IntTools_Context)& aCtx);
+ Standard_Real MaxDistance(const Handle(Geom_Curve)& theC,
+ const Standard_Real aT,
+ GeomAPI_ProjectPointOnSurf& theProjPS);
+static
+ Standard_Real FindMaxDistance(const Handle(Geom_Curve)& theC,
+ const Standard_Real theFirst,
+ const Standard_Real theLast,
+ GeomAPI_ProjectPointOnSurf& theProjPS,
+ const Standard_Real theEps);
+static
+ Standard_Real FindMaxDistance(const Handle(Geom_Curve)& theCurve,
+ const Standard_Real theFirst,
+ const Standard_Real theLast,
+ const TopoDS_Face& theFace,
+ const Handle(IntTools_Context)& theContext);
//=======================================================================
//function :
}
}
+//=======================================================================
+//function : ComputeTolerance
+//purpose :
+//=======================================================================
+Standard_Real IntTools_FaceFace::ComputeTolerance()
+{
+ Standard_Integer i, j, aNbLin;
+ Standard_Real aFirst, aLast, aD, aDMax, aT, aDelta;
+ Handle(Geom_Surface) aS1, aS2;
+ //
+ aDMax = 0;
+ aDelta = Precision::PConfusion();
+ aNbLin = mySeqOfCurve.Length();
+ //
+ aS1 = myHS1->ChangeSurface().Surface();
+ aS2 = myHS2->ChangeSurface().Surface();
+ //
+ for (i = 1; i <= aNbLin; ++i) {
+ const IntTools_Curve& aIC = mySeqOfCurve(i);
+ const Handle(Geom_Curve)& aC3D = aIC.Curve();
+ if (aC3D.IsNull()) {
+ continue;
+ }
+ //
+ aFirst = aC3D->FirstParameter();
+ aLast = aC3D->LastParameter();
+ //
+ const Handle(Geom2d_Curve)& aC2D1 = aIC.FirstCurve2d();
+ const Handle(Geom2d_Curve)& aC2D2 = aIC.SecondCurve2d();
+ //
+ for (j = 0; j < 2; ++j) {
+ const Handle(Geom2d_Curve)& aC2D = !j ? aC2D1 : aC2D2;
+ const Handle(Geom_Surface)& aS = !j ? aS1 : aS2;
+ //
+ if (!aC2D.IsNull()) {
+ if (IntTools_Tools::ComputeTolerance
+ (aC3D, aC2D, aS, aFirst, aLast, aD, aT)) {
+ if (aD > aDMax) {
+ aDMax = aD;
+ }
+ }
+ }
+ //
+ const TopoDS_Face& aF = !i ? myFace1 : myFace2;
+ aD = FindMaxDistance(aC3D, aFirst, aLast, aF, myContext);
+ if (aD > aDMax) {
+ aDMax = aD;
+ }
+ }
+ }
+ //
+ return aDMax;
+}
+
//=======================================================================
//function :ComputeTolReached3d
//purpose :
//=======================================================================
void IntTools_FaceFace::ComputeTolReached3d()
{
- Standard_Boolean bCase1;
Standard_Integer aNbLin, i;
GeomAbs_SurfaceType aType1, aType2;
//
aType1=myHS1->Surface().GetType();
aType2=myHS2->Surface().GetType();
//
- bCase1=((aType1==GeomAbs_Plane && aType2==GeomAbs_SurfaceOfExtrusion) ||
- (aType2==GeomAbs_Plane && aType1==GeomAbs_SurfaceOfExtrusion));
- //
if (aType1==GeomAbs_Cylinder && aType2==GeomAbs_Cylinder) {
if (aNbLin==2){
Handle(IntPatch_Line) aIL1, aIL2;
}
//ZZ
if (aNbLin) {// Check the distances
- Standard_Integer aNbP, j ;
- Standard_Real aT1, aT2, dT, aD2, aD2Max, aEps, aT11, aT12;
+ Standard_Real aDMax;
//
- aD2Max=0.;
- aNbP=10;
- aNbLin=mySeqOfCurve.Length();
- //
- for (i=1; i<=aNbLin; ++i) {
- const IntTools_Curve& aIC=mySeqOfCurve(i);
- const Handle(Geom_Curve)& aC3D=aIC.Curve();
- const Handle(Geom2d_Curve)& aC2D1=aIC.FirstCurve2d();
- const Handle(Geom2d_Curve)& aC2D2=aIC.SecondCurve2d();
- //
- if (aC3D.IsNull()) {
- continue;
- }
- const Handle(Geom_BSplineCurve)& aBC=
- Handle(Geom_BSplineCurve)::DownCast(aC3D);
- if (aBC.IsNull()) {
- continue;
- }
- //
- aT1=aBC->FirstParameter();
- aT2=aBC->LastParameter();
- //
- aEps=0.01*(aT2-aT1);
- dT=(aT2-aT1)/aNbP;
- for (j=1; j<aNbP; ++j) {
- aT11=aT1+j*dT;
- aT12=aT11+dT;
- aD2=FindMaxSquareDistance(aT11, aT12, aEps, aC3D, aC2D1, aC2D2,
- myHS1, myHS2, myFace1, myFace2, myContext);
- if (aD2>aD2Max) {
- aD2Max=aD2;
- }
- }
- }//for (i=1; i<=aNbLin; ++i) {
- //
- myTolReached3d=sqrt(aD2Max);
+ aDMax = ComputeTolerance();
+ if (aDMax > 0.) {
+ myTolReached3d = aDMax;
+ }
}// if (aNbLin)
}// if (aType1==GeomAbs_Cylinder && aType2==GeomAbs_Cylinder) {
//
}// if ((aType1==GeomAbs_Plane && aType2==GeomAbs_Torus) ||
//
else if ((aType1==GeomAbs_SurfaceOfRevolution && aType2==GeomAbs_Cylinder) ||
- (aType2==GeomAbs_SurfaceOfRevolution && aType1==GeomAbs_Cylinder)) {
- Standard_Integer j, aNbP;
- Standard_Real aT, aT1, aT2, dT, aD2max, aD2;
- //
- aNbLin=mySeqOfCurve.Length();
- aD2max=0.;
- aNbP=11;
- //
- for (i=1; i<=aNbLin; ++i) {
- const IntTools_Curve& aIC=mySeqOfCurve(i);
- const Handle(Geom_Curve)& aC3D=aIC.Curve();
- const Handle(Geom2d_Curve)& aC2D1=aIC.FirstCurve2d();
- const Handle(Geom2d_Curve)& aC2D2=aIC.SecondCurve2d();
- //
- if (aC3D.IsNull()) {
- continue;
- }
- const Handle(Geom_BSplineCurve)& aBC=
- Handle(Geom_BSplineCurve)::DownCast(aC3D);
- if (aBC.IsNull()) {
- return;
- }
- //
- aT1=aBC->FirstParameter();
- aT2=aBC->LastParameter();
- //
- dT=(aT2-aT1)/(aNbP-1);
- for (j=0; j<aNbP; ++j) {
- aT=aT1+j*dT;
- if (j==aNbP-1) {
- aT=aT2;
- }
- //
- aD2=MaxSquareDistance(aT, aC3D, aC2D1, aC2D2,
- myHS1, myHS2, myFace1, myFace2, myContext);
- if (aD2>aD2max) {
- aD2max=aD2;
- }
- }//for (j=0; j<aNbP; ++j) {
-
- }//for (i=1; i<=aNbLin; ++i) {
- //
- aD2=myTolReached3d*myTolReached3d;
- if (aD2max > aD2) {
- myTolReached3d=sqrt(aD2max);
- }
- }//if((aType1==GeomAbs_SurfaceOfRevolution ...
- else if ((aType1==GeomAbs_Plane && aType2==GeomAbs_Sphere) ||
- (aType2==GeomAbs_Plane && aType1==GeomAbs_Sphere)) {
- Standard_Integer j, aNbP;
- Standard_Real aT1, aT2, dT, aD2max, aD2, aEps, aT11, aT12;
- //
- aNbLin=mySeqOfCurve.Length();
- aD2max=0.;
- aNbP=10;
+ (aType2==GeomAbs_SurfaceOfRevolution && aType1==GeomAbs_Cylinder) ||
+ (aType1==GeomAbs_Plane && aType2==GeomAbs_Sphere) ||
+ (aType2==GeomAbs_Plane && aType1==GeomAbs_Sphere) ||
+ (aType1==GeomAbs_Plane && aType2==GeomAbs_SurfaceOfExtrusion) ||
+ (aType2==GeomAbs_Plane && aType1==GeomAbs_SurfaceOfExtrusion) ||
+ (aType1==GeomAbs_Plane && aType2==GeomAbs_BSplineSurface) ||
+ (aType2==GeomAbs_Plane && aType1==GeomAbs_BSplineSurface) ||
+ !myApprox) {
//
- for (i=1; i<=aNbLin; ++i) {
- const IntTools_Curve& aIC=mySeqOfCurve(i);
- const Handle(Geom_Curve)& aC3D=aIC.Curve();
- const Handle(Geom2d_Curve)& aC2D1=aIC.FirstCurve2d();
- const Handle(Geom2d_Curve)& aC2D2=aIC.SecondCurve2d();
- //
- const Handle(Geom2d_BSplineCurve)& aBC2D1=
- Handle(Geom2d_BSplineCurve)::DownCast(aC2D1);
- const Handle(Geom2d_BSplineCurve)& aBC2D2=
- Handle(Geom2d_BSplineCurve)::DownCast(aC2D2);
- //
- if (aBC2D1.IsNull() && aBC2D2.IsNull()) {
- return;
- }
- //
- if (!aBC2D1.IsNull()) {
- aT1=aBC2D1->FirstParameter();
- aT2=aBC2D1->LastParameter();
- }
- else {
- aT1=aBC2D2->FirstParameter();
- aT2=aBC2D2->LastParameter();
- }
- //
- aEps=0.01*(aT2-aT1);
- dT=(aT2-aT1)/aNbP;
- for (j=0; j<aNbP; ++j) {
- aT11=aT1+j*dT;
- aT12=aT11+dT;
- if (j==aNbP-1) {
- aT12=aT2;
- }
- //
- aD2=FindMaxSquareDistance(aT11, aT12, aEps, aC3D, aC2D1, aC2D2,
- myHS1, myHS2, myFace1, myFace2, myContext);
- if (aD2>aD2max) {
- aD2max=aD2;
- }
- }//for (j=0; j<aNbP; ++j) {
-
- }//for (i=1; i<=aNbLin; ++i) {
+ Standard_Real aDMax;
//
- aD2=myTolReached3d*myTolReached3d;
- if (aD2max > aD2) {
- myTolReached3d=sqrt(aD2max);
+ aDMax = ComputeTolerance();
+ if (aDMax > myTolReached3d) {
+ myTolReached3d = aDMax;
}
- }//else if ((aType1==GeomAbs_Plane && aType2==GeomAbs_Sphere) ...
- else if (!myApprox || bCase1) {
- //else if (!myApprox) {
- Standard_Integer aNbP, j;
- Standard_Real aT1, aT2, dT, aD2, aD2Max, aEps, aT11, aT12;
- //
- aD2Max=0.;
- aNbLin=mySeqOfCurve.Length();
- //
- for (i=1; i<=aNbLin; ++i) {
- const IntTools_Curve& aIC=mySeqOfCurve(i);
- const Handle(Geom_Curve)& aC3D=aIC.Curve();
- const Handle(Geom2d_Curve)& aC2D1=aIC.FirstCurve2d();
- const Handle(Geom2d_Curve)& aC2D2=aIC.SecondCurve2d();
- //
- if (aC3D.IsNull()) {
- continue;
-}
- const Handle(Geom_BSplineCurve)& aBC=
- Handle(Geom_BSplineCurve)::DownCast(aC3D);
- if (aBC.IsNull()) {
- continue;
- }
- //
- aT1=aBC->FirstParameter();
- aT2=aBC->LastParameter();
- //
- aEps=0.0001*(aT2-aT1);
- aNbP=11;
- dT=(aT2-aT1)/aNbP;
- for (j=1; j<aNbP-1; ++j) {
- aT11=aT1+j*dT;
- aT12=aT11+dT;
- aD2=FindMaxSquareDistance(aT11, aT12, aEps, aC3D, aC2D1, aC2D2,
- myHS1, myHS2, myFace1, myFace2, myContext);
- if (aD2>aD2Max) {
- aD2Max=aD2;
- }
- }
- }//for (i=1; i<=aNbLin; ++i) {
- myTolReached3d=sqrt(aD2Max);
}
}
+
//=======================================================================
//function : MakeCurve
//purpose :
return;
}
}
+ //
// Do the Curve
-
-
- typl=L->ArcType();
+ //
switch (typl) {
//########################################
// Line, Parabola, Hyperbola
//
aNbParts=myLConstruct.NbParts();
for (i=1; i<=aNbParts; i++) {
+ Standard_Boolean bFNIt, bLPIt;
+ //
myLConstruct.Part(i, fprm, lprm);
-
- if (!Precision::IsNegativeInfinite(fprm) &&
- !Precision::IsPositiveInfinite(lprm)) {
+ //
+ bFNIt=Precision::IsNegativeInfinite(fprm);
+ bLPIt=Precision::IsPositiveInfinite(lprm);
+ //
+ if (!bFNIt && !bLPIt) {
//
IntTools_Curve aCurve;
//
//
aCurve.SetFirstCurve2d(H1);
}
-
+ //
if(myApprox2) {
Handle (Geom2d_Curve) C2d;
BuildPCurves(fprm,lprm,Tolpc,myHS2->ChangeSurface().Surface(),newc,C2d);
aCurve.SetSecondCurve2d(H1);
}
mySeqOfCurve.Append(aCurve);
- } // end of if (!Precision::IsNegativeInfinite(fprm) && !Precision::IsPositiveInfinite(lprm))
+ } //if (!bFNIt && !bLPIt) {
else {
// on regarde si on garde
//
- Standard_Boolean bFNIt, bLPIt;
Standard_Real aTestPrm, dT=100.;
-
- bFNIt=Precision::IsNegativeInfinite(fprm);
- bLPIt=Precision::IsPositiveInfinite(lprm);
-
+ //
aTestPrm=0.;
-
if (bFNIt && !bLPIt) {
aTestPrm=lprm-dT;
}
else if (!bFNIt && bLPIt) {
aTestPrm=fprm+dT;
}
-
+ else {
+ // i.e, if (bFNIt && bLPIt)
+ aTestPrm=IntTools_Tools::IntermediatePoint(-dT, dT);
+ }
+ //
gp_Pnt ptref(newc->Value(aTestPrm));
//
GeomAbs_SurfaceType typS1 = myHS1->GetType();
typS1 == GeomAbs_SurfaceOfRevolution ||
typS2 == GeomAbs_SurfaceOfExtrusion ||
typS2 == GeomAbs_OffsetSurface ||
- typS2 == GeomAbs_SurfaceOfRevolution)
- {
+ typS2 == GeomAbs_SurfaceOfRevolution) {
Handle(Geom2d_BSplineCurve) H1;
mySeqOfCurve.Append(IntTools_Curve(newc, H1, H1));
continue;
mySeqOfCurve.Append(IntTools_Curve(newc, H1, H1));
}
}
- }// end of for (i=1; i<=myLConstruct.NbParts(); i++)
+ }// for (i=1; i<=aNbParts; i++) {
}// case IntPatch_Lin: case IntPatch_Parabola: case IntPatch_Hyperbola:
break;
U0 = pm.X();
//
bAdjust =
- IntTools_Tools::AdjustPeriodic(U0, umin, umax, period, U0x, du, aEps);
+ GeomInt::AdjustPeriodic(U0, umin, umax, period, U0x, du, aEps);
if (bAdjust) {
gp_Vec2d T1(du, 0.);
C2d->Translate(T1);
const Handle(GeomAdaptor_HSurface)& theSurface2,
const TopoDS_Face& theFace1,
const TopoDS_Face& theFace2,
- const IntTools_LineConstructor& theLConstructor,
+ const GeomInt_LineConstructor& theLConstructor,
const Standard_Boolean theAvoidLConstructor,
IntPatch_SequenceOfLine& theNewLines,
Standard_Real& theReachedTol3d,
aParameter=V;
}
- IntTools_Tools::AdjustPeriodic(aParameter,
+ GeomInt::AdjustPeriodic(aParameter,
alowerboundary,
aupperboundary,
aPeriod,
continue;
}
const TColStd_ListOfInteger& aListOfIndex = anArrayOfLines.Value(i);
- if(aListOfIndex.Extent() < 2) {
- continue;
- }
TColStd_ListOfInteger aListOfFLIndex;
for(j = 0; j < 2; j++) {
const IntSurf_PntOn2S& aPoint = theWLine->Point(anIndex);
IntSurf_PntOn2S aNewP = aPoint;
-
+ if(aListOfIndex.Extent() < 2) {
+ aSeqOfPntOn2S->Add(aNewP);
+ aListOfFLIndex.Append(aSeqOfPntOn2S->NbPoints());
+ continue;
+ }
+ //
+ Standard_Integer iFirst = aListOfIndex.First();
+ Standard_Integer iLast = aListOfIndex.Last();
+ //
for(Standard_Integer surfit = 0; surfit < 2; surfit++) {
Handle(GeomAdaptor_HSurface) aGASurface = (surfit == 0) ? theSurface1 : theSurface2;
else {
Standard_Real aPeriod = (parit == 0) ? aGASurface->UPeriod() : aGASurface->VPeriod();
Standard_Real anoffset, anAdjustPar;
- IntTools_Tools::AdjustPeriodic(aParameter, alowerboundary, aupperboundary,
+ GeomInt::AdjustPeriodic(aParameter, alowerboundary, aupperboundary,
aPeriod, anAdjustPar, anoffset);
bIsPointOnBoundary=
nbboundaries++;
}
else {
- //check neighbourhood of boundary
- Standard_Real anEpsilon = aResolution * 100.;
- Standard_Real aPart = ( aupperboundary - alowerboundary ) * 0.1;
- anEpsilon = ( anEpsilon > aPart ) ? aPart : anEpsilon;
-
+ //check neighbourhood of boundary
+ Standard_Real anEpsilon = aResolution * 100.;
+ Standard_Real aPart = ( aupperboundary - alowerboundary ) * 0.1;
+ anEpsilon = ( anEpsilon > aPart ) ? aPart : anEpsilon;
+
bIsNearBoundary = IsPointOnBoundary(anAdjustPar, alowerboundary, aupperboundary,
anEpsilon, bIsOnFirstBoundary);
gp_Pnt2d aPZone = (surfit == 0) ? aTanZoneS1->Value(zIt) : aTanZoneS2->Value(zIt);
Standard_Real aZoneRadius = aTanZoneRadius->Value(zIt);
- Standard_Integer aneighbourpointindex1 = (j == 0) ? aListOfIndex.First() : aListOfIndex.Last();
+ Standard_Integer aneighbourpointindex1 = (j == 0) ? iFirst : iLast;
const IntSurf_PntOn2S& aNeighbourPoint = theWLine->Point(aneighbourpointindex1);
Standard_Real nU1, nV1;
Standard_Real aPeriod = (bIsUBoundary) ? aGASurface->UPeriod() : aGASurface->VPeriod();
Standard_Real aParameter = (bIsUBoundary) ? U : V;
Standard_Real anoffset, anAdjustPar;
- IntTools_Tools::AdjustPeriodic(aParameter, alowerboundary, aupperboundary,
+ GeomInt::AdjustPeriodic(aParameter, alowerboundary, aupperboundary,
aPeriod, anAdjustPar, anoffset);
Standard_Real adist = (bIsFirstBoundary) ? fabs(anAdjustPar - alowerboundary) : fabs(anAdjustPar - aupperboundary);
bCheckAngle1 = Standard_True;
aNewVec = gp_Vec2d(gp_Pnt2d(nU1, nV1), gp_Pnt2d(anewU, anewV));
- if(aNewVec.SquareMagnitude() < (gp::Resolution() * gp::Resolution())) {
+ if(aNewVec.SquareMagnitude() < gp::Resolution()) {
aNewP.SetValue((surfit == 0), anewU, anewV);
bCheckAngle1 = Standard_False;
}
bCheckAngle2 = Standard_True;
aNewVec = gp_Vec2d(gp_Pnt2d(nU1, nV1), gp_Pnt2d(U, V));
- if(aNewVec.SquareMagnitude() < (gp::Resolution() * gp::Resolution())) {
+ if(aNewVec.SquareMagnitude() < gp::Resolution()) {
bCheckAngle2 = Standard_False;
}
}
// assume there are at least two points in line (see "if" above)
Standard_Integer anindexother = aneighbourpointindex;
- while((anindexother <= aListOfIndex.Last()) && (anindexother >= aListOfIndex.First())) {
+ while((anindexother <= iLast) && (anindexother >= iFirst)) {
anindexother = (j == 0) ? (anindexother + 1) : (anindexother - 1);
const IntSurf_PntOn2S& aPrevNeighbourPoint = theWLine->Point(anindexother);
Standard_Real nU2, nV2;
aPrevNeighbourPoint.ParametersOnS2(nU2, nV2);
gp_Vec2d aVecOld(gp_Pnt2d(nU2, nV2), gp_Pnt2d(nU1, nV1));
- if(aVecOld.SquareMagnitude() <= (gp::Resolution() * gp::Resolution())) {
+ if(aVecOld.SquareMagnitude() <= gp::Resolution()) {
continue;
}
else {
else
anewpoint = gp_Pnt2d( u2, v2 );
- Standard_Integer aneighbourpointindex1 = (j == 0) ? aListOfIndex.First() : aListOfIndex.Last();
+ Standard_Integer aneighbourpointindex1 = (j == 0) ? iFirst : iLast;
const IntSurf_PntOn2S& aNeighbourPoint = theWLine->Point(aneighbourpointindex1);
Standard_Real nU1, nV1;
}
else {
- Standard_Integer aneighbourpointindex1 = (j == 0) ? aListOfIndex.First() : aListOfIndex.Last();
+ Standard_Integer aneighbourpointindex1 = (j == 0) ? iFirst : iLast;
const IntSurf_PntOn2S& aNeighbourPoint = theWLine->Point(aneighbourpointindex1);
Standard_Real nU1, nV1;
gp_Pnt2d ap2(nU1, nV1);
Standard_Integer aneighbourpointindex2 = aneighbourpointindex1;
- while((aneighbourpointindex2 <= aListOfIndex.Last()) && (aneighbourpointindex2 >= aListOfIndex.First())) {
+ while((aneighbourpointindex2 <= iLast) && (aneighbourpointindex2 >= iFirst)) {
aneighbourpointindex2 = (j == 0) ? (aneighbourpointindex2 + 1) : (aneighbourpointindex2 - 1);
const IntSurf_PntOn2S& aPrevNeighbourPoint = theWLine->Point(aneighbourpointindex2);
Standard_Real nU2, nV2;
ap2.SetX(nU2);
ap2.SetY(nV2);
- if(ap1.SquareDistance(ap2) > (gp::Resolution() * gp::Resolution())) {
+ if(ap1.SquareDistance(ap2) > gp::Resolution()) {
break;
}
}
//Correction of projected coordinates. Begin
//Note, it may be shifted on a period
- Standard_Integer aneindex1 = (j == 0) ? aListOfIndex.First() : aListOfIndex.Last();
+ Standard_Integer aneindex1 = (j == 0) ? iFirst : iLast;
const IntSurf_PntOn2S& aNeighbourPoint = theWLine->Point(aneindex1);
Standard_Real nUn, nVn;
continue;
}
const TColStd_ListOfInteger& aListOfIndex = anArrayOfLines.Value(i);
-
- if(aListOfIndex.Extent() < 2) {
- continue;
- }
const TColStd_ListOfInteger& aListOfFLIndex = anArrayOfLineEnds.Value(i);
Standard_Boolean bhasfirstpoint = (aListOfFLIndex.Extent() == 2);
Standard_Boolean bhaslastpoint = (aListOfFLIndex.Extent() == 2);
if(!bhaslastpoint && !aListOfFLIndex.IsEmpty()) {
bhaslastpoint = (i != nblines);
}
- Standard_Boolean bIsFirstInside = ((ifprm >= aListOfIndex.First()) && (ifprm <= aListOfIndex.Last()));
- Standard_Boolean bIsLastInside = ((ilprm >= aListOfIndex.First()) && (ilprm <= aListOfIndex.Last()));
+
+ Standard_Integer iFirst = aListOfIndex.First();
+ Standard_Integer iLast = aListOfIndex.Last();
+ Standard_Boolean bIsFirstInside = ((ifprm >= iFirst) && (ifprm <= iLast));
+ Standard_Boolean bIsLastInside = ((ilprm >= iFirst) && (ilprm <= iLast));
if(!bIsFirstInside && !bIsLastInside) {
- if((ifprm < aListOfIndex.First()) && (ilprm > aListOfIndex.Last())) {
+ if((ifprm < iFirst) && (ilprm > iLast)) {
// append whole line, and boundaries if neccesary
if(bhasfirstpoint) {
- const IntSurf_PntOn2S& aP = aSeqOfPntOn2S->Value(aListOfFLIndex.First());
+ pit = aListOfFLIndex.First();
+ const IntSurf_PntOn2S& aP = aSeqOfPntOn2S->Value(pit);
aLineOn2S->Add(aP);
}
TColStd_ListIteratorOfListOfInteger anIt(aListOfIndex);
for(; anIt.More(); anIt.Next()) {
- const IntSurf_PntOn2S& aP = theWLine->Point(anIt.Value());
+ pit = anIt.Value();
+ const IntSurf_PntOn2S& aP = theWLine->Point(pit);
aLineOn2S->Add(aP);
}
if(bhaslastpoint) {
- const IntSurf_PntOn2S& aP = aSeqOfPntOn2S->Value(aListOfFLIndex.Last());
+ pit = aListOfFLIndex.Last();
+ const IntSurf_PntOn2S& aP = aSeqOfPntOn2S->Value(pit);
aLineOn2S->Add(aP);
}
TColStd_ListIteratorOfListOfInteger anIt(aListOfIndex);
for(; anIt.More(); anIt.Next()) {
- if((anIt.Value() < ifprm) || (anIt.Value() > ilprm))
+ pit = anIt.Value();
+ if((pit < ifprm) || (pit > ilprm))
continue;
- const IntSurf_PntOn2S& aP = theWLine->Point(anIt.Value());
+ const IntSurf_PntOn2S& aP = theWLine->Point(pit);
aLineOn2S->Add(aP);
}
}
TColStd_ListIteratorOfListOfInteger anIt(aListOfIndex);
for(; anIt.More(); anIt.Next()) {
- if(anIt.Value() < ifprm)
+ pit = anIt.Value();
+ if(pit < ifprm)
continue;
- const IntSurf_PntOn2S& aP = theWLine->Point(anIt.Value());
+ const IntSurf_PntOn2S& aP = theWLine->Point(pit);
aLineOn2S->Add(aP);
}
if(bhaslastpoint) {
- const IntSurf_PntOn2S& aP = aSeqOfPntOn2S->Value(aListOfFLIndex.Last());
+ pit = aListOfFLIndex.Last();
+ const IntSurf_PntOn2S& aP = aSeqOfPntOn2S->Value(pit);
aLineOn2S->Add(aP);
}
// check end of split line (end is almost always)
if(bIsLastInside) {
// append points from first boundary point to ilprm
if(bhasfirstpoint) {
- const IntSurf_PntOn2S& aP = aSeqOfPntOn2S->Value(aListOfFLIndex.First());
+ pit = aListOfFLIndex.First();
+ const IntSurf_PntOn2S& aP = aSeqOfPntOn2S->Value(pit);
aLineOn2S->Add(aP);
}
TColStd_ListIteratorOfListOfInteger anIt(aListOfIndex);
for(; anIt.More(); anIt.Next()) {
- if(anIt.Value() > ilprm)
+ pit = anIt.Value();
+ if(pit > ilprm)
continue;
- const IntSurf_PntOn2S& aP = theWLine->Point(anIt.Value());
+ const IntSurf_PntOn2S& aP = theWLine->Point(pit);
aLineOn2S->Add(aP);
}
}
}
return aIndex;
}
-#ifdef DEB_DUMPWLINE
+#ifdef OCCT_DEBUG_DUMPWLINE
//=======================================================================
//function : DumpWLine
//purpose :
aV2D.SetCoord(aC[0], aC[1]);
}
//=======================================================================
-//function : FindMaxSquareDistance
-//purpose :
+// Function : FindMaxDistance
+// purpose :
//=======================================================================
-Standard_Real FindMaxSquareDistance (const Standard_Real aT1,
- const Standard_Real aT2,
- const Standard_Real aEps,
- const Handle(Geom_Curve)& aC3D,
- const Handle(Geom2d_Curve)& aC2D1,
- const Handle(Geom2d_Curve)& aC2D2,
- const Handle(GeomAdaptor_HSurface)& myHS1,
- const Handle(GeomAdaptor_HSurface)& myHS2,
- const TopoDS_Face& myFace1,
- const TopoDS_Face& myFace2,
- const Handle(IntTools_Context)& myContext)
+Standard_Real FindMaxDistance(const Handle(Geom_Curve)& theCurve,
+ const Standard_Real theFirst,
+ const Standard_Real theLast,
+ const TopoDS_Face& theFace,
+ const Handle(IntTools_Context)& theContext)
{
- Standard_Real aA, aB, aCf, aX1, aX2, aF1, aF2, aX, aF;
+ Standard_Integer aNbS;
+ Standard_Real aT1, aT2, aDt, aD, aDMax, anEps;
//
- aCf=1.6180339887498948482045868343656;// =0.5*(1.+sqrt(5.));
- aA=aT1;
- aB=aT2;
- aX1=aB-(aB-aA)/aCf;
- aF1=MaxSquareDistance(aX1,
- aC3D, aC2D1, aC2D2, myHS1, myHS2, myFace1, myFace2, myContext);
- aX2=aA+(aB-aA)/aCf;
- aF2=MaxSquareDistance(aX2,
- aC3D, aC2D1, aC2D2, myHS1, myHS2, myFace1, myFace2, myContext);
+ aNbS = 11;
+ aDt = (theLast - theFirst) / aNbS;
+ aDMax = 0.;
+ anEps = 1.e-4 * aDt;
//
- for(;;) {
+ GeomAPI_ProjectPointOnSurf& aProjPS = theContext->ProjPS(theFace);
+ aT2 = theFirst;
+ for (;;) {
+ aT1 = aT2;
+ aT2 += aDt;
//
- if (fabs(aA-aB)<aEps) {
- aX=0.5*(aA+aB);
- aF=MaxSquareDistance(aX,
- aC3D, aC2D1, aC2D2, myHS1, myHS2, myFace1, myFace2, myContext);
+ if (aT2 > theLast) {
break;
}
- if (aF1<aF2){
- aA=aX1;
- aX1=aX2;
- aF1=aF2;
- aX2=aA+(aB-aA)/aCf;
- aF2=MaxSquareDistance(aX2,
- aC3D, aC2D1, aC2D2, myHS1, myHS2, myFace1, myFace2, myContext);
-
- }
- else {
- aB=aX2;
- aX2=aX1;
- aF2=aF1;
- aX1=aB-(aB-aA)/aCf;
- aF1=MaxSquareDistance(aX1,
- aC3D, aC2D1, aC2D2, myHS1, myHS2, myFace1, myFace2, myContext);
+ //
+ aD = FindMaxDistance(theCurve, aT1, aT2, aProjPS, anEps);
+ if (aD > aDMax) {
+ aDMax = aD;
}
}
- return aF;
+ //
+ return aDMax;
}
//=======================================================================
-//function : MaxSquareDistance
-//purpose :
+// Function : FindMaxDistance
+// purpose :
//=======================================================================
-Standard_Real MaxSquareDistance (const Standard_Real aT,
- const Handle(Geom_Curve)& aC3D,
- const Handle(Geom2d_Curve)& aC2D1,
- const Handle(Geom2d_Curve)& aC2D2,
- const Handle(GeomAdaptor_HSurface) myHS1,
- const Handle(GeomAdaptor_HSurface) myHS2,
- const TopoDS_Face& aF1,
- const TopoDS_Face& aF2,
- const Handle(IntTools_Context)& aCtx)
+Standard_Real FindMaxDistance(const Handle(Geom_Curve)& theC,
+ const Standard_Real theFirst,
+ const Standard_Real theLast,
+ GeomAPI_ProjectPointOnSurf& theProjPS,
+ const Standard_Real theEps)
{
- Standard_Boolean bIsDone;
- Standard_Integer i;
- Standard_Real aU, aV, aD2Max, aD2;
- gp_Pnt2d aP2D;
- gp_Pnt aP, aPS;
+ Standard_Real aA, aB, aCf, aX, aX1, aX2, aF1, aF2, aF;
//
- aD2Max=0.;
+ aCf = 0.61803398874989484820458683436564;//(sqrt(5.)-1)/2.;
+ aA = theFirst;
+ aB = theLast;
//
- aC3D->D0(aT, aP);
- if (aC3D.IsNull()) {
- return aD2Max;
- }
+ aX1 = aB - aCf * (aB - aA);
+ aF1 = MaxDistance(theC, aX1, theProjPS);
+ aX2 = aA + aCf * (aB - aA);
+ aF2 = MaxDistance(theC, aX2, theProjPS);
//
- for (i=0; i<2; ++i) {
- const Handle(GeomAdaptor_HSurface)& aGHS=(!i) ? myHS1 : myHS2;
- const TopoDS_Face &aF=(!i) ? aF1 : aF2;
- const Handle(Geom2d_Curve)& aC2D=(!i) ? aC2D1 : aC2D2;
- //
- if (!aC2D.IsNull()) {
- aC2D->D0(aT, aP2D);
- aP2D.Coord(aU, aV);
- aGHS->D0(aU, aV, aPS);
- aD2=aP.SquareDistance(aPS);
- if (aD2>aD2Max) {
- aD2Max=aD2;
- }
+ for (;;) {
+ if ((aB - aA) < theEps) {
+ break;
}
//
- GeomAPI_ProjectPointOnSurf& aProjector=aCtx->ProjPS(aF);
- //
- aProjector.Perform(aP);
- bIsDone=aProjector.IsDone();
- if (bIsDone) {
- aProjector.LowerDistanceParameters(aU, aV);
- aGHS->D0(aU, aV, aPS);
- aD2=aP.SquareDistance(aPS);
- if (aD2>aD2Max) {
- aD2Max=aD2;
- }
+ if (aF1 > aF2) {
+ aB = aX2;
+ aX2 = aX1;
+ aF2 = aF1;
+ aX1 = aB - aCf * (aB - aA);
+ aF1 = MaxDistance(theC, aX1, theProjPS);
}
+ else {
+ aA = aX1;
+ aX1 = aX2;
+ aF1 = aF2;
+ aX2 = aA + aCf * (aB - aA);
+ aF2 = MaxDistance(theC, aX2, theProjPS);
+ }
+ }
+ //
+ aX = 0.5 * (aA + aB);
+ aF = MaxDistance(theC, aX, theProjPS);
+ //
+ if (aF1 > aF) {
+ aF = aF1;
}
//
- return aD2Max;
+ if (aF2 > aF) {
+ aF = aF2;
+ }
+ //
+ return aF;
+}
+//=======================================================================
+// Function : MaxDistance
+// purpose :
+//=======================================================================
+Standard_Real MaxDistance(const Handle(Geom_Curve)& theC,
+ const Standard_Real aT,
+ GeomAPI_ProjectPointOnSurf& theProjPS)
+{
+ Standard_Real aD;
+ gp_Pnt aP;
+ //
+ theC->D0(aT, aP);
+ theProjPS.Perform(aP);
+ aD = theProjPS.NbPoints() ? theProjPS.LowerDistance() : 0.;
+ //
+ return aD;
}
//=======================================================================
projects / occt.git / blobdiff