#include <BRepTools.hxx>
#include <BRepAdaptor_Surface.hxx>
-#include <BOPTColStd_Dump.hxx>
-
#include <IntTools_Curve.hxx>
#include <IntTools_Tools.hxx>
#include <IntTools_Tools.hxx>
#include <IntTools_TopolTool.hxx>
#include <IntTools_PntOnFace.hxx>
#include <IntTools_PntOn2Faces.hxx>
-#include <IntTools_Context.hxx>
+#include <BOPInt_Context.hxx>
#include <IntSurf_ListIteratorOfListOfPntOn2S.hxx>
static
const Standard_Boolean theAvoidLConstructor,
IntPatch_SequenceOfLine& theNewLines,
Standard_Real& theReachedTol3d,
- const Handle(IntTools_Context)& );
+ const Handle(BOPInt_Context)& );
static
Standard_Boolean ParameterOutOfBoundary(const Standard_Real theParameter,
const Standard_Real theOtherParameter,
const Standard_Boolean bIncreasePar,
Standard_Real& theNewParameter,
- const Handle(IntTools_Context)& );
+ const Handle(BOPInt_Context)& );
static
Standard_Boolean IsCurveValid(Handle(Geom2d_Curve)& thePCurve);
Handle(TColgp_HArray1OfPnt2d)& theResultOnS1,
Handle(TColgp_HArray1OfPnt2d)& theResultOnS2,
Handle(TColStd_HArray1OfReal)& theResultRadius,
- const Handle(IntTools_Context)& );
+ const Handle(BOPInt_Context)& );
static
Standard_Boolean FindPoint(const gp_Pnt2d& theFirstPoint,
const Handle(GeomAdaptor_HSurface) myHS2,
const TopoDS_Face& aF1,
const TopoDS_Face& aF2,
- const Handle(IntTools_Context)& aCtx);
+ const Handle(BOPInt_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(BOPInt_Context)& aCtx);
+
//=======================================================================
//function :
//purpose :
//=======================================================================
IntTools_FaceFace::IntTools_FaceFace()
{
+ myIsDone=Standard_False;
myTangentFaces=Standard_False;
//
myHS1 = new GeomAdaptor_HSurface ();
//function : SetContext
//purpose :
//=======================================================================
-void IntTools_FaceFace::SetContext(const Handle(IntTools_Context)& aContext)
+void IntTools_FaceFace::SetContext(const Handle(BOPInt_Context)& aContext)
{
myContext=aContext;
}
//function : Context
//purpose :
//=======================================================================
-const Handle(IntTools_Context)& IntTools_FaceFace::Context()const
+const Handle(BOPInt_Context)& IntTools_FaceFace::Context()const
{
return myContext;
}
BRepAdaptor_Surface aBAS1, aBAS2;
//
if (myContext.IsNull()) {
- myContext=new IntTools_Context;
+ myContext=new BOPInt_Context;
}
//
mySeqOfCurve.Clear();
GeomAbs_SurfaceType aType1, aType2;
//
aNbLin=myIntersector.NbLines();
+ if (!aNbLin) {
+ return;
+ }
+ //
aType1=myHS1->Surface().GetType();
aType2=myHS2->Surface().GetType();
//
}
}
//ZZ
-
- {// Check the distances
- Standard_Integer i, j, aNbP;
- Standard_Real aT, aT1, aT2, dT, aD2, aD2Max;
+ if (aNbLin) {// Check the distances
+ Standard_Integer i, aNbP, j ;
+ Standard_Real aT1, aT2, dT, aD2, aD2Max, aEps, aT11, aT12;
//
aD2Max=0.;
- aNbP=11;
+ aNbP=10;
aNbLin=mySeqOfCurve.Length();
//
for (i=1; i<=aNbLin; ++i) {
aT1=aBC->FirstParameter();
aT2=aBC->LastParameter();
//
- aNbP--;
+ aEps=0.01*(aT2-aT1);
dT=(aT2-aT1)/aNbP;
- //modified by NIZNHY-PKV Tue Apr 17 14:36:33 2012f
for (j=1; j<aNbP; ++j) {
- aT=aT1+j*dT;
- aD2=MaxSquareDistance(aT, aC3D, aC2D1, aC2D2,
- myHS1, myHS2, myFace1, myFace2, myContext);
+ 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 (j=0; j<aNbP; ++j) {
+ }
}//for (i=1; i<=aNbLin; ++i) {
//
myTolReached3d=sqrt(aD2Max);
- }
-
+ }// if (aNbLin)
}// if (aType1==GeomAbs_Cylinder && aType2==GeomAbs_Cylinder) {
//
//904/G3 f
aD2max=aD2;
}
}//for (j=0; j<aNbP; ++j) {
+
}//for (i=1; i<=aNbLin; ++i) {
//
aD2=myTolReached3d*myTolReached3d;
myTolReached3d=sqrt(aD2max);
}
}//if((aType1==GeomAbs_SurfaceOfRevolution ...
+ else if ((aType1==GeomAbs_Plane && aType2==GeomAbs_Sphere) ||
+ (aType2==GeomAbs_Plane && aType1==GeomAbs_Sphere)) {
+ Standard_Integer i, j, aNbP;
+ Standard_Real aT1, aT2, dT, aD2max, aD2, aEps, aT11, aT12;
+ //
+ aNbLin=mySeqOfCurve.Length();
+ aD2max=0.;
+ aNbP=10;
+ //
+ 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) {
+ //
+ aD2=myTolReached3d*myTolReached3d;
+ if (aD2max > aD2) {
+ myTolReached3d=sqrt(aD2max);
+ }
+ }//else if ((aType1==GeomAbs_Plane && aType2==GeomAbs_Sphere) ...
+ else if (!myApprox) {
+ Standard_Integer i, 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);
+ }
+ //modified by NIZNHY-PKV Thu Aug 30 13:31:12 2012t
}
//=======================================================================
//function : MakeCurve
const Handle(Adaptor3d_TopolTool)& dom1,
const Handle(Adaptor3d_TopolTool)& dom2)
{
- Standard_Boolean bDone, rejectSurface, reApprox, bAvoidLineConstructor;
+ Standard_Boolean bDone, rejectSurface, reApprox, bAvoidLineConstructor,
+ bPCurvesOk;
Standard_Boolean ok;
Standard_Integer i, j, aNbParts;
Standard_Real fprm, lprm;
//
rejectSurface = Standard_False;
reApprox = Standard_False;
+ //
+ bPCurvesOk = Standard_True;
reapprox:;
goto reapprox;
}
}
- // ###########################################
+ // ###########################################
+ bPCurvesOk = CheckPCurve(BS1, myFace2);
aCurve.SetSecondCurve2d(BS1);
}
else {
goto reapprox;
}
}
- // ###########################################
+ // ###########################################
+ bPCurvesOk = bPCurvesOk && CheckPCurve(BS2, myFace1);
aCurve.SetFirstCurve2d(BS2);
}
else {
aCurve.SetFirstCurve2d(H1);
}
//
- mySeqOfCurve.Append(aCurve);
+ //if points of the pcurves are out of the faces bounds
+ //create 3d and 2d curves without approximation
+ if (!bPCurvesOk) {
+ Handle(Geom2d_BSplineCurve) H1, H2;
+ bPCurvesOk = Standard_True;
+ //
+ Handle(Geom_Curve) aBSp=MakeBSpline(WL,ifprm, ilprm);
+
+ if(myApprox1) {
+ H1 = MakeBSpline2d(WL, ifprm, ilprm, Standard_True);
+ bPCurvesOk = CheckPCurve(H1, myFace1);
+ }
+
+ if(myApprox2) {
+ H2 = MakeBSpline2d(WL, ifprm, ilprm, Standard_False);
+ bPCurvesOk = bPCurvesOk && CheckPCurve(H2, myFace2);
+ }
+ //
+ //if pcurves created without approximation are out of the
+ //faces bounds, use approximated 3d and 2d curves
+ if (bPCurvesOk) {
+ IntTools_Curve aIC(aBSp, H1, H2);
+ mySeqOfCurve.Append(aIC);
+ } else {
+ mySeqOfCurve.Append(aCurve);
+ }
+ } else {
+ mySeqOfCurve.Append(aCurve);
+ }
}
else {
const AppParCurves_MultiBSpCurve& mbspc = theapp3d.Value(j);
}
}
}
- if (C2d.IsNull()) {
- BOPTColStd_Dump::PrintMessage("BuildPCurves()=> Echec ProjLib\n");
- }
}
//=======================================================================
enlarge=Standard_True;
}
//
+ if (aType==GeomAbs_Sphere) {
+ Standard_Real dV;
+ //
+ dV=thevmax-thevmin;
+ if (dV+delta<M_PI) {
+ enlarge=Standard_True;
+ }
+ }
+ //
if(!isuperiodic && enlarge) {
if((theumin - uinf) > delta )
// because inside degenerated zone of the surface the approx. algo.
// uses wrong values of normal, etc., and resulting curve will have
// oscillations that we would not like to have.
-// PKV Tue Feb 12 2002
+
static
Standard_Boolean IsDegeneratedZone(const gp_Pnt2d& aP2d,
const Handle(Geom_Surface)& aS,
Handle(TColgp_HArray1OfPnt2d)& theResultOnS1,
Handle(TColgp_HArray1OfPnt2d)& theResultOnS2,
Handle(TColStd_HArray1OfReal)& theResultRadius,
- const Handle(IntTools_Context)& aContext)
+ const Handle(BOPInt_Context)& aContext)
{
Standard_Integer aResult = 0;
if ( !CheckTangentZonesExist( theSurface1, theSurface2 ) )
const Standard_Boolean theAvoidLConstructor,
IntPatch_SequenceOfLine& theNewLines,
Standard_Real& theReachedTol3d,
- const Handle(IntTools_Context)& aContext)
+ const Handle(BOPInt_Context)& aContext)
{
Standard_Boolean bRet, bAvoidLineConstructor;
const Standard_Real theOtherParameter,
const Standard_Boolean bIncreasePar,
Standard_Real& theNewParameter,
- const Handle(IntTools_Context)& aContext)
+ const Handle(BOPInt_Context)& aContext)
{
Standard_Boolean bIsComputed = Standard_False;
theNewParameter = theParameter;
}
}
aV2D.SetCoord(aC[0], aC[1]);
-}
+}
+//=======================================================================
+//function : FindMaxSquareDistance
+//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(BOPInt_Context)& myContext)
+{
+ Standard_Real aA, aB, aCf, aX1, aX2, aF1, aF2, aX, aF;
+ //
+ 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);
+ //
+ while(1) {
+ //
+ if (fabs(aA-aB)<aEps) {
+ aX=0.5*(aA+aB);
+ aF=MaxSquareDistance(aX,
+ aC3D, aC2D1, aC2D2, myHS1, myHS2, myFace1, myFace2, myContext);
+ 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);
+ }
+ }
+ return aF;
+}
//=======================================================================
//function : MaxSquareDistance
//purpose :
const Handle(GeomAdaptor_HSurface) myHS2,
const TopoDS_Face& aF1,
const TopoDS_Face& aF2,
- const Handle(IntTools_Context)& aCtx)
+ const Handle(BOPInt_Context)& aCtx)
{
Standard_Boolean bIsDone;
Standard_Integer i;
//
return aD2Max;
}
+
+//=======================================================================
+//function : CheckPCurve
+//purpose : Checks if points of the pcurve are out of the face bounds.
+//=======================================================================
+ Standard_Boolean CheckPCurve(const Handle(Geom2d_Curve)& aPC,
+ const TopoDS_Face& aFace)
+{
+ const Standard_Integer NPoints = 23;
+ Standard_Real umin,umax,vmin,vmax;
+
+ BRepTools::UVBounds(aFace, umin, umax, vmin, vmax);
+ Standard_Real tolU = Max ((umax-umin)*0.01, Precision::Confusion());
+ Standard_Real tolV = Max ((vmax-vmin)*0.01, Precision::Confusion());
+ Standard_Real fp = aPC->FirstParameter();
+ Standard_Real lp = aPC->LastParameter();
+ Standard_Real step = (lp-fp)/(NPoints+1);
+
+ // adjust domain for periodic surfaces
+ TopLoc_Location aLoc;
+ Handle(Geom_Surface) aSurf = BRep_Tool::Surface(aFace, aLoc);
+ if (aSurf->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface)))
+ aSurf = (Handle(Geom_RectangularTrimmedSurface)::DownCast(aSurf))->BasisSurface();
+
+ gp_Pnt2d pnt = aPC->Value((fp+lp)/2);
+ Standard_Real u,v;
+ pnt.Coord(u,v);
+
+ if (aSurf->IsUPeriodic()) {
+ Standard_Real aPer = aSurf->UPeriod();
+ Standard_Integer nshift = (Standard_Integer) ((u-umin)/aPer);
+ if (u < umin+aPer*nshift) nshift--;
+ umin += aPer*nshift;
+ umax += aPer*nshift;
+ }
+ if (aSurf->IsVPeriodic()) {
+ Standard_Real aPer = aSurf->VPeriod();
+ Standard_Integer nshift = (Standard_Integer) ((v-vmin)/aPer);
+ if (v < vmin+aPer*nshift) nshift--;
+ vmin += aPer*nshift;
+ vmax += aPer*nshift;
+ }
+
+ Standard_Integer i;
+ for (i=1; i <= NPoints; i++) {
+ Standard_Real p = fp + i * step;
+ pnt = aPC->Value(p);
+ pnt.Coord(u,v);
+ if (umin-u > tolU || u-umax > tolU ||
+ vmin-v > tolV || v-vmax > tolV)
+ return Standard_False;
+ }
+ return Standard_True;
+
+}