From 546dcf2f43b12c9d5ba6d043b5e9582cd68d480b Mon Sep 17 00:00:00 2001 From: asuraven Date: Tue, 13 Jul 2021 17:17:51 +0300 Subject: [PATCH] 0032450: Modeling Algorithms - change BRepLib_CheckCurveOnSurface & GeomLib_CheckCurveOnSurface interfaces to adapters --- src/BRepLib/BRepLib_CheckCurveOnSurface.cxx | 55 +++--- src/BRepLib/BRepLib_CheckCurveOnSurface.hxx | 39 +---- src/BRepLib/BRepLib_ValidateEdge.cxx | 9 +- src/BRepLib/BRepLib_ValidateEdge.hxx | 10 +- src/BRepTools/BRepTools.cxx | 13 +- src/GeomLib/GeomLib_CheckCurveOnSurface.cxx | 182 ++++++++++---------- src/GeomLib/GeomLib_CheckCurveOnSurface.hxx | 44 ++--- src/IntTools/IntTools_Tools.cxx | 13 +- 8 files changed, 173 insertions(+), 192 deletions(-) diff --git a/src/BRepLib/BRepLib_CheckCurveOnSurface.cxx b/src/BRepLib/BRepLib_CheckCurveOnSurface.cxx index c9a3257c81..c6adc33a40 100644 --- a/src/BRepLib/BRepLib_CheckCurveOnSurface.cxx +++ b/src/BRepLib/BRepLib_CheckCurveOnSurface.cxx @@ -12,8 +12,13 @@ // Alternatively, this file may be used under the terms of Open CASCADE // commercial license or contractual agreement. +#include #include +#include #include +#include +#include +#include #include #include #include @@ -36,9 +41,7 @@ BRepLib_CheckCurveOnSurface::BRepLib_CheckCurveOnSurface //function : Init //purpose : //======================================================================= -void BRepLib_CheckCurveOnSurface::Init - (const TopoDS_Edge& theEdge, - const TopoDS_Face& theFace) +void BRepLib_CheckCurveOnSurface::Init(const TopoDS_Edge& theEdge, const TopoDS_Face& theFace) { myCOnSurfGeom.Init(); @@ -53,26 +56,34 @@ void BRepLib_CheckCurveOnSurface::Init return; } - // - TopLoc_Location aLocE, aLocF, aLocC2D; - Standard_Real aFirst = 0.0, aLast = 0.0; - // // 3D curve initialization - const Handle(Geom_Curve)& aC3dTmp = BRep_Tool::Curve(theEdge, aLocE, aFirst, aLast); - const Handle(Geom_Curve) aC3d(Handle(Geom_Curve)::DownCast(aC3dTmp->Transformed(aLocE.Transformation()))); + const Handle(Adaptor3d_Curve) anAdaptor3dCurve = new BRepAdaptor_Curve(theEdge); // Surface initialization - const Handle(Geom_Surface)& aSTmp = BRep_Tool::Surface(theFace, aLocF); - const Handle(Geom_Surface) aS(Handle(Geom_Surface)::DownCast(aSTmp->Transformed(aLocF.Transformation()))); - // + + TopLoc_Location aLocation; + Standard_Real aFirstParam, aLastParam; + + Handle(Geom2d_Curve) aGeom2dCurve = BRep_Tool::CurveOnSurface(theEdge, theFace, aFirstParam, aLastParam); + Handle(Geom_Surface) aGeomSurface = BRep_Tool::Surface(theFace); + // 2D curves initialization - myPCurve = BRep_Tool::CurveOnSurface(theEdge, theFace, aFirst, aLast); + Handle(Adaptor2d_Curve2d) anAdaptorCurve = + new Geom2dAdaptor_Curve(aGeom2dCurve, aFirstParam, aLastParam); + Handle(GeomAdaptor_Surface) aGeomAdaptorSurface = new GeomAdaptor_Surface(aGeomSurface); + + myAdaptorCurveOnSurface = new Adaptor3d_CurveOnSurface(anAdaptorCurve, aGeomAdaptorSurface); if(BRep_Tool::IsClosed(theEdge, theFace)) - myPCurve2 = BRep_Tool::CurveOnSurface(TopoDS::Edge(theEdge.Reversed()), - theFace, aFirst, aLast); + { + Handle(Geom2d_Curve) aGeom2dReversedCurve = + BRep_Tool::CurveOnSurface(TopoDS::Edge(theEdge.Reversed()), theFace, aFirstParam, aLastParam); + Handle(Adaptor2d_Curve2d) anAdaptorReversedCurve = + new Geom2dAdaptor_Curve(aGeom2dReversedCurve, aFirstParam, aLastParam); + myAdaptorCurveOnSurface2 = new Adaptor3d_CurveOnSurface(anAdaptorReversedCurve, aGeomAdaptorSurface); + } - myCOnSurfGeom.Init(aC3d, aS, aFirst, aLast); + myCOnSurfGeom.Init(anAdaptor3dCurve); } //======================================================================= @@ -82,17 +93,17 @@ void BRepLib_CheckCurveOnSurface::Init void BRepLib_CheckCurveOnSurface::Perform(const Standard_Boolean isMultiThread) { // Compute the max distance - Compute(myPCurve, isMultiThread); + Compute(myAdaptorCurveOnSurface, isMultiThread); if (ErrorStatus()) { return; } // - if (!myPCurve2.IsNull()) + if (!myAdaptorCurveOnSurface2.IsNull()) { - // compute max distance for myPCurve2 + // compute max distance for myAdaptorCurveOnSurface2 // (for the second curve on closed surface) - Compute(myPCurve2, isMultiThread); + Compute(myAdaptorCurveOnSurface2, isMultiThread); } } @@ -100,8 +111,8 @@ void BRepLib_CheckCurveOnSurface::Perform(const Standard_Boolean isMultiThread) //function : Compute //purpose : if isTheMTDisabled == TRUE parallelization is not used //======================================================================= -void BRepLib_CheckCurveOnSurface::Compute(const Handle(Geom2d_Curve)& thePCurve, +void BRepLib_CheckCurveOnSurface::Compute(const Handle(Adaptor3d_CurveOnSurface)& theCurveOnSurface, const Standard_Boolean isMultiThread) { - myCOnSurfGeom.Perform(thePCurve, isMultiThread); + myCOnSurfGeom.Perform(theCurveOnSurface, isMultiThread); } diff --git a/src/BRepLib/BRepLib_CheckCurveOnSurface.hxx b/src/BRepLib/BRepLib_CheckCurveOnSurface.hxx index a30aae6521..2de289c3f8 100644 --- a/src/BRepLib/BRepLib_CheckCurveOnSurface.hxx +++ b/src/BRepLib/BRepLib_CheckCurveOnSurface.hxx @@ -38,38 +38,7 @@ public: //! Performs the calculation //! If isMultiThread == Standard_True then computation will be performed in parallel. - Standard_EXPORT void Perform(const Standard_Boolean isMultiThread = Standard_True); - - //! Returns source 3D-Curve - const Handle(Geom_Curve)& Curve() const - { - return myCOnSurfGeom.Curve(); - } - - //! Returns mine 2D-Curve - const Handle(Geom2d_Curve)& PCurve() const - { - return myPCurve; - } - - //! Returns 2nd 2D-Curve (if it exists, e.g. for seam-edge) - const Handle(Geom2d_Curve)& PCurve2() const - { - return myPCurve2; - } - - //! Returns source surface - const Handle(Geom_Surface)& Surface() const - { - return myCOnSurfGeom.Surface(); - } - - //! Returns first and last parameter of the curves - //! (2D- and 3D-curves are considered to have same range) - void Range (Standard_Real& theFirst, Standard_Real& theLast) - { - myCOnSurfGeom.Range(theFirst, theLast); - } + Standard_EXPORT void Perform (const Standard_Boolean isMultiThread = Standard_True); //! Returns true if the max distance has been found Standard_Boolean IsDone() const @@ -105,14 +74,14 @@ protected: //! Computes the max distance for the 3d curve of //! and 2d curve //! If isMultiThread == Standard_True then computation will be performed in parallel. - Standard_EXPORT void Compute (const Handle(Geom2d_Curve)& thePCurve, + Standard_EXPORT void Compute (const Handle(Adaptor3d_CurveOnSurface)& theCurveOnSurface, const Standard_Boolean isMultiThread); private: GeomLib_CheckCurveOnSurface myCOnSurfGeom; - Handle(Geom2d_Curve) myPCurve; - Handle(Geom2d_Curve) myPCurve2; + Handle(Adaptor3d_CurveOnSurface) myAdaptorCurveOnSurface; + Handle(Adaptor3d_CurveOnSurface) myAdaptorCurveOnSurface2; }; #endif // _BRepLib_CheckCurveOnSurface_HeaderFile diff --git a/src/BRepLib/BRepLib_ValidateEdge.cxx b/src/BRepLib/BRepLib_ValidateEdge.cxx index f97a13640e..54047b270a 100644 --- a/src/BRepLib/BRepLib_ValidateEdge.cxx +++ b/src/BRepLib/BRepLib_ValidateEdge.cxx @@ -41,7 +41,7 @@ BRepLib_ValidateEdge::BRepLib_ValidateEdge(Handle(Adaptor3d_Curve) theReferenceC //============================================================================= Standard_Boolean BRepLib_ValidateEdge::CheckTolerance(Standard_Real theToleranceToCheck) { - return correctTolerance(theToleranceToCheck) > myCalculatedDistance; + return CorrectTolerance(theToleranceToCheck) > myCalculatedDistance; } //============================================================================= @@ -68,10 +68,10 @@ void BRepLib_ValidateEdge::UpdateTolerance(Standard_Real& theToleranceToUpdate) } //============================================================================= -//function : correctTolerance +//function : CorrectTolerance //purpose : //============================================================================= -Standard_Real BRepLib_ValidateEdge::correctTolerance(Standard_Real theTolerance) +Standard_Real BRepLib_ValidateEdge::CorrectTolerance(Standard_Real theTolerance) { const Handle(Adaptor3d_Surface)& aSurface = myOtherCurve->GetSurface(); Standard_Real aCurvePrecision = BRepCheck::PrecCurve(*myReferenceCurve); @@ -88,7 +88,7 @@ Standard_Real BRepLib_ValidateEdge::correctTolerance(Standard_Real theTolerance) void BRepLib_ValidateEdge::SetExitIfToleranceExceeded(Standard_Real theToleranceForChecking) { myExitIfToleranceExceeded = Standard_True; - myToleranceForChecking = correctTolerance(theToleranceForChecking); + myToleranceForChecking = CorrectTolerance(theToleranceForChecking); } //============================================================================= @@ -212,3 +212,4 @@ void BRepLib_ValidateEdge::Process() } myCalculatedDistance = Sqrt(aMaxSquareDistance); } + diff --git a/src/BRepLib/BRepLib_ValidateEdge.hxx b/src/BRepLib/BRepLib_ValidateEdge.hxx index 48fc25c7f2..30ab95fb06 100644 --- a/src/BRepLib/BRepLib_ValidateEdge.hxx +++ b/src/BRepLib/BRepLib_ValidateEdge.hxx @@ -32,7 +32,7 @@ public: Standard_Boolean theSameParameter); //! Set control points number (if you need a value other than 22) - void SetControlPointsNumber(Standard_Integer theControlPointsNumber) + Standard_EXPORT void SetControlPointsNumber(Standard_Integer theControlPointsNumber) { myControlPointsNumber = theControlPointsNumber; } @@ -44,12 +44,12 @@ public: //! Computes the max distance for the 3d curve //! and curve on surface . If the SetExitIfToleranceExceeded() - //! function was called before contains first + //! function was called before containts first //! greater than SetExitIfToleranceExceeded() parameter value Standard_EXPORT void Process(); //! Returns true if the distance has been found for all points - Standard_Boolean IsDone() + Standard_EXPORT Standard_Boolean IsDone() { return myIsDone; } @@ -65,13 +65,13 @@ public: private: //! Adds some margin for distance checking - Standard_Real correctTolerance(Standard_Real theTolerance); + Standard_Real CorrectTolerance(Standard_Real theTolerance); private: Handle(Adaptor3d_Curve) myReferenceCurve; Handle(Adaptor3d_CurveOnSurface) myOtherCurve; Standard_Boolean mySameParameter; - Standard_Integer myControlPointsNumber; + Standard_Integer myControlPointsNumber; Standard_Real myToleranceForChecking; Standard_Real myCalculatedDistance; Standard_Boolean myExitIfToleranceExceeded; diff --git a/src/BRepTools/BRepTools.cxx b/src/BRepTools/BRepTools.cxx index 156ca3fb21..6c69c1fbe1 100644 --- a/src/BRepTools/BRepTools.cxx +++ b/src/BRepTools/BRepTools.cxx @@ -15,6 +15,7 @@ // commercial license or contractual agreement. +#include #include #include #include @@ -30,6 +31,7 @@ #include #include #include +#include #include #include #include @@ -1329,9 +1331,16 @@ Standard_Real BRepTools::EvalAndUpdateTol(const TopoDS_Edge& theE, first = Max(first, C2d->FirstParameter()); last = Min(last, C2d->LastParameter()); } + const Handle(Adaptor3d_Curve) aGeomAdaptorCurve = new GeomAdaptor_Curve(C3d, first, last); - GeomLib_CheckCurveOnSurface CT(C3d, S, first, last); - CT.Perform(C2d); + Handle(Adaptor2d_Curve2d) aGeom2dAdaptorCurve = new Geom2dAdaptor_Curve(C2d, first, last); + Handle(GeomAdaptor_Surface) aGeomAdaptorSurface = new GeomAdaptor_Surface(S); + + Handle(Adaptor3d_CurveOnSurface) anAdaptor3dCurveOnSurface = + new Adaptor3d_CurveOnSurface(aGeom2dAdaptorCurve, aGeomAdaptorSurface); + + GeomLib_CheckCurveOnSurface CT(aGeomAdaptorCurve); + CT.Perform(anAdaptor3dCurveOnSurface); if(CT.IsDone()) { newtol = CT.MaxDistance(); diff --git a/src/GeomLib/GeomLib_CheckCurveOnSurface.cxx b/src/GeomLib/GeomLib_CheckCurveOnSurface.cxx index 5693499324..c69d11aa1b 100644 --- a/src/GeomLib/GeomLib_CheckCurveOnSurface.cxx +++ b/src/GeomLib/GeomLib_CheckCurveOnSurface.cxx @@ -46,8 +46,8 @@ Standard_Boolean MinComputing( Standard_Real& theBestValue, Standard_Real& theBestParameter); -static Standard_Integer FillSubIntervals( const Handle(Geom_Curve)& theCurve3d, - const Handle(Geom2d_Curve)& theCurve2d, +static Standard_Integer FillSubIntervals( const Handle(Adaptor3d_Curve)& theCurve3d, + const Handle(Adaptor2d_Curve2d)& theCurve2d, const Standard_Real theFirst, const Standard_Real theLast, Standard_Integer &theNbParticles, @@ -61,12 +61,12 @@ class GeomLib_CheckCurveOnSurface_TargetFunc : public math_MultipleVarFunctionWithHessian { public: - GeomLib_CheckCurveOnSurface_TargetFunc( const Adaptor3d_Curve& theC3D, - const Adaptor3d_Curve& theAdCS, + GeomLib_CheckCurveOnSurface_TargetFunc(const Handle(Adaptor3d_Curve)& theC3D, + const Handle(Adaptor3d_Curve)& theCurveOnSurface, const Standard_Real theFirst, const Standard_Real theLast): myCurve1(theC3D), - myCurve2(theAdCS), + myCurve2(theCurveOnSurface), myFirst(theFirst), myLast(theLast) { @@ -96,8 +96,8 @@ class GeomLib_CheckCurveOnSurface_TargetFunc : if (!CheckParameter(theX)) return Standard_False; - const gp_Pnt aP1(myCurve1.Value(theX)), - aP2(myCurve2.Value(theX)); + const gp_Pnt aP1(myCurve1->Value(theX)), + aP2(myCurve2->Value(theX)); theFVal = -1.0*aP1.SquareDistance(aP2); } @@ -139,13 +139,13 @@ class GeomLib_CheckCurveOnSurface_TargetFunc : // if (!theDeriv2) { - myCurve1.D1(theX, aP1, aDC1); - myCurve2.D1(theX, aP2, aDC2); + myCurve1->D1(theX, aP1, aDC1); + myCurve2->D1(theX, aP2, aDC2); } else { - myCurve1.D2(theX, aP1, aDC1, aDCC1); - myCurve2.D2(theX, aP2, aDC2, aDCC2); + myCurve1->D2(theX, aP1, aDC1, aDCC1); + myCurve2->D2(theX, aP2, aDC2, aDCC2); } const gp_Vec aVec1(aP1, aP2), aVec2(aDC2-aDC1); @@ -223,8 +223,8 @@ class GeomLib_CheckCurveOnSurface_TargetFunc : return ((myFirst <= theParam) && (theParam <= myLast)); } - const Adaptor3d_Curve& myCurve1; - const Adaptor3d_Curve& myCurve2; + const Handle(Adaptor3d_Curve)& myCurve1; + const Handle(Adaptor3d_Curve)& myCurve2; const Standard_Real myFirst; const Standard_Real myLast; }; @@ -237,15 +237,13 @@ class GeomLib_CheckCurveOnSurface_Local { public: GeomLib_CheckCurveOnSurface_Local( - const Handle(Geom_Curve)& theCurve3D, - const Handle(Geom2d_Curve)& theCurve2D, - const Handle(Geom_Surface)& theSurface, + const Handle(Adaptor3d_Curve) theCurve3D, + const Handle(Adaptor3d_Curve)& theCurveOnSurface, const TColStd_Array1OfReal& theIntervalsArr, const Standard_Real theEpsilonRange, const Standard_Integer theNbParticles): myCurve3D(theCurve3D), - myCurve2D(theCurve2D), - mySurface(theSurface), + myCurveOnSurface(theCurveOnSurface), mySubIntervals(theIntervalsArr), myEpsilonRange(theEpsilonRange), myNbParticles(theNbParticles), @@ -253,6 +251,22 @@ public: myArrOfParam(theIntervalsArr.Lower(), theIntervalsArr.Upper()-1) { } + + GeomLib_CheckCurveOnSurface_Local( + const Handle(HArray1OfHCurve) theAdaptorArray, + const Handle(Adaptor3d_Curve)& theCurveOnSurface, + const TColStd_Array1OfReal& theIntervalsArr, + const Standard_Real theEpsilonRange, + const Standard_Integer theNbParticles) : + myAdaptorArray(theAdaptorArray), + myCurveOnSurface(theCurveOnSurface), + mySubIntervals(theIntervalsArr), + myEpsilonRange(theEpsilonRange), + myNbParticles(theNbParticles), + myArrOfDist(theIntervalsArr.Lower(), theIntervalsArr.Upper() - 1), + myArrOfParam(theIntervalsArr.Lower(), theIntervalsArr.Upper() - 1) + { + } void operator()(const Standard_Integer& theIndex) const { @@ -261,13 +275,7 @@ public: //This optimal value will be put in corresponding (depending on theIndex - the //identificator of the current interval in mySubIntervals array) cell of //myArrOfDist and myArrOfParam arrays. - const GeomAdaptor_Curve anAC(myCurve3D); - const Handle(Adaptor2d_Curve2d) anAd2dC = new Geom2dAdaptor_Curve(myCurve2D); - const Handle(Adaptor3d_Surface) anAdS = new GeomAdaptor_Surface(mySurface); - - const Adaptor3d_CurveOnSurface anACS(anAd2dC, anAdS); - - GeomLib_CheckCurveOnSurface_TargetFunc aFunc( anAC, anACS, + GeomLib_CheckCurveOnSurface_TargetFunc aFunc(myCurve3D, myCurveOnSurface, mySubIntervals.Value(theIndex), mySubIntervals.Value(theIndex+1)); @@ -283,6 +291,25 @@ public: myArrOfParam(theIndex) = aPar; } + void operator()(int theThreadIndex, int theElemIndex) const + { + GeomLib_CheckCurveOnSurface_TargetFunc aFunc(myAdaptorArray->Value(theThreadIndex), + myCurveOnSurface, + mySubIntervals.Value(theElemIndex), + mySubIntervals.Value(theElemIndex + 1)); + + Standard_Real aMinDist = RealLast(), aPar = 0.0; + if (!MinComputing(aFunc, myEpsilonRange, myNbParticles, aMinDist, aPar)) + { + myArrOfDist(theElemIndex) = RealLast(); + myArrOfParam(theElemIndex) = aFunc.FirstParameter(); + return; + } + + myArrOfDist(theElemIndex) = aMinDist; + myArrOfParam(theElemIndex) = aPar; + } + //Returns optimal value (inverse of square of maximal distance) void OptimalValues(Standard_Real& theMinimalValue, Standard_Real& theParameter) const { @@ -303,9 +330,9 @@ public: private: GeomLib_CheckCurveOnSurface_Local operator=(GeomLib_CheckCurveOnSurface_Local&); - const Handle(Geom_Curve)& myCurve3D; - const Handle(Geom2d_Curve)& myCurve2D; - const Handle(Geom_Surface)& mySurface; + const Handle(Adaptor3d_Curve) myCurve3D; + Handle(HArray1OfHCurve) myAdaptorArray; + const Handle(Adaptor3d_Curve)& myCurveOnSurface; const TColStd_Array1OfReal& mySubIntervals; const Standard_Real myEpsilonRange; @@ -320,8 +347,6 @@ private: //======================================================================= GeomLib_CheckCurveOnSurface::GeomLib_CheckCurveOnSurface() : - myFirst(0.), - myLast(0.), myErrorStatus(0), myMaxDistance(RealLast()), myMaxParameter(0.), @@ -334,15 +359,9 @@ GeomLib_CheckCurveOnSurface::GeomLib_CheckCurveOnSurface() //purpose : //======================================================================= GeomLib_CheckCurveOnSurface:: - GeomLib_CheckCurveOnSurface(const Handle(Geom_Curve)& theCurve, - const Handle(Geom_Surface)& theSurface, - const Standard_Real theFirst, - const Standard_Real theLast, + GeomLib_CheckCurveOnSurface(const Handle(Adaptor3d_Curve)& theCurve, const Standard_Real theTolRange): myCurve(theCurve), - mySurface(theSurface), - myFirst(theFirst), - myLast(theLast), myErrorStatus(0), myMaxDistance(RealLast()), myMaxParameter(0.), @@ -357,9 +376,6 @@ GeomLib_CheckCurveOnSurface:: void GeomLib_CheckCurveOnSurface::Init() { myCurve.Nullify(); - mySurface.Nullify(); - myFirst = 0.0; - myLast = 0.0; myErrorStatus = 0; myMaxDistance = RealLast(); myMaxParameter = 0.0; @@ -370,16 +386,10 @@ void GeomLib_CheckCurveOnSurface::Init() //function : Init //purpose : //======================================================================= -void GeomLib_CheckCurveOnSurface::Init( const Handle(Geom_Curve)& theCurve, - const Handle(Geom_Surface)& theSurface, - const Standard_Real theFirst, - const Standard_Real theLast, +void GeomLib_CheckCurveOnSurface::Init( const Handle(Adaptor3d_Curve)& theCurve, const Standard_Real theTolRange) { myCurve = theCurve; - mySurface = theSurface; - myFirst = theFirst; - myLast = theLast; myErrorStatus = 0; myMaxDistance = RealLast(); myMaxParameter = 0.0; @@ -390,26 +400,16 @@ void GeomLib_CheckCurveOnSurface::Init( const Handle(Geom_Curve)& theCurve, //function : Perform //purpose : //======================================================================= -void GeomLib_CheckCurveOnSurface::Perform(const Handle(Geom2d_Curve)& thePCurve, +void GeomLib_CheckCurveOnSurface::Perform(const Handle(Adaptor3d_CurveOnSurface)& theCurveOnSurface, const Standard_Boolean isMultiThread) { if( myCurve.IsNull() || - mySurface.IsNull() || - thePCurve.IsNull()) + theCurveOnSurface.IsNull()) { myErrorStatus = 1; return; } - if(((myCurve->FirstParameter() - myFirst) > myTolRange) || - ((myCurve->LastParameter() - myLast) < -myTolRange) || - ((thePCurve->FirstParameter() - myFirst) > myTolRange) || - ((thePCurve->LastParameter() - myLast) < -myTolRange)) - { - myErrorStatus = 2; - return; - } - const Standard_Real anEpsilonRange = 1.e-3; Standard_Integer aNbParticles = 3; @@ -422,8 +422,8 @@ void GeomLib_CheckCurveOnSurface::Perform(const Handle(Geom2d_Curve)& thePCurve, //number of particles should be equal to n. const Standard_Integer aNbSubIntervals = - FillSubIntervals( myCurve, thePCurve, - myFirst, myLast, aNbParticles); + FillSubIntervals( myCurve, theCurveOnSurface->GetCurve(), + myCurve->FirstParameter(), myCurve->LastParameter(), aNbParticles); if(!aNbSubIntervals) { @@ -435,14 +435,35 @@ void GeomLib_CheckCurveOnSurface::Perform(const Handle(Geom2d_Curve)& thePCurve, OCC_CATCH_SIGNALS TColStd_Array1OfReal anIntervals(1, aNbSubIntervals+1); - FillSubIntervals(myCurve, thePCurve, myFirst, myLast, aNbParticles, &anIntervals); - - GeomLib_CheckCurveOnSurface_Local aComp(myCurve, thePCurve, - mySurface, anIntervals, anEpsilonRange, aNbParticles); + FillSubIntervals(myCurve, theCurveOnSurface->GetCurve(), + myCurve->FirstParameter(), myCurve->LastParameter(), aNbParticles, &anIntervals); - OSD_Parallel::For(anIntervals.Lower(), anIntervals.Upper(), aComp, !isMultiThread); + if (isMultiThread) + { + const Handle(OSD_ThreadPool)& aThreadPool = OSD_ThreadPool::DefaultPool(); + const int aNbThreads = isMultiThread ? Min(anIntervals.Size(), aThreadPool->NbDefaultThreadsToLaunch()) : 1; + Handle(HArray1OfHCurve) anAdaptorArray = new HArray1OfHCurve(0, aNbThreads - 1); + for (Standard_Integer anI = 0; anI < aNbThreads; ++anI) + { + anAdaptorArray->SetValue(anI, myCurve->ShallowCopy()); + } + GeomLib_CheckCurveOnSurface_Local aComp(anAdaptorArray, theCurveOnSurface, anIntervals, + anEpsilonRange, aNbParticles); + OSD_ThreadPool::Launcher aLauncher(*aThreadPool, aNbThreads); + aLauncher.Perform(anIntervals.Lower(), anIntervals.Upper(), aComp); - aComp.OptimalValues(myMaxDistance, myMaxParameter); + aComp.OptimalValues(myMaxDistance, myMaxParameter); + } + else + { + GeomLib_CheckCurveOnSurface_Local aComp(myCurve, theCurveOnSurface, anIntervals, + anEpsilonRange, aNbParticles); + for (Standard_Integer anI = anIntervals.Lower(); anI < anIntervals.Upper(); ++anI) + { + aComp(anI); + } + aComp.OptimalValues(myMaxDistance, myMaxParameter); + } myMaxDistance = sqrt(Abs(myMaxDistance)); } @@ -458,8 +479,8 @@ void GeomLib_CheckCurveOnSurface::Perform(const Handle(Geom2d_Curve)& thePCurve, // (fills theSubIntervals array). // Returns number of subintervals. //======================================================================= -Standard_Integer FillSubIntervals(const Handle(Geom_Curve)& theCurve3d, - const Handle(Geom2d_Curve)& theCurve2d, +Standard_Integer FillSubIntervals(const Handle(Adaptor3d_Curve)& theCurve3d, + const Handle(Adaptor2d_Curve2d)& theCurve2d, const Standard_Real theFirst, const Standard_Real theLast, Standard_Integer &theNbParticles, @@ -475,28 +496,13 @@ Standard_Integer FillSubIntervals(const Handle(Geom_Curve)& theCurve3d, Standard_Boolean isTrimmed3D = Standard_False, isTrimmed2D = Standard_False; // - if (theCurve3d->IsKind(STANDARD_TYPE(Geom_TrimmedCurve))) - { - aBS3DCurv = Handle(Geom_BSplineCurve):: - DownCast(Handle(Geom_TrimmedCurve):: - DownCast(theCurve3d)->BasisCurve()); - isTrimmed3D = Standard_True; - } - else + if (theCurve3d->GetType() == GeomAbs_BSplineCurve) { - aBS3DCurv = Handle(Geom_BSplineCurve)::DownCast(theCurve3d); + aBS3DCurv = theCurve3d->BSpline(); } - - if (theCurve2d->IsKind(STANDARD_TYPE(Geom2d_TrimmedCurve))) - { - aBS2DCurv = Handle(Geom2d_BSplineCurve):: - DownCast(Handle(Geom2d_TrimmedCurve):: - DownCast(theCurve2d)->BasisCurve()); - isTrimmed2D = Standard_True; - } - else + if (theCurve2d->GetType() == GeomAbs_BSplineCurve) { - aBS2DCurv = Handle(Geom2d_BSplineCurve)::DownCast(theCurve2d); + aBS2DCurv = theCurve2d->BSpline(); } Handle(TColStd_HArray1OfReal) anArrKnots3D, anArrKnots2D; diff --git a/src/GeomLib/GeomLib_CheckCurveOnSurface.hxx b/src/GeomLib/GeomLib_CheckCurveOnSurface.hxx index 1e89a2191a..e291303ef4 100644 --- a/src/GeomLib/GeomLib_CheckCurveOnSurface.hxx +++ b/src/GeomLib/GeomLib_CheckCurveOnSurface.hxx @@ -15,10 +15,14 @@ #ifndef _GeomLib_CheckCurveOnSurface_HeaderFile #define _GeomLib_CheckCurveOnSurface_HeaderFile -#include +#include #include #include +#include +class GeomAdaptor_Curve; +class Adaptor2d_Curve2d; +class Adaptor3d_CurveOnSurface; class Geom_Surface; class Geom2d_Curve; @@ -35,18 +39,12 @@ public: //! Constructor Standard_EXPORT - GeomLib_CheckCurveOnSurface(const Handle(Geom_Curve)& theCurve, - const Handle(Geom_Surface)& theSurface, - const Standard_Real theFirst, - const Standard_Real theLast, + GeomLib_CheckCurveOnSurface(const Handle(Adaptor3d_Curve)& theCurve, const Standard_Real theTolRange = Precision::PConfusion()); //! Sets the data for the algorithm - Standard_EXPORT void Init (const Handle(Geom_Curve)& theCurve, - const Handle(Geom_Surface)& theSurface, - const Standard_Real theFirst, - const Standard_Real theLast, + Standard_EXPORT void Init (const Handle(Adaptor3d_Curve)& theCurve, const Standard_Real theTolRange = Precision::PConfusion()); //! Initializes all members by default values @@ -55,29 +53,9 @@ public: //! Computes the max distance for the 3d curve //! and 2d curve //! If isMultiThread == Standard_True then computation will be performed in parallel. - Standard_EXPORT void Perform(const Handle(Geom2d_Curve)& thePCurve, + Standard_EXPORT void Perform(const Handle(Adaptor3d_CurveOnSurface)& theCurveOnSurface, const Standard_Boolean isMultiThread = Standard_True); - //! Returns my3DCurve - const Handle(Geom_Curve)& Curve() const - { - return myCurve; - } - - //! Returns mySurface - const Handle(Geom_Surface)& Surface() const - { - return mySurface; - } - - //! Returns first and last parameter of the curves - //! (2D- and 3D-curves are considered to have same range) - void Range (Standard_Real& theFirst, Standard_Real& theLast) - { - theFirst = myFirst; - theLast = myLast; - } - //! Returns true if the max distance has been found Standard_Boolean IsDone() const { @@ -109,14 +87,12 @@ public: private: - Handle(Geom_Curve) myCurve; - Handle(Geom_Surface) mySurface; - Standard_Real myFirst; - Standard_Real myLast; + Handle(Adaptor3d_Curve) myCurve; Standard_Integer myErrorStatus; Standard_Real myMaxDistance; Standard_Real myMaxParameter; Standard_Real myTolRange; }; +typedef NCollection_Shared > HArray1OfHCurve; #endif // _BRepLib_CheckCurveOnSurface_HeaderFile diff --git a/src/IntTools/IntTools_Tools.cxx b/src/IntTools/IntTools_Tools.cxx index a50033b0a7..bf7b91e634 100644 --- a/src/IntTools/IntTools_Tools.cxx +++ b/src/IntTools/IntTools_Tools.cxx @@ -21,6 +21,7 @@ #include #include #include +#include #include #include #include @@ -797,8 +798,16 @@ Standard_Boolean IntTools_Tools::ComputeTolerance { GeomLib_CheckCurveOnSurface aCS; // - aCS.Init(theCurve3D, theSurf, theFirst, theLast, theTolRange); - aCS.Perform (theCurve2D, theToRunParallel); + const Handle(Adaptor3d_Curve) aGeomAdaptorCurve = new GeomAdaptor_Curve(theCurve3D, theFirst, theLast); + + Handle(Adaptor2d_Curve2d) aGeom2dAdaptorCurve = new Geom2dAdaptor_Curve(theCurve2D, theFirst, theLast); + Handle(GeomAdaptor_Surface) aGeomAdaptorSurface = new GeomAdaptor_Surface(theSurf); + + Handle(Adaptor3d_CurveOnSurface) anAdaptor3dCurveOnSurface = + new Adaptor3d_CurveOnSurface(aGeom2dAdaptorCurve, aGeomAdaptorSurface); + + aCS.Init(aGeomAdaptorCurve, theTolRange); + aCS.Perform(anAdaptor3dCurveOnSurface, theToRunParallel); if (!aCS.IsDone()) { return Standard_False; } -- 2.39.5