From d4b867e61797d904921237008e1530a10ae9efcb Mon Sep 17 00:00:00 2001 From: nbv Date: Wed, 25 Mar 2015 09:52:07 +0300 Subject: [PATCH] 0025416: Wrong section curve 1. Restriction line is processed in IntTools_FaceFace with using methods of GeomInt_IntSS class. 2. Check, if Restriction- and Walking-lines (or Restriction-Restriction lines) are coincided, has been added in IntPatch_ImpPrmIntersection.cxx (at that RLine is considered to be isoline only). 3. Check, if RLine and GLine are coincided, has been added in IntPatch_ImpImpIntersection.cxx. 4. Create new class IntPatch_PointLine, which is inherited from IntPatch_Line. 5. The reason of exception (in DEBUG MODE) has been eliminated. New test cases for issue #25416 were added. tests/bugs/modalg_5/bug24650 was modified. --- src/BOPTools/BOPTools_AlgoTools3D.cxx | 6 + src/GeomInt/FILES | 1 + src/GeomInt/GeomInt.cdl | 4 +- src/GeomInt/GeomInt_IntSS.cdl | 28 +- src/GeomInt/GeomInt_IntSS_1.cxx | 576 ++++++++++++------ src/GeomInt/GeomInt_VectorOfReal.hxx | 23 + src/IntPatch/IntPatch.cdl | 13 +- src/IntPatch/IntPatch_ImpImpIntersection.cdl | 20 +- .../IntPatch_ImpImpIntersection_0.gxx | 162 ++++- .../IntPatch_ImpImpIntersection_2.gxx | 12 +- src/IntPatch/IntPatch_ImpPrmIntersection.cxx | 247 ++++++-- src/IntPatch/IntPatch_Intersection.cdl | 32 +- src/IntPatch/IntPatch_Intersection.cxx | 28 +- src/IntPatch/IntPatch_Point.cdl | 1 - src/IntPatch/IntPatch_PointLine.cdl | 75 +++ src/IntPatch/IntPatch_PointLine.cxx | 36 ++ src/IntPatch/IntPatch_RLine.cdl | 2 +- src/IntPatch/IntPatch_RLine.cxx | 17 +- src/IntPatch/IntPatch_WLine.cdl | 2 +- src/IntPatch/IntPatch_WLine.cxx | 6 +- src/IntTools/IntTools_FaceFace.cxx | 274 +++++---- .../TopOpeBRep_FacesIntersector.cxx | 3 +- src/gp/gp_Lin2d.lxx | 6 +- tests/boolean/bopsection/B5 | 2 +- tests/boolean/bsection/B5 | 2 +- tests/bugs/modalg_5/bug24650 | 71 ++- tests/bugs/modalg_5/bug25416_1 | 124 ++++ tests/bugs/modalg_5/bug25416_2 | 127 ++++ tests/bugs/modalg_5/bug25416_3 | 44 ++ 29 files changed, 1526 insertions(+), 418 deletions(-) create mode 100644 src/GeomInt/GeomInt_VectorOfReal.hxx create mode 100644 src/IntPatch/IntPatch_PointLine.cdl create mode 100644 src/IntPatch/IntPatch_PointLine.cxx create mode 100644 tests/bugs/modalg_5/bug25416_1 create mode 100644 tests/bugs/modalg_5/bug25416_2 create mode 100644 tests/bugs/modalg_5/bug25416_3 diff --git a/src/BOPTools/BOPTools_AlgoTools3D.cxx b/src/BOPTools/BOPTools_AlgoTools3D.cxx index 81b3ad4775..eecfd809a4 100644 --- a/src/BOPTools/BOPTools_AlgoTools3D.cxx +++ b/src/BOPTools/BOPTools_AlgoTools3D.cxx @@ -796,6 +796,12 @@ Standard_Integer BOPTools_AlgoTools3D::PointInFace } } // + if(!aHatcher.IsDone(aIx)) + { + iErr=2; + return iErr; + } + aNbDomains=aHatcher.NbDomains(aIx); if (aNbDomains > 0) { const HatchGen_Domain& aDomain=aHatcher.Domain (aIx, 1); diff --git a/src/GeomInt/FILES b/src/GeomInt/FILES index a1d19b2db5..86da84a8fd 100755 --- a/src/GeomInt/FILES +++ b/src/GeomInt/FILES @@ -1 +1,2 @@ GeomInt_IntSS_1.cxx +GeomInt_VectorOfReal.hxx \ No newline at end of file diff --git a/src/GeomInt/GeomInt.cdl b/src/GeomInt/GeomInt.cdl index 700e591a93..1e1eec97cb 100644 --- a/src/GeomInt/GeomInt.cdl +++ b/src/GeomInt/GeomInt.cdl @@ -35,11 +35,13 @@ uses StdFail, IntSurf, IntPatch, - ApproxInt + ApproxInt, + Bnd is class IntSS; + imported VectorOfReal; class LineConstructor; diff --git a/src/GeomInt/GeomInt_IntSS.cdl b/src/GeomInt/GeomInt_IntSS.cdl index cdd9a9b0b5..959ff04a02 100644 --- a/src/GeomInt/GeomInt_IntSS.cdl +++ b/src/GeomInt/GeomInt_IntSS.cdl @@ -30,8 +30,11 @@ uses Intersection from IntPatch, Surface from Geom, HSurface from GeomAdaptor, TopolTool from Adaptor3d, - Line from IntPatch - + Line from IntPatch, + RLine from IntPatch, + Box2d from Bnd, + VectorOfReal from GeomInt + raises NotDone from StdFail, OutOfRange from Standard @@ -191,6 +194,27 @@ is aTolCheck:out Real from Standard; aTolAngCheck:out Real from Standard); + TreatRLine(myclass; theRL: RLine from IntPatch; + theHS1, theHS2: HSurface from GeomAdaptor; + theC3d: out Curve from Geom; + theC2d1, theC2d2: out Curve from Geom2d; + theTolReached: out Real from Standard); + ---Purpose: converts RLine to Geom(2d)_Curve. + + BuildPCurves(myclass; f, l : Real from Standard; + Tol: out Real from Standard; + S: Surface from Geom; + C: Curve from Geom; + C2d: out Curve from Geom2d); + ---Purpose: creates 2D-curve on given surface from given 3D-curve + + TrimILineOnSurfBoundaries(myclass; theC2d1, theC2d2: Curve from Geom2d; + theBound1, theBound2: Box2d from Bnd; + theArrayOfParameters: out VectorOfReal from GeomInt); + ---Purpose: puts into theArrayOfParameters the parameters of intersection + -- points of given theC2d1 and theC2d2 curves with the boundaries + -- of the source surface. + --- Private methods -- -- diff --git a/src/GeomInt/GeomInt_IntSS_1.cxx b/src/GeomInt/GeomInt_IntSS_1.cxx index 609cda12a5..aaaf02a55c 100644 --- a/src/GeomInt/GeomInt_IntSS_1.cxx +++ b/src/GeomInt/GeomInt_IntSS_1.cxx @@ -14,8 +14,12 @@ // Alternatively, this file may be used under the terms of Open CASCADE // commercial license or contractual agreement. +#include + #include +#include + #include #include #include @@ -75,13 +79,22 @@ #include #include -static - void BuildPCurves (Standard_Real f, - Standard_Real l, - Standard_Real& Tol, - const Handle (Geom_Surface)& S, - const Handle (Geom_Curve)& C, - Handle (Geom2d_Curve)& C2d); +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include static void Parameters(const Handle(GeomAdaptor_HSurface)& HS1, @@ -145,20 +158,6 @@ static void GetQuadric(const Handle(GeomAdaptor_HSurface)& HS1, IntSurf_Quadric& quad1); -static - void TreatRLine(const Handle(IntPatch_RLine)& theRL, - const Handle(GeomAdaptor_HSurface)& theHS1, - const Handle(GeomAdaptor_HSurface)& theHS2, - const Standard_Boolean theApprox1, - const Standard_Boolean theApprox2, - Handle(Geom_Curve)& theC3d, - Handle(Geom2d_Curve)& theC2d1, - Handle(Geom2d_Curve)& theC2d2, - Standard_Real& theTolReached); - -// - - class ProjectPointOnSurf { public: @@ -251,13 +250,13 @@ Standard_Real ProjectPointOnSurf::LowerDistance() const //function : MakeCurve //purpose : //======================================================================= - void GeomInt_IntSS::MakeCurve(const Standard_Integer Index, - const Handle(Adaptor3d_TopolTool) & dom1, - const Handle(Adaptor3d_TopolTool) & dom2, - const Standard_Real Tol, - const Standard_Boolean Approx, - const Standard_Boolean ApproxS1, - const Standard_Boolean ApproxS2) +void GeomInt_IntSS::MakeCurve(const Standard_Integer Index, + const Handle(Adaptor3d_TopolTool) & dom1, + const Handle(Adaptor3d_TopolTool) & dom2, + const Standard_Real Tol, + const Standard_Boolean Approx, + const Standard_Boolean ApproxS1, + const Standard_Boolean ApproxS2) { Standard_Boolean myApprox1, myApprox2, myApprox; @@ -1036,96 +1035,92 @@ Standard_Real ProjectPointOnSurf::LowerDistance() const default: break; } - if(!isAnalS1 || !isAnalS2) + Handle(IntPatch_RLine) RL = + Handle(IntPatch_RLine)::DownCast(L); + Handle(Geom_Curve) aC3d; + Handle(Geom2d_Curve) aC2d1, aC2d2; + Standard_Real aTolReached; + TreatRLine(RL, myHS1, myHS2, aC3d, + aC2d1, aC2d2, aTolReached); + + if(aC3d.IsNull()) + break; + + Bnd_Box2d aBox1, aBox2; + + const Standard_Real aU1f = myHS1->FirstUParameter(), + aV1f = myHS1->FirstVParameter(), + aU1l = myHS1->LastUParameter(), + aV1l = myHS1->LastVParameter(); + const Standard_Real aU2f = myHS2->FirstUParameter(), + aV2f = myHS2->FirstVParameter(), + aU2l = myHS2->LastUParameter(), + aV2l = myHS2->LastVParameter(); + + aBox1.Add(gp_Pnt2d(aU1f, aV1f)); + aBox1.Add(gp_Pnt2d(aU1l, aV1l)); + aBox2.Add(gp_Pnt2d(aU2f, aV2f)); + aBox2.Add(gp_Pnt2d(aU2l, aV2l)); + + GeomInt_VectorOfReal anArrayOfParameters; + + //We consider here that the intersection line is same-parameter-line + anArrayOfParameters.Append(aC3d->FirstParameter()); + anArrayOfParameters.Append(aC3d->LastParameter()); + + TrimILineOnSurfBoundaries(aC2d1, aC2d2, aBox1, aBox2, anArrayOfParameters); + + const Standard_Integer aNbIntersSolutionsm1 = anArrayOfParameters.Length() - 1; + + //Trim RLine found. + for(Standard_Integer anInd = 0; anInd < aNbIntersSolutionsm1; anInd++) { - Handle(IntPatch_RLine) RL = - Handle(IntPatch_RLine)::DownCast(L); - Handle(Geom_Curve) aC3d; - Handle(Geom2d_Curve) aC2d1, aC2d2; - Standard_Real aTolReached; - TreatRLine(RL, myHS1, myHS2, myApprox1, myApprox2, aC3d, - aC2d1, aC2d2, aTolReached); - sline.Append(aC3d); - slineS1.Append(aC2d1); - slineS2.Append(aC2d2); + const Standard_Real aParF = anArrayOfParameters(anInd), + aParL = anArrayOfParameters(anInd+1); + + if((aParL - aParF) <= Precision::PConfusion()) + continue; + + const Standard_Real aPar = 0.5*(aParF + aParL); + gp_Pnt2d aPt; + + Handle(Geom2d_Curve) aCurv2d1, aCurv2d2; + if(!aC2d1.IsNull()) + { + aC2d1->D0(aPar, aPt); + + if(aBox1.IsOut(aPt)) + continue; + + if(myApprox1) + aCurv2d1 = new Geom2d_TrimmedCurve(aC2d1, aParF, aParL); + } + + if(!aC2d2.IsNull()) + { + aC2d2->D0(aPar, aPt); + + if(aBox2.IsOut(aPt)) + continue; + + if(myApprox2) + aCurv2d2 = new Geom2d_TrimmedCurve(aC2d2, aParF, aParL); + } + + Handle(Geom_Curve) aCurv3d = new Geom_TrimmedCurve(aC3d, aParF, aParL); + + sline.Append(aCurv3d); + slineS1.Append(aCurv2d1); + slineS2.Append(aCurv2d2); } } break; - } } // //======================================================================= //function : AdjustUPeriodic //purpose : -//======================================================================= -void TreatRLine(const Handle(IntPatch_RLine)& theRL, - const Handle(GeomAdaptor_HSurface)& theHS1, - const Handle(GeomAdaptor_HSurface)& theHS2, - const Standard_Boolean theApprox1, - const Standard_Boolean theApprox2, - Handle(Geom_Curve)& theC3d, - Handle(Geom2d_Curve)& theC2d1, - Handle(Geom2d_Curve)& theC2d2, - Standard_Real& theTolReached) -{ - Handle(GeomAdaptor_HSurface) aGAHS; - Handle(Adaptor2d_HCurve2d) anAHC2d; - Standard_Real tf, tl; - gp_Lin2d aL; - // It is assumed that 2d curve is 2d line (rectangular surface domain) - if(theRL->IsArcOnS1()) - { - aGAHS = theHS1; - anAHC2d = theRL->ArcOnS1(); - theRL->ParamOnS1(tf, tl); - theC2d1 = Geom2dAdaptor::MakeCurve(theRL->ArcOnS1()->Curve2d()); - } - else if (theRL->IsArcOnS2()) - { - aGAHS = theHS2; - anAHC2d = theRL->ArcOnS2(); - theRL->ParamOnS2(tf, tl); - theC2d2 = Geom2dAdaptor::MakeCurve(theRL->ArcOnS2()->Curve2d()); - } - else - { - return; - } - // - //To provide sameparameter it is necessary to get 3d curve as - //approximation of curve on surface. - Standard_Integer aMaxDeg = 8; - Standard_Integer aMaxSeg = 1000; - Approx_CurveOnSurface anApp(anAHC2d, aGAHS, tf, tl, Precision::Confusion(), - GeomAbs_C1, aMaxDeg, aMaxSeg, - Standard_True, Standard_False); - if(anApp.HasResult()) - { - theC3d = anApp.Curve3d(); - theTolReached = anApp.MaxError3d(); - Standard_Real aTol = Precision::Confusion(); - if(theRL->IsArcOnS1() && theApprox2) - { - Handle(Geom_Surface) aS = GeomAdaptor::MakeSurface(theHS1->Surface()); - BuildPCurves (tf, tl, aTol, - aS, theC3d, theC2d2); - } - if(theRL->IsArcOnS2() && theApprox1) - { - Handle(Geom_Surface) aS = GeomAdaptor::MakeSurface(theHS2->Surface()); - BuildPCurves (tf, tl, aTol, - aS, theC3d, theC2d1); - } - theTolReached = Max(theTolReached, aTol); - } - // - -} -// -//======================================================================= -//function : AdjustUPeriodic -//purpose : //======================================================================= void AdjustUPeriodic (const Handle(Geom_Surface)& aS, Handle(Geom2d_Curve)& aC2D) { @@ -1168,53 +1163,6 @@ void TreatRLine(const Handle(IntPatch_RLine)& theRL, // // //======================================================================= -//function : BuildPCurves -//purpose : -//======================================================================= - void BuildPCurves (Standard_Real f, Standard_Real l, - Standard_Real& Tol, - const Handle(Geom_Surface)& S, - const Handle(Geom_Curve)& C, - Handle(Geom2d_Curve)& C2d) -{ - if (C2d.IsNull()) - { - C2d = GeomProjLib::Curve2d(C,f,l,S,Tol); - if (S->IsUPeriodic()) - { - Standard_Real umin,umax,vmin,vmax; - S->Bounds(umin,umax,vmin,vmax); - // Recadre dans le domaine UV de la face - const Standard_Real period = S->UPeriod(); - gp_Pnt2d Pf=C2d->Value(f); - // - Standard_Real U0=Pf.X(); - // - const Standard_Real aEpsilon=Epsilon(10.);//1.77e-15 - if (fabs(U0)(umax+aEps)) { - U0-=period; - du-=period; - } - if (du!=0.) { - gp_Vec2d T1(du, 0.); - C2d->Translate(T1); - } - } - } -} -// -//======================================================================= //function : GetQuadric //purpose : //======================================================================= @@ -2106,26 +2054,312 @@ Standard_Boolean FindPoint(const gp_Pnt2d& theFirstPoint, return Standard_False; } -/* -static - void DumpWLine (const Handle(IntPatch_WLine)& theWLine); //======================================================================= -//function : DumpWLine +//function : TreatRLine +//purpose : Approx of Restriction line +//======================================================================= +void GeomInt_IntSS::TreatRLine(const Handle(IntPatch_RLine)& theRL, + const Handle(GeomAdaptor_HSurface)& theHS1, + const Handle(GeomAdaptor_HSurface)& theHS2, + Handle(Geom_Curve)& theC3d, + Handle(Geom2d_Curve)& theC2d1, + Handle(Geom2d_Curve)& theC2d2, + Standard_Real& theTolReached) +{ + Handle(GeomAdaptor_HSurface) aGAHS; + Handle(Adaptor2d_HCurve2d) anAHC2d; + Standard_Real tf, tl; + gp_Lin2d aL; + // It is assumed that 2d curve is 2d line (rectangular surface domain) + if(theRL->IsArcOnS1()) + { + aGAHS = theHS1; + anAHC2d = theRL->ArcOnS1(); + theRL->ParamOnS1(tf, tl); + theC2d1 = Geom2dAdaptor::MakeCurve(anAHC2d->Curve2d()); + } + else if (theRL->IsArcOnS2()) + { + aGAHS = theHS2; + anAHC2d = theRL->ArcOnS2(); + theRL->ParamOnS2(tf, tl); + theC2d2 = Geom2dAdaptor::MakeCurve(anAHC2d->Curve2d()); + } + else + { + return; + } + // + //To provide sameparameter it is necessary to get 3d curve as + //approximation of curve on surface. + Standard_Integer aMaxDeg = 8; + Standard_Integer aMaxSeg = 1000; + Approx_CurveOnSurface anApp(anAHC2d, aGAHS, tf, tl, Precision::Confusion(), + GeomAbs_C1, aMaxDeg, aMaxSeg, + Standard_True, Standard_False); + if(!anApp.HasResult()) + return; + + theC3d = anApp.Curve3d(); + theTolReached = anApp.MaxError3d(); + Standard_Real aTol = Precision::Confusion(); + if(theRL->IsArcOnS1()) + { + Handle(Geom_Surface) aS = GeomAdaptor::MakeSurface(theHS2->Surface()); + BuildPCurves (tf, tl, aTol, + aS, theC3d, theC2d2); + } + if(theRL->IsArcOnS2()) + { + Handle(Geom_Surface) aS = GeomAdaptor::MakeSurface(theHS1->Surface()); + BuildPCurves (tf, tl, aTol, + aS, theC3d, theC2d1); + } + theTolReached = Max(theTolReached, aTol); +} + +//======================================================================= +//function : BuildPCurves //purpose : //======================================================================= - void DumpWLine (const Handle(IntPatch_WLine)& theWLine) +void GeomInt_IntSS::BuildPCurves (Standard_Real f, + Standard_Real l, + Standard_Real& Tol, + const Handle (Geom_Surface)& S, + const Handle (Geom_Curve)& C, + Handle (Geom2d_Curve)& C2d) { - Standard_Integer i, nbp; - Standard_Real u1,v1,u2,v2; + if (!C2d.IsNull()) { + return; + } // - nbp=theWLine->NbPnts(); - printf(" nbp=%d\n", nbp); - for(i=1;i<=nbp;i++) { - const IntSurf_PntOn2S& aPoint = theWLine->Point(i); - const gp_Pnt& aP=aPoint.Value(); - aPoint.Parameters(u1,v1,u2,v2); - printf("point i%d %lf %lf %lf [ %lf %lf ] [ %lf %lf ]\n", - i, aP.X(), aP.Y(), aP.Z(), u1, v1, u2, v2); + Standard_Real umin,umax,vmin,vmax; + // + S->Bounds(umin, umax, vmin, vmax); + // in class ProjLib_Function the range of parameters is shrank by 1.e-09 + if((l - f) > 2.e-09) { + C2d = GeomProjLib::Curve2d(C,f,l,S,umin,umax,vmin,vmax,Tol); + // + if (C2d.IsNull()) { + // proj. a circle that goes through the pole on a sphere to the sphere + Tol += Precision::Confusion(); + C2d = GeomProjLib::Curve2d(C,f,l,S,Tol); + } + } + else { + if((l - f) > Epsilon(Abs(f))) { + GeomAPI_ProjectPointOnSurf aProjector1, aProjector2; + gp_Pnt P1 = C->Value(f); + gp_Pnt P2 = C->Value(l); + aProjector1.Init(P1, S); + aProjector2.Init(P2, S); + + if(aProjector1.IsDone() && aProjector2.IsDone()) { + Standard_Real U=0., V=0.; + aProjector1.LowerDistanceParameters(U, V); + gp_Pnt2d p1(U, V); + + aProjector2.LowerDistanceParameters(U, V); + gp_Pnt2d p2(U, V); + + if(p1.Distance(p2) > gp::Resolution()) { + TColgp_Array1OfPnt2d poles(1,2); + TColStd_Array1OfReal knots(1,2); + TColStd_Array1OfInteger mults(1,2); + poles(1) = p1; + poles(2) = p2; + knots(1) = f; + knots(2) = l; + mults(1) = mults(2) = 2; + + C2d = new Geom2d_BSplineCurve(poles,knots,mults,1); + + // compute reached tolerance.begin + gp_Pnt PMid = C->Value((f + l) * 0.5); + aProjector1.Perform(PMid); + + if(aProjector1.IsDone()) { + aProjector1.LowerDistanceParameters(U, V); + gp_Pnt2d pmidproj(U, V); + gp_Pnt2d pmidcurve2d = C2d->Value((f + l) * 0.5); + Standard_Real adist = pmidcurve2d.Distance(pmidproj); + Tol = (adist > Tol) ? adist : Tol; + } + // compute reached tolerance.end + } + } + } + } + // + if (S->IsUPeriodic() && !C2d.IsNull()) { + // Recadre dans le domaine UV de la face + Standard_Real aTm, U0, aEps, period, du, U0x; + Standard_Boolean bAdjust; + // + aEps = Precision::PConfusion(); + period = S->UPeriod(); + // + aTm = .5*(f + l); + gp_Pnt2d pm = C2d->Value(aTm); + U0 = pm.X(); + // + bAdjust = + GeomInt::AdjustPeriodic(U0, umin, umax, period, U0x, du, aEps); + if (bAdjust) { + gp_Vec2d T1(du, 0.); + C2d->Translate(T1); + } } } -*/ + +//======================================================================= +//function : TrimILineOnSurfBoundaries +//purpose : This function finds intersection points of given curves with +// surface boundaries and fills theArrayOfParameters by parameters +// along the given curves corresponding of these points. +//======================================================================= +void GeomInt_IntSS::TrimILineOnSurfBoundaries(const Handle(Geom2d_Curve)& theC2d1, + const Handle(Geom2d_Curve)& theC2d2, + const Bnd_Box2d& theBound1, + const Bnd_Box2d& theBound2, + GeomInt_VectorOfReal& theArrayOfParameters) +{ + //Rectangular boundaries of two surfaces: [0]:U=Ufirst, [1]:U=Ulast, + // [2]:V=Vfirst, [3]:V=Vlast + const Standard_Integer aNumberOfCurves = 4; + Handle(Geom2d_Curve) aCurS1Bounds[aNumberOfCurves]; + Handle(Geom2d_Curve) aCurS2Bounds[aNumberOfCurves]; + + Standard_Real aU1f=0.0, aV1f=0.0, aU1l=0.0, aV1l=0.0; + Standard_Real aU2f=0.0, aV2f=0.0, aU2l=0.0, aV2l=0.0; + + theBound1.Get(aU1f, aV1f, aU1l, aV1l); + theBound2.Get(aU2f, aV2f, aU2l, aV2l); + + Standard_Real aDelta = aV1l-aV1f; + if(Abs(aDelta) > RealSmall()) + { + if(!Precision::IsInfinite(aU1f)) + { + aCurS1Bounds[0] = new Geom2d_Line(gp_Pnt2d(aU1f, aV1f), gp_Dir2d(0.0, 1.0)); + + if(!Precision::IsInfinite(aDelta)) + aCurS1Bounds[0] = new Geom2d_TrimmedCurve(aCurS1Bounds[0], 0, aDelta); + } + + if(!Precision::IsInfinite(aU1l)) + { + aCurS1Bounds[1] = new Geom2d_Line(gp_Pnt2d(aU1l, aV1f), gp_Dir2d(0.0, 1.0)); + if(!Precision::IsInfinite(aDelta)) + aCurS1Bounds[1] = new Geom2d_TrimmedCurve(aCurS1Bounds[1], 0, aDelta); + } + } + + aDelta = aU1l-aU1f; + if(Abs(aDelta) > RealSmall()) + { + if(!Precision::IsInfinite(aV1f)) + { + aCurS1Bounds[2] = new Geom2d_Line(gp_Pnt2d(aU1f, aV1f), gp_Dir2d(1.0, 0.0)); + if(!Precision::IsInfinite(aDelta)) + aCurS1Bounds[2] = new Geom2d_TrimmedCurve(aCurS1Bounds[2], 0, aDelta); + } + + if(!Precision::IsInfinite(aV1l)) + { + aCurS1Bounds[3] = new Geom2d_Line(gp_Pnt2d(aU1l, aV1l), gp_Dir2d(1.0, 0.0)); + if(!Precision::IsInfinite(aDelta)) + aCurS1Bounds[3] = new Geom2d_TrimmedCurve(aCurS1Bounds[3], 0, aDelta); + } + } + + aDelta = aV2l-aV2f; + if(Abs(aDelta) > RealSmall()) + { + if(!Precision::IsInfinite(aU2f)) + { + aCurS2Bounds[0] = new Geom2d_Line(gp_Pnt2d(aU2f, aV2f), gp_Dir2d(0.0, 1.0)); + if(!Precision::IsInfinite(aDelta)) + aCurS2Bounds[0] = new Geom2d_TrimmedCurve(aCurS2Bounds[0], 0, aDelta); + } + + if(!Precision::IsInfinite(aU2l)) + { + aCurS2Bounds[1] = new Geom2d_Line(gp_Pnt2d(aU2l, aV2f), gp_Dir2d(0.0, 1.0)); + if(!Precision::IsInfinite(aDelta)) + aCurS2Bounds[1] = new Geom2d_TrimmedCurve(aCurS2Bounds[1], 0, aDelta); + } + } + + aDelta = aU2l-aU2f; + if(Abs(aDelta) > RealSmall()) + { + if(!Precision::IsInfinite(aV2f)) + { + aCurS2Bounds[2] = new Geom2d_Line(gp_Pnt2d(aU2f, aV2f), gp_Dir2d(1.0, 0.0)); + if(!Precision::IsInfinite(aDelta)) + aCurS2Bounds[2] = new Geom2d_TrimmedCurve(aCurS2Bounds[2], 0, aDelta); + } + + if(!Precision::IsInfinite(aV2l)) + { + aCurS2Bounds[3] = new Geom2d_Line(gp_Pnt2d(aU2l, aV2l), gp_Dir2d(1.0, 0.0)); + if(!Precision::IsInfinite(aDelta)) + aCurS2Bounds[3] = new Geom2d_TrimmedCurve(aCurS2Bounds[3], 0, aDelta); + } + } + + Geom2dAPI_InterCurveCurve anIntCC2d; + + if(!theC2d1.IsNull()) + { + for(Standard_Integer aCurID = 0; aCurID < aNumberOfCurves; aCurID++) + { + if(aCurS1Bounds[aCurID].IsNull()) + continue; + + anIntCC2d.Init(theC2d1, aCurS1Bounds[aCurID]); + + for (Standard_Integer aPntID = 1; aPntID <= anIntCC2d.NbPoints(); aPntID++) + { + const Standard_Real aParam = anIntCC2d.Intersector().Point(aPntID).ParamOnFirst(); + theArrayOfParameters.Append(aParam); + } + + for (Standard_Integer aSegmID = 1; aSegmID <= anIntCC2d.NbSegments(); aSegmID++) + { + Handle(Geom2d_Curve) aCS, aCSTemp; + anIntCC2d.Segment(aSegmID, aCS, aCSTemp); + theArrayOfParameters.Append(aCS->FirstParameter()); + theArrayOfParameters.Append(aCS->LastParameter()); + } + } + } + + if(!theC2d2.IsNull()) + { + for(Standard_Integer aCurID = 0; aCurID < aNumberOfCurves; aCurID++) + { + if(aCurS2Bounds[aCurID].IsNull()) + continue; + + anIntCC2d.Init(theC2d2, aCurS2Bounds[aCurID]); + + for (Standard_Integer aPntID = 1; aPntID <= anIntCC2d.NbPoints(); aPntID++) + { + const Standard_Real aParam = anIntCC2d.Intersector().Point(aPntID).ParamOnFirst(); + theArrayOfParameters.Append(aParam); + } + + for (Standard_Integer aSegmID = 1; aSegmID <= anIntCC2d.NbSegments(); aSegmID++) + { + Handle(Geom2d_Curve) aCS, aCSTemp; + anIntCC2d.Segment(aSegmID, aCS, aCSTemp); + theArrayOfParameters.Append(aCS->FirstParameter()); + theArrayOfParameters.Append(aCS->LastParameter()); + } + } + } + + std::sort(theArrayOfParameters.begin(), theArrayOfParameters.end()); +} diff --git a/src/GeomInt/GeomInt_VectorOfReal.hxx b/src/GeomInt/GeomInt_VectorOfReal.hxx new file mode 100644 index 0000000000..53d54c6013 --- /dev/null +++ b/src/GeomInt/GeomInt_VectorOfReal.hxx @@ -0,0 +1,23 @@ +// Created on: 2015-02-18 +// Created by: Nikolai BUKHALOV +// Copyright (c) 2003-2015 OPEN CASCADE SAS +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef GeomInt_VectorOfReal_HeaderFile +#define GeomInt_VectorOfReal_HeaderFile + +#include + +typedef NCollection_Vector GeomInt_VectorOfReal; + +#endif \ No newline at end of file diff --git a/src/IntPatch/IntPatch.cdl b/src/IntPatch/IntPatch.cdl index 3400f34ecb..f4a06df072 100644 --- a/src/IntPatch/IntPatch.cdl +++ b/src/IntPatch/IntPatch.cdl @@ -38,14 +38,11 @@ is class Point; deferred class Line; - - class GLine; -- inherits Line from IntPatch - - class ALine; -- inherits Line from IntPatch - - class WLine; -- inherits Line from IntPatch - - class RLine; -- inherits Line from IntPatch + class ALine; -- inherits Line from IntPatch + class GLine; -- inherits Line from IntPatch + deferred class PointLine; -- inherits Line from IntPatch + class RLine; -- inherits PointLine from IntPatch + class WLine; -- inherits PointLine from IntPatch class ArcFunction; diff --git a/src/IntPatch/IntPatch_ImpImpIntersection.cdl b/src/IntPatch/IntPatch_ImpImpIntersection.cdl index ce5670a87e..15421c8e86 100644 --- a/src/IntPatch/IntPatch_ImpImpIntersection.cdl +++ b/src/IntPatch/IntPatch_ImpImpIntersection.cdl @@ -44,7 +44,15 @@ is Create (S1: HSurface from Adaptor3d; D1: TopolTool from Adaptor3d; S2: HSurface from Adaptor3d; D2: TopolTool from Adaptor3d; - TolArc,TolTang: Real from Standard) + TolArc,TolTang: Real from Standard; + theIsReqToKeepRLine: Boolean from Standard = Standard_False) + + ---Purpose: Flag theIsReqToKeepRLine has been enterred only for + -- compatibility with TopOpeBRep package. It shall be deleted + -- after deleting TopOpeBRep. + -- When intersection result returns IntPatch_RLine and another + -- IntPatch_Line (not restriction) we (in case of theIsReqToKeepRLine==TRUE) + -- will always keep both lines even if they are coincided. returns ImpImpIntersection from IntPatch @@ -55,9 +63,17 @@ is S1: HSurface from Adaptor3d; D1: TopolTool from Adaptor3d; S2: HSurface from Adaptor3d; D2: TopolTool from Adaptor3d; TolArc,TolTang: Real from Standard; - isTheTrimmed: Boolean from Standard = Standard_False) + isTheTrimmed: Boolean from Standard = Standard_False; + theIsReqToKeepRLine: Boolean from Standard = Standard_False) raises ConstructionError from Standard + + ---Purpose: Flag theIsReqToKeepRLine has been enterred only for + -- compatibility with TopOpeBRep package. It shall be deleted + -- after deleting TopOpeBRep. + -- When intersection result returns IntPatch_RLine and another + -- IntPatch_Line (not restriction) we (in case of theIsReqToKeepRLine==TRUE) + -- will always keep both lines even if they are coincided. is static; diff --git a/src/IntPatch/IntPatch_ImpImpIntersection_0.gxx b/src/IntPatch/IntPatch_ImpImpIntersection_0.gxx index 6e296d82af..dab4f3c3fb 100644 --- a/src/IntPatch/IntPatch_ImpImpIntersection_0.gxx +++ b/src/IntPatch/IntPatch_ImpImpIntersection_0.gxx @@ -22,6 +22,12 @@ #include #include #include +#include +#include +#include +#include +#include + static void PutPointsOnLine(const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_HSurface)& S2, @@ -82,7 +88,8 @@ static void ProcessSegments (const IntPatch_SequenceOfSegmentOfTheSOnBounds&, static void ProcessRLine (IntPatch_SequenceOfLine&, const IntSurf_Quadric&, const IntSurf_Quadric&, - const Standard_Real); + const Standard_Real, + const Standard_Boolean theIsReqToKeepRLine); //-- le calcul de dist est completement faux ds la routine ci dessous a revoir (lbr le 18 nov 97) Standard_Boolean IntersectionWithAnArc(gp_Pnt& PSurf, @@ -1654,13 +1661,136 @@ void ProcessSegments (const IntPatch_SequenceOfSegmentOfTheSOnBounds& listedg, } } +inline const gp_Pnt& PointValue(const Handle(IntPatch_RLine) theRLine, + const Standard_Integer theIndex) +{ + return theRLine->Point(theIndex).Value(); +} + +inline const gp_Pnt& VertexValue( const Handle(IntPatch_RLine) theRLine, + const Standard_Integer theIndex) +{ + return theRLine->Vertex(theIndex).Value(); +} + +static Standard_Real SquareDistance(const Handle(IntPatch_GLine) theGLine, + const gp_Pnt& theP, + GeomAPI_ProjectPointOnCurve& thePrj) +{ + Standard_Real aSQDist = RealLast(); + switch(theGLine->ArcType()) + { + case IntPatch_Lin: + aSQDist = theGLine->Line().SquareDistance(theP); + break; + case IntPatch_Circle: + aSQDist = theGLine->Circle().SquareDistance(theP); + break; + default: + thePrj.Perform(theP); + if(thePrj.NbPoints() == 0) + { + //Lines are not overlapped + return aSQDist; + } + + aSQDist = theP.SquareDistance(thePrj.NearestPoint()); + } + + return aSQDist; +} + +static Standard_Boolean IsRLineGood(const IntSurf_Quadric& Quad1, + const IntSurf_Quadric& Quad2, + const Handle(IntPatch_GLine) theGLine, + const Handle(IntPatch_RLine) theRLine, + const Standard_Real theTol) +{ + const Standard_Real aSQTol = theTol*theTol; + const IntPatch_IType aGType = theGLine->ArcType(); + Standard_Integer aNbPntsM1 = 0; + + const gp_Pnt& (*Value) (const Handle(IntPatch_RLine), const Standard_Integer); + + if(theRLine->HasPolygon()) + { + aNbPntsM1 = theRLine->NbPnts()-1; + Value = PointValue; + } + else + { + aNbPntsM1 = theRLine->NbVertex()-1; + Value = VertexValue; + } + + if(aNbPntsM1 < 1) + return Standard_False; + + GeomAPI_ProjectPointOnCurve aPrj; + + Handle(Geom_Curve) aCurv; + if(aGType == IntPatch_Ellipse) + aCurv = new Geom_Ellipse(theGLine->Ellipse()); + else if(aGType == IntPatch_Parabola) + aCurv = new Geom_Parabola(theGLine->Parabola()); + else if(aGType == IntPatch_Hyperbola) + aCurv = new Geom_Hyperbola(theGLine->Hyperbola()); + + if(!aCurv.IsNull()) + aPrj.Init(aCurv, aCurv->FirstParameter(), aCurv->LastParameter()); + + if(aNbPntsM1 == 1) + { + gp_Pnt aP1(Value(theRLine, 1)), aP2(Value(theRLine, 2)); + + if(aP1.SquareDistance(aP2) < aSQTol) + { + //RLine is degenerated + return Standard_False; + } + + gp_Pnt aPMid; + if(theRLine->IsArcOnS1()) + { + const Handle(Adaptor2d_HCurve2d)& anAC2d = theRLine->ArcOnS1(); + const Standard_Real aParF = anAC2d->FirstParameter(), + aParL = anAC2d->LastParameter(); + gp_Pnt2d aP2d(anAC2d->Value(0.5*(aParF+aParL))); + aPMid = Quad1.Value(aP2d.X(), aP2d.Y()); + } + else + { + const Handle(Adaptor2d_HCurve2d)& anAC2d = theRLine->ArcOnS2(); + const Standard_Real aParF = anAC2d->FirstParameter(), + aParL = anAC2d->LastParameter(); + gp_Pnt2d aP2d(anAC2d->Value(0.5*(aParF+aParL))); + aPMid = Quad2.Value(aP2d.X(), aP2d.Y()); + } + + const Standard_Real aSQDist = SquareDistance(theGLine, aPMid, aPrj); + return (aSQDist > aSQTol); + } + + for(Standard_Integer i = 2; i <= aNbPntsM1; i++) + { + const gp_Pnt aP(Value(theRLine, i)); + const Standard_Real aSQDist = SquareDistance(theGLine, aP, aPrj); + + if(aSQDist > aSQTol) + return Standard_True; + } + + return Standard_False; +} + void ProcessRLine (IntPatch_SequenceOfLine& slin, // const Handle(Adaptor3d_HSurface)& Surf1, // const Handle(Adaptor3d_HSurface)& Surf2, const IntSurf_Quadric& Quad1, const IntSurf_Quadric& Quad2, - const Standard_Real _TolArc) { + const Standard_Real _TolArc, + const Standard_Boolean theIsReqToKeepRLine) { // On cherche a placer sur les restrictions solutions les points "multiples" // des autres lignes d intersection @@ -1701,15 +1831,17 @@ void ProcessRLine (IntPatch_SequenceOfLine& slin, for (i=1; i<=Nblin; i++) { const Handle(IntPatch_Line)& slini = slin(i); typ1 = slini->ArcType(); + + Standard_Boolean HasToDeleteRLine = Standard_False; if (typ1 == IntPatch_Restriction) { seq_Pnt3d.Clear(); seq_Real.Clear(); + for (j=1; j<=Nblin; j++) { const Handle(IntPatch_Line)& slinj = slin(j); Nbpt = seq_Pnt3d.Length(); // important que ce soit ici typ2 = slinj->ArcType(); if (typ2 != IntPatch_Restriction) { - //-- arcref = (*((Handle(IntPatch_RLine)*)&slini))->Arc(); //-- OnFirst = (*((Handle(IntPatch_RLine)*)&slini))->IsOnFirstSurface(); @@ -1896,8 +2028,32 @@ void ProcessRLine (IntPatch_SequenceOfLine& slin, } //-- if (keeppoint) } //-- if ((OnFirst && !Ptvtx.IsOnDomS1())||(!OnFirst && !Ptvtx.IsOnDomS2())) } //-- boucle sur les vertex + + if(!theIsReqToKeepRLine) + { + Handle(IntPatch_GLine) aGL = Handle(IntPatch_GLine)::DownCast(slinj); + + if(!aGL.IsNull()) + { + HasToDeleteRLine = !IsRLineGood(Quad1, Quad2, aGL, + Handle(IntPatch_RLine)::DownCast(slini), TolArc); + } + + if(HasToDeleteRLine) + { + break; + } + } } //-- if (typ2 != IntPatch_Restriction) } //-- for (j=1; j<=Nblin; j++) } //-- if (typ1 == IntPatch_Restriction) + + if(HasToDeleteRLine) + { + slin.Remove(i); + i--; + Nblin = slin.Length(); + continue; + } } //-- for (i=1; i<=Nblin; i++) } diff --git a/src/IntPatch/IntPatch_ImpImpIntersection_2.gxx b/src/IntPatch/IntPatch_ImpImpIntersection_2.gxx index f2f3814224..f94f8096d2 100644 --- a/src/IntPatch/IntPatch_ImpImpIntersection_2.gxx +++ b/src/IntPatch/IntPatch_ImpImpIntersection_2.gxx @@ -24,7 +24,7 @@ static //purpose : //======================================================================= IntPatch_ImpImpIntersection::IntPatch_ImpImpIntersection (): - done(Standard_False) + done(Standard_False) { } //======================================================================= @@ -37,9 +37,10 @@ IntPatch_ImpImpIntersection::IntPatch_ImpImpIntersection const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real TolArc, - const Standard_Real TolTang) + const Standard_Real TolTang, + const Standard_Boolean theIsReqToKeepRLine) { - Perform(S1,D1,S2,D2,TolArc,TolTang); + Perform(S1,D1,S2,D2,TolArc,TolTang, Standard_False, theIsReqToKeepRLine); } //======================================================================= //function : Perform @@ -51,7 +52,8 @@ void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real TolArc, const Standard_Real TolTang, - const Standard_Boolean isTheTrimmed) { + const Standard_Boolean isTheTrimmed, + const Standard_Boolean theIsReqToKeepRLine) { done = Standard_False; Standard_Boolean isTrimmed = isTheTrimmed; spnt.Clear(); @@ -418,7 +420,7 @@ void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)& S1, if (edg1.Length() !=0 || edg2.Length() !=0) { // ProcessRLine(slin,S1,S2,TolArc); - ProcessRLine(slin,quad1,quad2,TolArc); + ProcessRLine(slin,quad1,quad2,TolArc, theIsReqToKeepRLine); } }//if (!nosolonS1 || !nosolonS2) { else { diff --git a/src/IntPatch/IntPatch_ImpPrmIntersection.cxx b/src/IntPatch/IntPatch_ImpPrmIntersection.cxx index 0dfaf716b2..032031fbea 100644 --- a/src/IntPatch/IntPatch_ImpPrmIntersection.cxx +++ b/src/IntPatch/IntPatch_ImpPrmIntersection.cxx @@ -41,7 +41,6 @@ #define No_Standard_OutOfRange #endif - #include #include #include @@ -53,6 +52,11 @@ #include #include #include +#include +#include +#include + +#include static Standard_Boolean DecomposeResult(const Handle(IntPatch_Line)& Line, const Standard_Boolean IsReversed, @@ -80,6 +84,12 @@ static Standard_Real U2, Standard_Real V2); +static Standard_Boolean IsIn2DBox(const Bnd_Box2d& theBox, + const Handle(IntPatch_PointLine)& theLine, + const Standard_Real theUPeriod, + const Standard_Real theVPeriod, + const Standard_Boolean isTheSurface1Using); + //======================================================================= //function : IntPatch_ImpPrmIntersection //purpose : @@ -402,7 +412,7 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur const Standard_Real Pas) { Standard_Boolean reversed, procf, procl, dofirst, dolast; - Standard_Integer indfirst = 0, indlast = 0, ind2, i,j,k, NbSegm; + Standard_Integer indfirst = 0, indlast = 0, ind2, NbSegm; Standard_Integer NbPointIns, NbPointRst, Nblines, Nbpts, NbPointDep; Standard_Real U1,V1,U2,V2,paramf,paraml,currentparam; @@ -557,7 +567,7 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur UVap(2)=s2d.Y(); Func.Value(UVap,Valf); Standard_Real rvalf = Sign(1.,Valf(1)); - for(i = 2; i <= aNbSamples; ++i) + for(Standard_Integer i = 2; i <= aNbSamples; ++i) { D1->SamplePoint(i,s2d, s3d); UVap(1)=s2d.X(); @@ -586,7 +596,7 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur solins.Perform(Func,Surf1,D1,TolTang); } NbPointIns = solins.NbPoints(); - for (i=1; i <= NbPointIns; i++) { + for (Standard_Integer i=1; i <= NbPointIns; i++) { seqpins.Append(solins.Value(i)); } } @@ -616,13 +626,13 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur } // Nblines = iwalk.NbLines(); - for (j=1; j<=Nblines; j++) { + for (Standard_Integer j=1; j<=Nblines; j++) { const Handle(IntPatch_TheIWLineOfTheIWalking)& iwline = iwalk.Value(j); const Handle(IntSurf_LineOn2S)& thelin = iwline->Line(); Nbpts = thelin->NbPoints(); if(Nbpts>=2) { - + Standard_Integer k = 0; tgline = iwline->TangentVector(k); if(k>=1 && k<=Nbpts) { } else { k=Nbpts>>1; } valpt = thelin->Value(k).Value(); @@ -772,7 +782,7 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur PPoint = seqpdep(indfirst); tgline = PPoint.Direction3d(); Standard_Integer themult = PPoint.Multiplicity(); - for (i=NbPointRst; i>=1; i--) { + for (Standard_Integer i=NbPointRst; i>=1; i--) { if (Destination(i) == indfirst) { if (!reversed) { //-- typeS1 = Pln || Cyl || Sph || Cone Quad.Parameters(PPoint.Value(),U1,V1); @@ -860,7 +870,7 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur PPoint = seqpdep(indlast); tgline = PPoint.Direction3d().Reversed(); Standard_Integer themult = PPoint.Multiplicity(); - for (i=NbPointRst; i >=1; i--) { + for (Standard_Integer i=NbPointRst; i >=1; i--) { if (Destination(i) == indlast) { if (!reversed) { Quad.Parameters(PPoint.Value(),U1,V1); @@ -952,7 +962,7 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur Nblines = slin.Length(); - for (j=1; j<=Nblines-1; j++) { + for (Standard_Integer j=1; j<=Nblines-1; j++) { dofirst = dolast = Standard_False; const Handle(IntPatch_Line)& slinj = slin(j); const Handle(IntPatch_WLine)& wlin1 = *((Handle(IntPatch_WLine)*)&slinj); @@ -970,7 +980,7 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur } if (dofirst || dolast) { - for (k=j+1; k<=Nblines;k++) { + for (Standard_Integer k=j+1; k<=Nblines;k++) { const Handle(IntPatch_Line)& slink = slin(k); const Handle(IntPatch_WLine)& wlin2 = *((Handle(IntPatch_WLine)*)&slink); if (wlin2->HasFirstPoint()) { @@ -1031,7 +1041,7 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur // Treatment the segments NbSegm = solrst.NbSegments(); if (NbSegm) { - for(i=1; i<=NbSegm; i++) { + for(Standard_Integer i=1; i<=NbSegm; i++) { thesegm = solrst.Segment(i); //Check if segment is degenerated if(thesegm.HasFirstPoint() && thesegm.HasLastPoint()) @@ -1240,7 +1250,7 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur Standard_Integer nbsample = 100; if (!reversed) { - for (j=1; j<=nbsample; j++) { + for (Standard_Integer j=1; j<=nbsample; j++) { prm = paramf + (j-1)*(paraml-paramf)/(nbsample-1); arcsegm->D0(prm,p2d); Surf2->D0(p2d.X(),p2d.Y(),ptpoly); @@ -1251,7 +1261,7 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur } } else { - for (j=1; j<=nbsample; j++) { + for (Standard_Integer j=1; j<=nbsample; j++) { prm = paramf + (j-1)*(paraml-paramf)/(nbsample-1); arcsegm->D0(prm,p2d); Surf1->D0(p2d.X(),p2d.Y(),ptpoly); @@ -1266,7 +1276,7 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur if (dofirst || dolast) { Nblines = slin.Length(); - for (j=1; j<=Nblines; j++) { + for (Standard_Integer j=1; j<=Nblines; j++) { const Handle(IntPatch_Line)& slinj = slin(j); typ = slinj->ArcType(); if (typ == IntPatch_Walking) { @@ -1275,7 +1285,7 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur else { Nbpts = (*((Handle(IntPatch_RLine)*)&slinj))->NbVertex(); } - for (k=1; k<=Nbpts;k++) { + for (Standard_Integer k=1; k<=Nbpts;k++) { if (typ == IntPatch_Walking) { ptdeb = (*((Handle(IntPatch_WLine)*)&slinj))->Vertex(k); } @@ -1333,18 +1343,100 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur }// if (NbSegm) // // on traite les restrictions de la surface implicite - for (i=1; i<=slin.Length(); i++) + for (Standard_Integer i=1; i<=slin.Length(); i++) { + Handle(IntPatch_Line)& aL = slin(i); + if (!reversed) - IntPatch_RstInt::PutVertexOnLine(slin(i),Surf1,D1,Surf2,Standard_True,TolTang); + IntPatch_RstInt::PutVertexOnLine(aL,Surf1,D1,Surf2,Standard_True,TolTang); else - IntPatch_RstInt::PutVertexOnLine(slin(i),Surf2,D2,Surf1,Standard_False,TolTang); + IntPatch_RstInt::PutVertexOnLine(aL,Surf2,D2,Surf1,Standard_False,TolTang); } + + const Standard_Real aUPeriodOfSurf1 = Surf1->IsUPeriodic() ? Surf1->UPeriod() : 0.0, + aUPeriodOfSurf2 = Surf2->IsUPeriodic() ? Surf2->UPeriod() : 0.0, + aVPeriodOfSurf1 = Surf1->IsVPeriodic() ? Surf1->VPeriod() : 0.0, + aVPeriodOfSurf2 = Surf2->IsVPeriodic() ? Surf2->VPeriod() : 0.0; + + for (Standard_Integer i = 1; i <= slin.Length(); i++) + { + //BndBox of the points in Restriction line + Bnd_Box2d aBRL; + for(Standard_Integer j = i + 1; j <= slin.Length(); j++) + { + Handle(IntPatch_PointLine) aL1 = Handle(IntPatch_PointLine)::DownCast(slin(i)); + Handle(IntPatch_PointLine) aL2 = Handle(IntPatch_PointLine)::DownCast(slin(j)); + + Handle(IntPatch_RLine) aRL1 = Handle(IntPatch_RLine)::DownCast(aL1); + Handle(IntPatch_RLine) aRL2 = Handle(IntPatch_RLine)::DownCast(aL2); + + if(aRL1.IsNull() && aRL2.IsNull()) + {//If Walking-Walking + continue; + } + else if(aRL1.IsNull()) + {// i-th line is not restriction, + // but j-th is restriction + slin.Append(aL1); + slin.SetValue(i, aL2); + slin.Remove(j); + j--; + continue; + } + + //Here aL1 (i-th line) is Restriction-line and aL2 (j-th line) is not Restriction + + if(aBRL.IsVoid()) + {//Fill aBRL + for(Standard_Integer aPRID = 1; aPRID <= aRL1->NbPnts(); aPRID++) + { + Standard_Real u = 0.0, v = 0.0; + if(reversed) + aRL1->Point(aPRID).ParametersOnS1(u, v); + else + aRL1->Point(aPRID).ParametersOnS2(u, v); + + aBRL.Add(gp_Pnt2d(u, v)); + } + + Standard_Real aXmin = 0.0, aYmin = 0.0, aXMax = 0.0, aYMax = 0.0; + aBRL.Get(aXmin, aYmin, aXMax, aYMax); + const Standard_Real aDX = aXMax - aXmin, + aDY = aYMax - aYmin; + + const Standard_Real aTolU = reversed? Surf1->UResolution(TolArc) : Surf2->UResolution(TolArc); + const Standard_Real aTolV = reversed? Surf1->VResolution(TolArc) : Surf2->VResolution(TolArc); + + if((aDX > aTolU) && (aDY > aTolV)) + {//Delete restriction line because it is not isoline. + slin.Remove(i); + i--; + break; + } + + aXmin -= aTolU; + aXMax += aTolU; + aYmin -= aTolV; + aYMax += aTolV; + aBRL.SetVoid(); + aBRL.Update(aXmin, aYmin, aXMax, aYMax); + } + + const Standard_Boolean isCoincide = IsIn2DBox(aBRL, aL2, + (reversed? aUPeriodOfSurf1 : aUPeriodOfSurf2), + (reversed? aVPeriodOfSurf1 : aVPeriodOfSurf2), reversed); + + if(isCoincide) + {//Delete Walking-line + slin.Remove(j); + j--; + } + } + } + empt = (slin.Length() == 0 && spnt.Length() == 0); done = Standard_True; - - - // post processing for cones and spheres + if(slin.Length() == 0) return; @@ -1355,12 +1447,14 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur if(!isDecomposeRequired) return; + // post processing for cones and spheres + const Handle(Adaptor3d_TopolTool)& PDomain = (reversed) ? D1 : D2; const Handle(Adaptor3d_HSurface)& aQSurf = (reversed) ? Surf2 : Surf1; IntPatch_SequenceOfLine dslin; Standard_Boolean isDecompose = Standard_False; - for(i = 1; i <= slin.Length(); i++ ) + for(Standard_Integer i = 1; i <= slin.Length(); i++ ) { if(DecomposeResult(slin(i),reversed,Quad,PDomain,aQSurf,TolArc,dslin)) { @@ -1372,7 +1466,7 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur return; slin.Clear(); - for(i = 1; i <= dslin.Length(); i++ ) + for(Standard_Integer i = 1; i <= dslin.Length(); i++ ) slin.Append(dslin(i)); } @@ -1518,8 +1612,8 @@ static Standard_Boolean AreSamePoints(const IntSurf_PntOn2S& P1, } static void ForcedPurgePoints(const Handle(IntSurf_LineOn2S)& Result, - const Standard_Boolean IsReversed, - const IntSurf_Quadric& Quad) + const Standard_Boolean IsReversed, + const IntSurf_Quadric& Quad) { if(Result->NbPoints() <= 30) return; Standard_Integer Index = 0, IndexLimF = 8, IndexLimL = 8; @@ -1790,10 +1884,10 @@ static Standard_Boolean InsertSeamVertices(Handle(IntSurf_LineOn2S)& Line, } static void ToSmooth( const Handle(IntSurf_LineOn2S)& Line, - const Standard_Boolean IsReversed, - const IntSurf_Quadric& Quad, - const Standard_Boolean IsFirst, - Standard_Real& D3D) + const Standard_Boolean IsReversed, + const IntSurf_Quadric& Quad, + const Standard_Boolean IsFirst, + Standard_Real& D3D) { if(Line->NbPoints() <= 10) return; @@ -1886,10 +1980,10 @@ static void ToSmooth( const Handle(IntSurf_LineOn2S)& Line, } static Standard_Boolean TestMiddleOnPrm(const IntSurf_PntOn2S& aP, - const IntSurf_PntOn2S& aV, - const Standard_Boolean IsReversed, - const Standard_Real ArcTol, - const Handle(Adaptor3d_TopolTool)& PDomain) + const IntSurf_PntOn2S& aV, + const Standard_Boolean IsReversed, + const Standard_Real ArcTol, + const Handle(Adaptor3d_TopolTool)& PDomain) { Standard_Boolean result = Standard_False; @@ -1911,15 +2005,15 @@ static Standard_Boolean TestMiddleOnPrm(const IntSurf_PntOn2S& aP, } static void VerifyVertices( const Handle(IntSurf_LineOn2S)& Line, - const Standard_Boolean IsReversed, - const Handle(IntSurf_LineOn2S)& Vertices, - const Standard_Real TOL2D, - const Standard_Real ArcTol, - const Handle(Adaptor3d_TopolTool)& PDomain, - IntSurf_PntOn2S& VrtF, - Standard_Boolean& AddFirst, - IntSurf_PntOn2S& VrtL, - Standard_Boolean& AddLast) + const Standard_Boolean IsReversed, + const Handle(IntSurf_LineOn2S)& Vertices, + const Standard_Real TOL2D, + const Standard_Real ArcTol, + const Handle(Adaptor3d_TopolTool)& PDomain, + IntSurf_PntOn2S& VrtF, + Standard_Boolean& AddFirst, + IntSurf_PntOn2S& VrtL, + Standard_Boolean& AddLast) { Standard_Integer nbp = Line->NbPoints(), nbv = Vertices->NbPoints(); Standard_Integer FIndexSame = 0, FIndexNear = 0, LIndexSame = 0, LIndexNear = 0; @@ -2522,21 +2616,58 @@ static Standard_Boolean DecomposeResult(const Handle(IntPatch_Line)& theLine, return hasBeenDecomposed; } -/* -// <-A + +static Standard_Boolean IsIn2DBox(const Bnd_Box2d& theBox, + const Handle(IntPatch_PointLine)& theLine, + const Standard_Real theUPeriod, + const Standard_Real theVPeriod, + const Standard_Boolean isTheSurface1Using) { -Standard_Integer aNbPnts; -Standard_Real aU1,aV1,aU2,aV2; -gp_Pnt aPx; -// -aNbPnts=thelin->NbPoints(); -printf(" WLine: aNbPnts=%d\n", aNbPnts); -for(i=1; i <= aNbPnts; ++i) { -const IntSurf_PntOn2S& aPoint = thelin->Value(i); -aPx=aPoint.Value(); -aPoint.Parameters(aU1, aV1, aU2, aV2); -printf(" point %d %lf %lf %lf %lf %lf %lf %lf\n", -i, aPx.X(), aPx.Y(), aPx.Z(), aU1, aV1, aU2, aV2); + const Standard_Integer aNbPnts = theLine->NbPnts(); + + const Standard_Real aDeltaUPeriod[] = {0.0, -theUPeriod, 2.0*theUPeriod}; + const Standard_Real aDeltaVPeriod[] = {0.0, -theVPeriod, 2.0*theVPeriod}; + + const Standard_Integer aSzOfUPArr = sizeof(aDeltaUPeriod)/sizeof(aDeltaUPeriod[0]); + const Standard_Integer aSzOfVPArr = sizeof(aDeltaVPeriod)/sizeof(aDeltaVPeriod[0]); + + for(Standard_Integer aPtID = 1; aPtID <= aNbPnts; aPtID++) + { + Standard_Real aU = 0.0, aV = 0.0; + if(isTheSurface1Using) + theLine->Point(aPtID).ParametersOnS1(aU, aV); + else + theLine->Point(aPtID).ParametersOnS2(aU, aV); + + if(!theBox.IsOut(gp_Pnt2d(aU, aV))) + continue; + + Standard_Boolean isInscribe = Standard_False; + + for(Standard_Integer aUind = 0; !isInscribe && (aUind < aSzOfUPArr); aUind++) + { + if((aUind > 0) && (aDeltaUPeriod[aUind] == 0.0)) + { + break; + } + + aU += aDeltaUPeriod[aUind]; + + for(Standard_Integer aVind = 0; !isInscribe && (aVind < aSzOfVPArr); aVind++) + { + if((aVind > 0) && (aDeltaVPeriod[aVind] == 0.0)) + { + break; + } + + aV += aDeltaVPeriod[aVind]; + + isInscribe = !theBox.IsOut(gp_Pnt2d(aU, aV)); + } + } + + if(!isInscribe) + return Standard_False; + } + return Standard_True; } -} -*/ diff --git a/src/IntPatch/IntPatch_Intersection.cdl b/src/IntPatch/IntPatch_Intersection.cdl index e29a61c303..89dd5b5981 100644 --- a/src/IntPatch/IntPatch_Intersection.cdl +++ b/src/IntPatch/IntPatch_Intersection.cdl @@ -88,8 +88,16 @@ is S1: HSurface from Adaptor3d; D1: TopolTool from Adaptor3d; S2: HSurface from Adaptor3d; D2: TopolTool from Adaptor3d; TolArc,TolTang: Real from Standard; - isGeomInt : Boolean from Standard = Standard_True) + isGeomInt : Boolean from Standard = Standard_True; + theIsReqToKeepRLine: Boolean from Standard = Standard_False) + ---Purpose: Flag theIsReqToKeepRLine has been enterred only for + -- compatibility with TopOpeBRep package. It shall be deleted + -- after deleting TopOpeBRep. + -- When intersection result returns IntPatch_RLine and another + -- IntPatch_Line (not restriction) we (in case of theIsReqToKeepRLine==TRUE) + -- will always keep both lines even if they are coincided. + raises ConstructionError from Standard is static; @@ -140,7 +148,15 @@ is TolArc,TolTang: Real from Standard; LOfPnts: in out ListOfPntOn2S from IntSurf; RestrictLine: Boolean from Standard; - typs1, typs2: SurfaceType from GeomAbs) + typs1, typs2: SurfaceType from GeomAbs; + theIsReqToKeepRLine: Boolean from Standard = Standard_False) + + ---Purpose: Flag theIsReqToKeepRLine has been enterred only for + -- compatibility with TopOpeBRep package. It shall be deleted + -- after deleting TopOpeBRep. + -- When intersection result returns IntPatch_RLine and another + -- IntPatch_Line (not restriction) we (in case of theIsReqToKeepRLine==TRUE) + -- will always keep both lines even if they are coincided. is private; @@ -150,8 +166,16 @@ is TolArc,TolTang: Real from Standard; LOfPnts: in out ListOfPntOn2S from IntSurf; RestrictLine: Boolean from Standard; - typs1, typs2: SurfaceType from GeomAbs) - + typs1, typs2: SurfaceType from GeomAbs; + theIsReqToKeepRLine: Boolean from Standard = Standard_False) + + ---Purpose: Flag theIsReqToKeepRLine has been enterred only for + -- compatibility with TopOpeBRep package. It shall be deleted + -- after deleting TopOpeBRep. + -- When intersection result returns IntPatch_RLine and another + -- IntPatch_Line (not restriction) we (in case of theIsReqToKeepRLine==TRUE) + -- will always keep both lines even if they are coincided. + is private; GeomParamPerfom(me: in out; diff --git a/src/IntPatch/IntPatch_Intersection.cxx b/src/IntPatch/IntPatch_Intersection.cxx index dee76ad1fb..1ecb466ea9 100644 --- a/src/IntPatch/IntPatch_Intersection.cxx +++ b/src/IntPatch/IntPatch_Intersection.cxx @@ -925,7 +925,8 @@ void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& theS1, const Handle(Adaptor3d_TopolTool)& theD2, const Standard_Real TolArc, const Standard_Real TolTang, - const Standard_Boolean isGeomInt) + const Standard_Boolean isGeomInt, + const Standard_Boolean theIsReqToKeepRLine) { myTolArc = TolArc; myTolTang = TolTang; @@ -1124,13 +1125,15 @@ void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& theS1, { if(theD1->DomainIsInfinite() || theD2->DomainIsInfinite()) { - GeomGeomPerfom(theS1, theD1, theS2, theD2, TolArc, - TolTang, ListOfPnts, RestrictLine, typs1, typs2); + GeomGeomPerfom( theS1, theD1, theS2, theD2, TolArc, + TolTang, ListOfPnts, RestrictLine, + typs1, typs2, theIsReqToKeepRLine); } else { - GeomGeomPerfomTrimSurf(theS1, theD1, theS2, theD2, - TolArc, TolTang, ListOfPnts, RestrictLine, typs1, typs2); + GeomGeomPerfomTrimSurf( theS1, theD1, theS2, theD2, + TolArc, TolTang, ListOfPnts, RestrictLine, + typs1, typs2, theIsReqToKeepRLine); } } else @@ -1500,9 +1503,11 @@ void IntPatch_Intersection::GeomGeomPerfom(const Handle(Adaptor3d_HSurface)& the IntSurf_ListOfPntOn2S& ListOfPnts, const Standard_Boolean RestrictLine, const GeomAbs_SurfaceType typs1, - const GeomAbs_SurfaceType typs2) + const GeomAbs_SurfaceType typs2, + const Standard_Boolean theIsReqToKeepRLine) { - IntPatch_ImpImpIntersection interii(theS1,theD1,theS2,theD2,myTolArc,myTolTang); + IntPatch_ImpImpIntersection interii(theS1,theD1,theS2,theD2, + myTolArc,myTolTang, theIsReqToKeepRLine); const Standard_Boolean anIS = interii.IsDone(); if (anIS) { @@ -1693,14 +1698,16 @@ void IntPatch_Intersection:: IntSurf_ListOfPntOn2S& theListOfPnts, const Standard_Boolean RestrictLine, const GeomAbs_SurfaceType theTyps1, - const GeomAbs_SurfaceType theTyps2) + const GeomAbs_SurfaceType theTyps2, + const Standard_Boolean theIsReqToKeepRLine) { IntSurf_Quadric Quad1,Quad2; if((theTyps1 == GeomAbs_Cylinder) && (theTyps2 == GeomAbs_Cylinder)) { IntPatch_ImpImpIntersection anInt; - anInt.Perform(theS1, theD1, theS2, theD2, myTolArc, myTolTang, Standard_True); + anInt.Perform(theS1, theD1, theS2, theD2, myTolArc, + myTolTang, Standard_True, theIsReqToKeepRLine); done = anInt.IsDone(); @@ -1743,7 +1750,8 @@ void IntPatch_Intersection:: else { GeomGeomPerfom(theS1, theD1, theS2, theD2, - theTolArc, theTolTang, theListOfPnts, RestrictLine, theTyps1, theTyps2); + theTolArc, theTolTang, theListOfPnts, + RestrictLine, theTyps1, theTyps2, theIsReqToKeepRLine); } } diff --git a/src/IntPatch/IntPatch_Point.cdl b/src/IntPatch/IntPatch_Point.cdl index ce97e987c7..9a7de699f9 100644 --- a/src/IntPatch/IntPatch_Point.cdl +++ b/src/IntPatch/IntPatch_Point.cdl @@ -24,7 +24,6 @@ uses HVertex from Adaptor3d, HCurve2d from Adaptor2d, PntOn2S from IntSurf, - Line from IntPatch, Transition from IntSurf, Pnt from gp diff --git a/src/IntPatch/IntPatch_PointLine.cdl b/src/IntPatch/IntPatch_PointLine.cdl new file mode 100644 index 0000000000..02d293d746 --- /dev/null +++ b/src/IntPatch/IntPatch_PointLine.cdl @@ -0,0 +1,75 @@ +-- Created on: 2015-02-18 +-- Created by: Nikolai BUKHALOV +-- Copyright (c) 1992-1999 Matra Datavision +-- Copyright (c) 1999-2015 OPEN CASCADE SAS +-- +-- This file is part of Open CASCADE Technology software library. +-- +-- This library is free software; you can redistribute it and/or modify it under +-- the terms of the GNU Lesser General Public License version 2.1 as published +-- by the Free Software Foundation, with special exception defined in the file +-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +-- distribution for complete text of the license and disclaimer of any warranty. +-- +-- Alternatively, this file may be used under the terms of Open CASCADE +-- commercial license or contractual agreement. + +deferred class PointLine from IntPatch + +inherits Line from IntPatch + + ---Purpose: Definition of an intersection line between two + -- surfaces. + -- A line defined by a set of points + -- (e.g. coming from a walking algorithm) as + -- defined in the class WLine or RLine (Restriction line). + + +uses TypeTrans from IntSurf, + Situation from IntSurf, + PntOn2S from IntSurf + + +raises DomainError from Standard, + OutOfRange from Standard + +is + + Initialize(Tang: Boolean from Standard; + Trans1,Trans2: TypeTrans from IntSurf); + + ---Purpose: To initialize the fields, when the transitions + -- are In or Out. + + + Initialize(Tang: Boolean from Standard; + Situ1,Situ2: Situation from IntSurf); + + ---Purpose: To initialize the fields, when the transitions + -- are Touch. + + Initialize(Tang: Boolean from Standard); + + ---Purpose: To initialize the fields, when the transitions + -- are Undecided. + + NbPnts(me) returns Integer from Standard + ---Purpose: Returns the number of intersection points. + + is deferred; + + Point(me; Index : Integer from Standard) returns PntOn2S from IntSurf + ---Purpose: Returns the intersection point of range Index. + + ---C++: return const& + + raises OutOfRange from Standard, + DomainError from Standard + --- The exception DomainError is raised if HasPolygon returns False. + --- The exception OutOfRange is raised if Index <= 0 or Index > NbPnts. + + is deferred; + +-- fields + +end Line; diff --git a/src/IntPatch/IntPatch_PointLine.cxx b/src/IntPatch/IntPatch_PointLine.cxx new file mode 100644 index 0000000000..0025d9a721 --- /dev/null +++ b/src/IntPatch/IntPatch_PointLine.cxx @@ -0,0 +1,36 @@ +// Created on: 2015-02-18 +// Created by: Nikolai BUKHALOV +// Copyright (c) 1995-1999 Matra Datavision +// Copyright (c) 1999-2015 OPEN CASCADE SAS +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + + +IntPatch_PointLine::IntPatch_PointLine (const Standard_Boolean Tang, + const IntSurf_TypeTrans Trans1, + const IntSurf_TypeTrans Trans2) : + IntPatch_Line(Tang, Trans1, Trans2) +{} + +IntPatch_PointLine::IntPatch_PointLine (const Standard_Boolean Tang, + const IntSurf_Situation Situ1, + const IntSurf_Situation Situ2) : + IntPatch_Line(Tang, Situ1, Situ2) +{} + +IntPatch_PointLine::IntPatch_PointLine (const Standard_Boolean Tang) : + IntPatch_Line(Tang) +{} + + diff --git a/src/IntPatch/IntPatch_RLine.cdl b/src/IntPatch/IntPatch_RLine.cdl index 894507051a..0ffd145532 100644 --- a/src/IntPatch/IntPatch_RLine.cdl +++ b/src/IntPatch/IntPatch_RLine.cdl @@ -17,7 +17,7 @@ class RLine from IntPatch -inherits Line from IntPatch +inherits PointLine from IntPatch ---Purpose: Implementation of an intersection line described by a -- restriction line on one of the surfaces. diff --git a/src/IntPatch/IntPatch_RLine.cxx b/src/IntPatch/IntPatch_RLine.cxx index ba6787aca4..d3c12bb6c7 100644 --- a/src/IntPatch/IntPatch_RLine.cxx +++ b/src/IntPatch/IntPatch_RLine.cxx @@ -20,10 +20,9 @@ #include IntPatch_RLine::IntPatch_RLine (const Standard_Boolean Tang, - const IntSurf_TypeTrans Trans1, - const IntSurf_TypeTrans Trans2) : - IntPatch_Line(Tang,Trans1,Trans2), - fipt(Standard_False),lapt(Standard_False) + const IntSurf_TypeTrans Trans1, + const IntSurf_TypeTrans Trans2) : + IntPatch_PointLine(Tang,Trans1,Trans2), fipt(Standard_False),lapt(Standard_False) { typ = IntPatch_Restriction; @@ -33,10 +32,9 @@ IntPatch_RLine::IntPatch_RLine (const Standard_Boolean Tang, IntPatch_RLine::IntPatch_RLine (const Standard_Boolean Tang, - const IntSurf_Situation Situ1, - const IntSurf_Situation Situ2) : - IntPatch_Line(Tang,Situ1,Situ2), - fipt(Standard_False),lapt(Standard_False) + const IntSurf_Situation Situ1, + const IntSurf_Situation Situ2) : + IntPatch_PointLine(Tang,Situ1,Situ2), fipt(Standard_False),lapt(Standard_False) { typ = IntPatch_Restriction; onS2=Standard_False; @@ -45,8 +43,7 @@ IntPatch_RLine::IntPatch_RLine (const Standard_Boolean Tang, IntPatch_RLine::IntPatch_RLine (const Standard_Boolean Tang) : - IntPatch_Line(Tang), - fipt(Standard_False),lapt(Standard_False) + IntPatch_PointLine(Tang), fipt(Standard_False),lapt(Standard_False) { typ = IntPatch_Restriction; diff --git a/src/IntPatch/IntPatch_WLine.cdl b/src/IntPatch/IntPatch_WLine.cdl index 9bf5921737..524723e227 100644 --- a/src/IntPatch/IntPatch_WLine.cdl +++ b/src/IntPatch/IntPatch_WLine.cdl @@ -16,7 +16,7 @@ class WLine from IntPatch -inherits Line from IntPatch +inherits PointLine from IntPatch ---Purpose: Definition of set of points as a result of the intersection -- between 2 parametrised patches. diff --git a/src/IntPatch/IntPatch_WLine.cxx b/src/IntPatch/IntPatch_WLine.cxx index e82ffda21c..e55a3d218f 100644 --- a/src/IntPatch/IntPatch_WLine.cxx +++ b/src/IntPatch/IntPatch_WLine.cxx @@ -28,7 +28,7 @@ IntPatch_WLine::IntPatch_WLine (const Handle(IntSurf_LineOn2S)& Line, const Standard_Boolean Tang, const IntSurf_TypeTrans Trans1, const IntSurf_TypeTrans Trans2) : - IntPatch_Line(Tang,Trans1,Trans2),fipt(Standard_False),lapt(Standard_False), + IntPatch_PointLine(Tang,Trans1,Trans2),fipt(Standard_False),lapt(Standard_False), hasArcOnS1(Standard_False),hasArcOnS2(Standard_False) { typ = IntPatch_Walking; @@ -44,7 +44,7 @@ IntPatch_WLine::IntPatch_WLine (const Handle(IntSurf_LineOn2S)& Line, const Standard_Boolean Tang, const IntSurf_Situation Situ1, const IntSurf_Situation Situ2) : - IntPatch_Line(Tang,Situ1,Situ2),fipt(Standard_False),lapt(Standard_False), + IntPatch_PointLine(Tang,Situ1,Situ2),fipt(Standard_False),lapt(Standard_False), hasArcOnS1(Standard_False),hasArcOnS2(Standard_False) { typ = IntPatch_Walking; @@ -58,7 +58,7 @@ IntPatch_WLine::IntPatch_WLine (const Handle(IntSurf_LineOn2S)& Line, IntPatch_WLine::IntPatch_WLine (const Handle(IntSurf_LineOn2S)& Line, const Standard_Boolean Tang) : - IntPatch_Line(Tang),fipt(Standard_False),lapt(Standard_False), + IntPatch_PointLine(Tang),fipt(Standard_False),lapt(Standard_False), hasArcOnS1(Standard_False),hasArcOnS2(Standard_False) { typ = IntPatch_Walking; diff --git a/src/IntTools/IntTools_FaceFace.cxx b/src/IntTools/IntTools_FaceFace.cxx index d96acc3183..8880e66498 100644 --- a/src/IntTools/IntTools_FaceFace.cxx +++ b/src/IntTools/IntTools_FaceFace.cxx @@ -87,6 +87,7 @@ #include #include +#include #include #include #include @@ -115,6 +116,10 @@ #include #include +#include +#include +#include + static void RefineVector(gp_Vec2d& aV2D); #ifdef OCCT_DEBUG_DUMPWLINE @@ -140,12 +145,6 @@ static Standard_Real&, Standard_Real&); -static - void BuildPCurves (Standard_Real f,Standard_Real l,Standard_Real& Tol, - const Handle (Geom_Surface)& S, - const Handle (Geom_Curve)& C, - Handle (Geom2d_Curve)& C2d); - static void CorrectSurfaceBoundaries(const TopoDS_Face& theFace, const Standard_Real theTolerance, @@ -153,6 +152,7 @@ static Standard_Real& theumax, Standard_Real& thevmin, Standard_Real& thevmax); + static Standard_Boolean NotUseSurfacesForApprox (const TopoDS_Face& aF1, @@ -1094,20 +1094,32 @@ Standard_Real IntTools_FaceFace::ComputeTolerance() bAvoidLineConstructor = Standard_False; } } + + typl=L->ArcType(); + // // Line Constructor if(!bAvoidLineConstructor) { myLConstruct.Perform(L); // bDone=myLConstruct.IsDone(); - aNbParts=myLConstruct.NbParts(); - if (!bDone|| !aNbParts) { + if(!bDone) + { return; } + + if(typl != IntPatch_Restriction) + { + aNbParts=myLConstruct.NbParts(); + if (aNbParts <= 0) + { + return; + } + } } - // // Do the Curve - // + + switch (typl) { //######################################## // Line, Parabola, Hyperbola @@ -1140,7 +1152,7 @@ Standard_Real IntTools_FaceFace::ComputeTolerance() Standard_Boolean bFNIt, bLPIt; // myLConstruct.Part(i, fprm, lprm); - // + // bFNIt=Precision::IsNegativeInfinite(fprm); bLPIt=Precision::IsPositiveInfinite(lprm); // @@ -1162,7 +1174,8 @@ Standard_Real IntTools_FaceFace::ComputeTolerance() aCurve.SetCurve(new Geom_TrimmedCurve(newc, fprm, lprm)); if(myApprox1) { Handle (Geom2d_Curve) C2d; - BuildPCurves(fprm, lprm, Tolpc, myHS1->ChangeSurface().Surface(), newc, C2d); + GeomInt_IntSS::BuildPCurves(fprm, lprm, Tolpc, + myHS1->ChangeSurface().Surface(), newc, C2d); if(Tolpc>myTolReached2d || myTolReached2d==0.) { myTolReached2d=Tolpc; } @@ -1177,7 +1190,8 @@ Standard_Real IntTools_FaceFace::ComputeTolerance() // if(myApprox2) { Handle (Geom2d_Curve) C2d; - BuildPCurves(fprm,lprm,Tolpc,myHS2->ChangeSurface().Surface(),newc,C2d); + GeomInt_IntSS::BuildPCurves(fprm, lprm, Tolpc, + myHS2->ChangeSurface().Surface(), newc, C2d); if(Tolpc>myTolReached2d || myTolReached2d==0.) { myTolReached2d=Tolpc; } @@ -1345,7 +1359,8 @@ Standard_Real IntTools_FaceFace::ComputeTolerance() if (typl == IntPatch_Circle || typl == IntPatch_Ellipse) {//// if(myApprox1) { Handle (Geom2d_Curve) C2d; - BuildPCurves(fprm,lprm,Tolpc,myHS1->ChangeSurface().Surface(),newc,C2d); + GeomInt_IntSS::BuildPCurves(fprm, lprm, Tolpc, + myHS1->ChangeSurface().Surface(), newc, C2d); if(Tolpc>myTolReached2d || myTolReached2d==0) { myTolReached2d=Tolpc; } @@ -1360,7 +1375,8 @@ Standard_Real IntTools_FaceFace::ComputeTolerance() if(myApprox2) { Handle (Geom2d_Curve) C2d; - BuildPCurves(fprm,lprm,Tolpc,myHS2->ChangeSurface().Surface(),newc,C2d); + GeomInt_IntSS::BuildPCurves(fprm,lprm,Tolpc, + myHS2->ChangeSurface().Surface(),newc,C2d); if(Tolpc>myTolReached2d || myTolReached2d==0) { myTolReached2d=Tolpc; } @@ -1396,7 +1412,8 @@ Standard_Real IntTools_FaceFace::ComputeTolerance() if(myApprox1) { Handle (Geom2d_Curve) C2d; - BuildPCurves(fprm,lprm,Tolpc,myHS1->ChangeSurface().Surface(),newc,C2d); + GeomInt_IntSS::BuildPCurves(fprm,lprm,Tolpc, + myHS1->ChangeSurface().Surface(),newc,C2d); if(Tolpc>myTolReached2d || myTolReached2d==0) { myTolReached2d=Tolpc; } @@ -1410,7 +1427,8 @@ Standard_Real IntTools_FaceFace::ComputeTolerance() if(myApprox2) { Handle (Geom2d_Curve) C2d; - BuildPCurves(fprm,lprm,Tolpc,myHS2->ChangeSurface().Surface(),newc,C2d); + GeomInt_IntSS::BuildPCurves(fprm,lprm,Tolpc, + myHS2->ChangeSurface().Surface(),newc,C2d); if(Tolpc>myTolReached2d || myTolReached2d==0) { myTolReached2d=Tolpc; } @@ -1447,7 +1465,8 @@ Standard_Real IntTools_FaceFace::ComputeTolerance() if(myApprox1) { Handle (Geom2d_Curve) C2d; - BuildPCurves(fprm, lprm, Tolpc, myHS1->ChangeSurface().Surface(), newc, C2d); + GeomInt_IntSS::BuildPCurves(fprm, lprm, Tolpc, + myHS1->ChangeSurface().Surface(), newc, C2d); if(Tolpc>myTolReached2d || myTolReached2d==0) { myTolReached2d=Tolpc; } @@ -1461,7 +1480,8 @@ Standard_Real IntTools_FaceFace::ComputeTolerance() if(myApprox2) { Handle (Geom2d_Curve) C2d; - BuildPCurves(fprm, lprm, Tolpc,myHS2->ChangeSurface().Surface(), newc, C2d); + GeomInt_IntSS::BuildPCurves(fprm, lprm, Tolpc, + myHS2->ChangeSurface().Surface(), newc, C2d); if(Tolpc>myTolReached2d || myTolReached2d==0) { myTolReached2d=Tolpc; } @@ -2126,7 +2146,8 @@ Standard_Real IntTools_FaceFace::ComputeTolerance() Handle(Geom2d_Curve) C2d; Standard_Real aTol = myTolApprox; - BuildPCurves(fprm, lprm, aTol, myHS1->ChangeSurface().Surface(), BS, C2d); + GeomInt_IntSS::BuildPCurves(fprm, lprm, aTol, + myHS1->ChangeSurface().Surface(), BS, C2d); BS1 = Handle(Geom2d_BSplineCurve)::DownCast(C2d); aCurve.SetFirstCurve2d(BS1); } @@ -2156,7 +2177,8 @@ Standard_Real IntTools_FaceFace::ComputeTolerance() Handle(Geom2d_Curve) C2d; Standard_Real aTol = myTolApprox; - BuildPCurves(fprm, lprm, aTol, myHS2->ChangeSurface().Surface(), BS, C2d); + GeomInt_IntSS::BuildPCurves(fprm, lprm, aTol, + myHS2->ChangeSurface().Surface(), BS, C2d); BS2 = Handle(Geom2d_BSplineCurve)::DownCast(C2d); aCurve.SetSecondCurve2d(BS2); } @@ -2178,6 +2200,110 @@ Standard_Real IntTools_FaceFace::ComputeTolerance() break; case IntPatch_Restriction: + { + GeomAbs_SurfaceType typS1 = myHS1->Surface().GetType(); + GeomAbs_SurfaceType typS2 = myHS2->Surface().GetType(); + Standard_Boolean isAnalS1 = Standard_False; + switch (typS1) + { + case GeomAbs_Plane: + case GeomAbs_Cylinder: + case GeomAbs_Sphere: + case GeomAbs_Cone: + case GeomAbs_Torus: isAnalS1 = Standard_True; break; + default: break; + } + + Standard_Integer isAnalS2 = Standard_False; + switch (typS2) + { + case GeomAbs_Plane: + case GeomAbs_Cylinder: + case GeomAbs_Sphere: + case GeomAbs_Cone: + case GeomAbs_Torus: isAnalS2 = Standard_True; break; + default: break; + } + + Handle(IntPatch_RLine) RL = + Handle(IntPatch_RLine)::DownCast(L); + Handle(Geom_Curve) aC3d; + Handle(Geom2d_Curve) aC2d1, aC2d2; + Standard_Real aTolReached; + GeomInt_IntSS::TreatRLine(RL, myHS1, myHS2, aC3d, + aC2d1, aC2d2, aTolReached); + + if(aC3d.IsNull()) + break; + + Bnd_Box2d aBox1, aBox2; + + const Standard_Real aU1f = myHS1->FirstUParameter(), + aV1f = myHS1->FirstVParameter(), + aU1l = myHS1->LastUParameter(), + aV1l = myHS1->LastVParameter(); + const Standard_Real aU2f = myHS2->FirstUParameter(), + aV2f = myHS2->FirstVParameter(), + aU2l = myHS2->LastUParameter(), + aV2l = myHS2->LastVParameter(); + + aBox1.Add(gp_Pnt2d(aU1f, aV1f)); + aBox1.Add(gp_Pnt2d(aU1l, aV1l)); + aBox2.Add(gp_Pnt2d(aU2f, aV2f)); + aBox2.Add(gp_Pnt2d(aU2l, aV2l)); + + GeomInt_VectorOfReal anArrayOfParameters; + + //We consider here that the intersection line is same-parameter-line + anArrayOfParameters.Append(aC3d->FirstParameter()); + anArrayOfParameters.Append(aC3d->LastParameter()); + + GeomInt_IntSS:: + TrimILineOnSurfBoundaries(aC2d1, aC2d2, aBox1, aBox2, anArrayOfParameters); + + const Standard_Integer aNbIntersSolutionsm1 = anArrayOfParameters.Length() - 1; + + //Trim RLine found. + for(Standard_Integer anInd = 0; anInd < aNbIntersSolutionsm1; anInd++) + { + const Standard_Real aParF = anArrayOfParameters(anInd), + aParL = anArrayOfParameters(anInd+1); + + if((aParL - aParF) <= Precision::PConfusion()) + continue; + + const Standard_Real aPar = 0.5*(aParF + aParL); + gp_Pnt2d aPt; + + Handle(Geom2d_Curve) aCurv2d1, aCurv2d2; + if(!aC2d1.IsNull()) + { + aC2d1->D0(aPar, aPt); + + if(aBox1.IsOut(aPt)) + continue; + + if(myApprox1) + aCurv2d1 = new Geom2d_TrimmedCurve(aC2d1, aParF, aParL); + } + + if(!aC2d2.IsNull()) + { + aC2d2->D0(aPar, aPt); + + if(aBox2.IsOut(aPt)) + continue; + + if(myApprox2) + aCurv2d2 = new Geom2d_TrimmedCurve(aC2d2, aParF, aParL); + } + + Handle(Geom_Curve) aCurv3d = new Geom_TrimmedCurve(aC3d, aParF, aParL); + + IntTools_Curve aIC(aCurv3d, aCurv2d1, aCurv2d2); + mySeqOfCurve.Append(aIC); + } + } break; default: break; @@ -2185,100 +2311,6 @@ Standard_Real IntTools_FaceFace::ComputeTolerance() } } -//======================================================================= -//function : BuildPCurves -//purpose : -//======================================================================= -void BuildPCurves (Standard_Real f, - Standard_Real l, - Standard_Real& Tol, - const Handle (Geom_Surface)& S, - const Handle (Geom_Curve)& C, - Handle (Geom2d_Curve)& C2d) -{ - if (!C2d.IsNull()) { - return; - } - // - Standard_Real umin,umax,vmin,vmax; - // - S->Bounds(umin, umax, vmin, vmax); - // in class ProjLib_Function the range of parameters is shrank by 1.e-09 - if((l - f) > 2.e-09) { - C2d = GeomProjLib::Curve2d(C,f,l,S,umin,umax,vmin,vmax,Tol); - // - if (C2d.IsNull()) { - // proj. a circle that goes through the pole on a sphere to the sphere - Tol += Precision::Confusion(); - C2d = GeomProjLib::Curve2d(C,f,l,S,Tol); - } - } - else { - if((l - f) > Epsilon(Abs(f))) { - GeomAPI_ProjectPointOnSurf aProjector1, aProjector2; - gp_Pnt P1 = C->Value(f); - gp_Pnt P2 = C->Value(l); - aProjector1.Init(P1, S); - aProjector2.Init(P2, S); - - if(aProjector1.IsDone() && aProjector2.IsDone()) { - Standard_Real U=0., V=0.; - aProjector1.LowerDistanceParameters(U, V); - gp_Pnt2d p1(U, V); - - aProjector2.LowerDistanceParameters(U, V); - gp_Pnt2d p2(U, V); - - if(p1.Distance(p2) > gp::Resolution()) { - TColgp_Array1OfPnt2d poles(1,2); - TColStd_Array1OfReal knots(1,2); - TColStd_Array1OfInteger mults(1,2); - poles(1) = p1; - poles(2) = p2; - knots(1) = f; - knots(2) = l; - mults(1) = mults(2) = 2; - - C2d = new Geom2d_BSplineCurve(poles,knots,mults,1); - - // compute reached tolerance.begin - gp_Pnt PMid = C->Value((f + l) * 0.5); - aProjector1.Perform(PMid); - - if(aProjector1.IsDone()) { - aProjector1.LowerDistanceParameters(U, V); - gp_Pnt2d pmidproj(U, V); - gp_Pnt2d pmidcurve2d = C2d->Value((f + l) * 0.5); - Standard_Real adist = pmidcurve2d.Distance(pmidproj); - Tol = (adist > Tol) ? adist : Tol; - } - // compute reached tolerance.end - } - } - } - } - // - if (S->IsUPeriodic() && !C2d.IsNull()) { - // Recadre dans le domaine UV de la face - Standard_Real aTm, U0, aEps, period, du, U0x; - Standard_Boolean bAdjust; - // - aEps = Precision::PConfusion(); - period = S->UPeriod(); - // - aTm = .5*(f + l); - gp_Pnt2d pm = C2d->Value(aTm); - U0 = pm.X(); - // - bAdjust = - GeomInt::AdjustPeriodic(U0, umin, umax, period, U0x, du, aEps); - if (bAdjust) { - gp_Vec2d T1(du, 0.); - C2d->Translate(T1); - } - } -} - //======================================================================= //function : Parameters //purpose : @@ -2524,26 +2556,30 @@ Handle(Geom2d_BSplineCurve) MakeBSpline2d(const Handle(IntPatch_WLine)& theWLine // if(!isuperiodic && enlarge) { - if((theumin - uinf) > delta ) + if(!Precision::IsInfinite(theumin) && + ((theumin - uinf) > delta)) theumin -= delta; else { theumin = uinf; } - if((usup - theumax) > delta ) + if(!Precision::IsInfinite(theumax) && + ((usup - theumax) > delta)) theumax += delta; else theumax = usup; } // if(!isvperiodic && enlarge) { - if((thevmin - vinf) > delta ) { + if(!Precision::IsInfinite(thevmin) && + ((thevmin - vinf) > delta)) { thevmin -= delta; } else { thevmin = vinf; } - if((vsup - thevmax) > delta ) { + if(!Precision::IsInfinite(thevmax) && + ((vsup - thevmax) > delta)) { thevmax += delta; } else { diff --git a/src/TopOpeBRep/TopOpeBRep_FacesIntersector.cxx b/src/TopOpeBRep/TopOpeBRep_FacesIntersector.cxx index f6d4d0f508..920864d40e 100644 --- a/src/TopOpeBRep/TopOpeBRep_FacesIntersector.cxx +++ b/src/TopOpeBRep/TopOpeBRep_FacesIntersector.cxx @@ -208,7 +208,8 @@ void TopOpeBRep_FacesIntersector::Perform(const TopoDS_Shape& F1,const TopoDS_Sh #endif myIntersector.SetTolerances(myTol1,myTol2,MaxUV,Deflection); - myIntersector.Perform(mySurface1,myDomain1,mySurface2,myDomain2,myTol1,myTol2); + myIntersector.Perform(mySurface1,myDomain1,mySurface2,myDomain2, + myTol1,myTol2,Standard_True,Standard_True); #ifdef OCCT_DEBUG if (TopOpeBRepTool_GettraceKRO()) KRO_DSFILLER_INTFF.Stop(); diff --git a/src/gp/gp_Lin2d.lxx b/src/gp/gp_Lin2d.lxx index c37292b3bc..df2068ec10 100644 --- a/src/gp/gp_Lin2d.lxx +++ b/src/gp/gp_Lin2d.lxx @@ -95,10 +95,8 @@ inline Standard_Real gp_Lin2d::SquareDistance (const gp_Pnt2d& P) const inline Standard_Real gp_Lin2d::SquareDistance (const gp_Lin2d& Other) const { Standard_Real D = 0.0; - if (pos.IsParallel (Other.pos, gp::Resolution())) { - D = Other.Distance(pos.Location()); - D *= D;return D * D; - } + if (pos.IsParallel (Other.pos, gp::Resolution())) + D = Other.SquareDistance(pos.Location()); return D; } diff --git a/tests/boolean/bopsection/B5 b/tests/boolean/bopsection/B5 index 0b39b5d9dc..bd3ea205fd 100644 --- a/tests/boolean/bopsection/B5 +++ b/tests/boolean/bopsection/B5 @@ -7,4 +7,4 @@ restore [locate_data_file CTO904_cts20280b.rle] b bop a b bopsection result -set length 546.82 +set length 530.82 diff --git a/tests/boolean/bsection/B5 b/tests/boolean/bsection/B5 index 27fc3755a7..4b4e693d98 100644 --- a/tests/boolean/bsection/B5 +++ b/tests/boolean/bsection/B5 @@ -2,4 +2,4 @@ restore [locate_data_file CIN001_a15.rle] a restore [locate_data_file CIN001_b15.rle] b bsection result a b -set length 546.82 +set length 530.82 diff --git a/tests/bugs/modalg_5/bug24650 b/tests/bugs/modalg_5/bug24650 index 955ffb5284..86cea01978 100644 --- a/tests/bugs/modalg_5/bug24650 +++ b/tests/bugs/modalg_5/bug24650 @@ -6,6 +6,8 @@ puts "" # Wrong intersection curves obtained for a surface of revolution and a plane. ############################################################## +set GoodNbCurv 1 + restore [locate_data_file bug24650_fz1365.brep] b1 restore [locate_data_file bug24650_fz2495.brep] b2 @@ -13,22 +15,67 @@ mksurface sb1 b1 mksurface sb2 b2 trimu sb1tu sb1 0.242 0.291 -set N [intersect i sb1tu sb2] +clear -if { [llength ${N}] != 1} { - puts "Error : Wrong intersection curves" +set N [intersect res sb1tu sb2] + +set che [whatis res] +set ind [string first "3d curve" $che] +if {${ind} >= 0} { + #Only variable "res" exists + renamevar res res_1 +} + + +set ic 1 +set AllowRepeate 1 +while { $AllowRepeate != 0 } { + set che [whatis res_$ic] + set ind [string first "3d curve" $che] + if {${ind} < 0} { + set AllowRepeate 0 + } else { + display res_$ic + + bounds res_$ic U1 U2 + + dval U1 + dval U2 + + if {[dval U2-U1] < 1.0e-20} { + puts "Error: Wrong curve's range!" + } + + dlog reset + dlog on + xdistcs res_$ic sb1tu U1 U2 10 + set Log1 [dlog get] + set List1 [split ${Log1} {TD= \t\n}] + set Tolerance 1.0e-7 + set Limit_Tol 1.0e-7 + set D_good 0. + checkList ${List1} ${Tolerance} ${D_good} ${Limit_Tol} + + dlog reset + dlog on + xdistcs res_$ic sb2 U1 U2 10 + set Log1 [dlog get] + set List1 [split ${Log1} {TD= \t\n}] + set Tolerance 1.0e-7 + set Limit_Tol 1.0e-7 + set D_good 0. + checkList ${List1} ${Tolerance} ${D_good} ${Limit_Tol} + + incr ic + } +} + +if {[expr {$ic - 1}] == $GoodNbCurv} { + puts "OK: Curve Number is good!" } else { - set info1 [dump i] - set type_of_curve "BSplineCurve" - if { [regexp ${type_of_curve} ${info1}] != 1 } { - puts "Error : Wrong type of intersection curve" - } else { - puts "OK : Good type of intersection curve" - } + puts "Error: Curve Number is bad!" } smallview -donly i fit set only_screen_axo 1 - diff --git a/tests/bugs/modalg_5/bug25416_1 b/tests/bugs/modalg_5/bug25416_1 new file mode 100644 index 0000000000..7331cbc774 --- /dev/null +++ b/tests/bugs/modalg_5/bug25416_1 @@ -0,0 +1,124 @@ +puts "================" +puts "OCC25416" +puts "================" +puts "" +####################################################################### +# Wrong section curve +####################################################################### + +# Check if list of xdistcs-command is valid +proc checkList {List Tolerance D_good Limit_Tol} { + set L1 [llength ${List}] + set L2 10 + set L3 5 + set N [expr (${L1} - ${L2})/${L3} + 1] + + for {set i 1} {${i} <= ${N}} {incr i} { + set j1 [expr ${L2} + (${i}-1)*${L3}] + set j2 [expr ${j1} + 2] + set T [lindex ${List} ${j1}] + set D [lindex ${List} ${j2}] + #puts "i=${i} j1=${j1} j2=${j2} T=${T} D=${D}" + if { [expr abs(${D} - ${D_good})] > ${Tolerance} } { + puts "Error: T=${T} D=${D}" + } + + if { ${Tolerance} > ${Limit_Tol} } { + if { [expr abs(${D} - ${D_good})] > ${Limit_Tol} + && [expr abs(${D} - ${D_good})] <= ${Tolerance} } { + puts "Attention (critical value of tolerance) : T=${T} D=${D}" + } + } + } +} + + +puts "##############################" +puts "#!!!Search \"Attention\" keyword on this web-page for additional checking!!!" +puts "##############################" +puts "" +puts "" + +# bopcurves command + +restore [locate_data_file bug25416_f1.brep] f1 +restore [locate_data_file bug25416_f2.brep] f2 + +############################# +set log [bopcurves f1 f2 -2d] +############################# + +regexp {Tolerance Reached=+([-0-9.+eE]+)\n+([-0-9.+eE]+)} ${log} full Toler NbCurv + +#This value must be equal to the analogical value in bug25292_31 and bug25292_32 of "bugs modalg_5" testgrid. +set MaxTol 1.e-7 + +#This value must be equal to the analogical value in bug25292_31 and bug25292_32 of "bugs modalg_5" testgrid. +set GoodNbCurv 1 + +if {${Toler} > ${MaxTol}} { + puts "Error: Tolerance is too big!" +} +if {${NbCurv} != ${GoodNbCurv}} { + puts "Error: Curve Number is bad!" +} + +#------------- + +mksurface s1 f1 +mksurface s2 f2 + +erase s1 s2 + +for {set i 1} {$i <= ${NbCurv}} {incr i} { + set log [dump c_$i] + set dumptrimres [regexp {Trimmed curve\nParameters : +([-0-9.+eE]+) +([-0-9.+eE]+)} ${log} full U1 U2] + + if {${dumptrimres} == 0} { + regexp {Degree +([-0-9.+eE]+), +([-0-9.+eE]+) Poles, +([-0-9.+eE]+)} ${log} full Degree Poles KnotsPoles + + puts "Degree=${Degree}" + puts "Poles=${Poles}" + puts "KnotsPoles=${KnotsPoles}" + puts "" + + set Knot 1 + set exp_string "Knots :\n\n +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)" + regexp ${exp_string} ${log} full U1 Mult1 + + set Knot ${KnotsPoles} + set exp_string " +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)" + regexp ${exp_string} ${log} full U2 Mult2 + } + + puts "U1=${U1}" + puts "U2=${U2}" + + if {[expr {$U2 - $U1}] < 1.0e-20} { + puts "Error: Wrong curve's range!" + } + + dlog reset + dlog on + xdistcs c_$i s1 ${U1} ${U2} 10 + set Log2 [dlog get] + set List2 [split ${Log2} {TD= \t\n}] + set Tolerance 1.0e-7 + set Limit_Tol 1.0e-7 + set D_good 0. + checkList ${List2} ${Tolerance} ${D_good} ${Limit_Tol} + + dlog reset + dlog on + xdistcs c_$i s2 ${U1} ${U2} 10 + set Log2 [dlog get] + set List2 [split ${Log2} {TD= \t\n}] + set Tolerance 1.0e-7 + set Limit_Tol 1.0e-7 + set D_good 0. + checkList ${List2} ${Tolerance} ${D_good} ${Limit_Tol} +} + +smallview +fit +set only_screen_axo 1 diff --git a/tests/bugs/modalg_5/bug25416_2 b/tests/bugs/modalg_5/bug25416_2 new file mode 100644 index 0000000000..8c56c3fda1 --- /dev/null +++ b/tests/bugs/modalg_5/bug25416_2 @@ -0,0 +1,127 @@ +puts "================" +puts "OCC25416" +puts "================" +puts "" +####################################################################### +# Wrong section curve +####################################################################### + +# Check if list of xdistcs-command is valid +proc checkList {List Tolerance D_good Limit_Tol} { + set L1 [llength ${List}] + set L2 10 + set L3 5 + set N [expr (${L1} - ${L2})/${L3} + 1] + + for {set i 1} {${i} <= ${N}} {incr i} { + set j1 [expr ${L2} + (${i}-1)*${L3}] + set j2 [expr ${j1} + 2] + set T [lindex ${List} ${j1}] + set D [lindex ${List} ${j2}] + #puts "i=${i} j1=${j1} j2=${j2} T=${T} D=${D}" + if { [expr abs(${D} - ${D_good})] > ${Tolerance} } { + puts "Error: T=${T} D=${D}" + } + + if { ${Tolerance} > ${Limit_Tol} } { + if { [expr abs(${D} - ${D_good})] > ${Limit_Tol} + && [expr abs(${D} - ${D_good})] <= ${Tolerance} } { + puts "Attention (critical value of tolerance) : T=${T} D=${D}" + } + } + } +} + +puts "##############################" +puts "#!!!Search \"Attention\" keyword on this web-page for additional checking!!!" +puts "##############################" +puts "" +puts "" + +# bopcurves command + +restore [locate_data_file bug25416_f3.brep] f1 +restore [locate_data_file bug25416_f4.brep] f2 + +mksurface s1 f1 +mksurface s2 f2 + +#Trim according to "xbounds f1" +trim s1 s1 -55.44 150.554 -98.1087 79.1766 + +mkface ff1 s1 +donly ff1 f2 + +############################# +set log [bopcurves ff1 f2] +############################# + +regexp {Tolerance Reached=+([-0-9.+eE]+)\n+([-0-9.+eE]+)} ${log} full Toler NbCurv + +#This value must be equal to the analogical value in bug25292_31 and bug25292_32 of "bugs modalg_5" testgrid. +set MaxTol 1.e-7 + +#This value must be equal to the analogical value in bug25292_31 and bug25292_32 of "bugs modalg_5" testgrid. +set GoodNbCurv 2 + +if {${Toler} > ${MaxTol}} { + puts "Error: Tolerance is too big!" +} +if {${NbCurv} != ${GoodNbCurv}} { + puts "Error: Curve Number is bad!" +} + +#------------- + +for {set i 1} {$i <= ${NbCurv}} {incr i} { + set log [dump c_$i] + set dumptrimres [regexp {Trimmed curve\nParameters : +([-0-9.+eE]+) +([-0-9.+eE]+)} ${log} full U1 U2] + + if {${dumptrimres} == 0} { + regexp {Degree +([-0-9.+eE]+), +([-0-9.+eE]+) Poles, +([-0-9.+eE]+)} ${log} full Degree Poles KnotsPoles + + puts "Degree=${Degree}" + puts "Poles=${Poles}" + puts "KnotsPoles=${KnotsPoles}" + puts "" + + set Knot 1 + set exp_string "Knots :\n\n +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)" + regexp ${exp_string} ${log} full U1 Mult1 + + set Knot ${KnotsPoles} + set exp_string " +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)" + regexp ${exp_string} ${log} full U2 Mult2 + } + + puts "U1=${U1}" + puts "U2=${U2}" + + if {[expr {$U2 - $U1}] < 1.0e-20} { + puts "Error: Wrong curve's range!" + } + + dlog reset + dlog on + xdistcs c_$i s1 ${U1} ${U2} 10 + set Log2 [dlog get] + set List2 [split ${Log2} {TD= \t\n}] + set Tolerance 1.0e-7 + set Limit_Tol 1.0e-7 + set D_good 0. + checkList ${List2} ${Tolerance} ${D_good} ${Limit_Tol} + + dlog reset + dlog on + xdistcs c_$i s2 ${U1} ${U2} 10 + set Log2 [dlog get] + set List2 [split ${Log2} {TD= \t\n}] + set Tolerance 1.0e-7 + set Limit_Tol 1.0e-7 + set D_good 0. + checkList ${List2} ${Tolerance} ${D_good} ${Limit_Tol} +} + +smallview +fit +set only_screen_axo 1 diff --git a/tests/bugs/modalg_5/bug25416_3 b/tests/bugs/modalg_5/bug25416_3 new file mode 100644 index 0000000000..2ad495f445 --- /dev/null +++ b/tests/bugs/modalg_5/bug25416_3 @@ -0,0 +1,44 @@ +puts "================" +puts "OCC25416" +puts "================" +puts "" +####################################################################### +# Wrong section curve +####################################################################### + +#Check if intersection algorithm produces overlapped curves + +restore [locate_data_file bug25416_s1.brep] s1 +restore [locate_data_file bug25416_s2.brep] s2 + +set ll [intersect ii s1 s2] + +set status 0 +if { [llength $ll] < 1 } { + set status 1 +} + +foreach i $ll { + foreach j $ll { + if { $i >= $j } continue + + decho off + mkedge e1 $i + mkedge e2 $j + set coe [checkoverlapedges e1 e2] + decho on + + puts "$i<->$j: $coe" + if { [regexp "Edges is not overlaped" $coe] != 1 } { + set status 2 + } + } +} + +decho on + +if { $status != 0 } { + puts "Wrong section. Error with code $status" +} else { + puts "OK: Good section" +}