diff --git a/dox/upgrade/upgrade.md b/dox/upgrade/upgrade.md index d9e70e476b..58c8681e72 100644 --- a/dox/upgrade/upgrade.md +++ b/dox/upgrade/upgrade.md @@ -2264,17 +2264,6 @@ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1); BRepAlgoApi_Cut(S1, S2, aProgress->Start()); // method Start() creates range for usage in cut algorithm ~~~~ -@subsection upgrade_occt760_old_bop_removed Removal of old Boolean operations algorithm (BRepAlgo_BooleanOperation) - -* The method *BRepAlgo_Tool::Deboucle3D* has been removed as duplicating. The corresponding method from *BRepOffset_Tool* class has to be used instead. -* The API classes from *BRepAlgo* package performing old Boolean operations algorithm have been removed: - - *BRepAlgo_BooleanOperation* - - *BRepAlgo_Fuse* - - *BRepAlgo_Common* - - *BRepAlgo_Cut* - - *BRepAlgo_Section* - The corresponding classes from the *BRepAlgoAPI* package have to be used instead. - @subsection upgrade_occt760_change_check_to_adaptors Changes in BRepLib_CheckCurveOnSurface & GeomLib_CheckCurveOnSurface interfaces Now the classes accept adaptors instead objects as input parameters. @@ -2292,4 +2281,15 @@ void Init (const Handle(Adaptor3d_Curve)& theCurve, const Standard_Real theTolRa void Perform(const Handle(Adaptor3d_CurveOnSurface)& theCurveOnSurface, const Standard_Boolean isMultiThread); -~~~~ \ No newline at end of file +~~~~ + +@subsection upgrade_occt760_old_bop_removed Removal of old Boolean operations algorithm (BRepAlgo_BooleanOperation) + +* The method *BRepAlgo_Tool::Deboucle3D* has been removed as duplicating. The corresponding method from *BRepOffset_Tool* class has to be used instead. +* The API classes from *BRepAlgo* package performing old Boolean operations algorithm have been removed: + - *BRepAlgo_BooleanOperation* + - *BRepAlgo_Fuse* + - *BRepAlgo_Common* + - *BRepAlgo_Cut* + - *BRepAlgo_Section* + The corresponding classes from the *BRepAlgoAPI* package have to be used instead. diff --git a/src/BRepLib/BRepLib_CheckCurveOnSurface.cxx b/src/BRepLib/BRepLib_CheckCurveOnSurface.cxx index c9a3257c81..8f656f81d4 100644 --- a/src/BRepLib/BRepLib_CheckCurveOnSurface.cxx +++ b/src/BRepLib/BRepLib_CheckCurveOnSurface.cxx @@ -12,8 +12,12 @@ // 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 @@ -36,9 +40,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 +55,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 +92,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 +110,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..328493b48a 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_False); //! Returns true if the max distance has been found Standard_Boolean IsDone() const @@ -103,16 +72,16 @@ public: protected: //! Computes the max distance for the 3d curve of - //! and 2d curve + //! 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/BRepTools/BRepTools.cxx b/src/BRepTools/BRepTools.cxx index 99b3828d6f..7b75cc325b 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 @@ -1333,9 +1335,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..c736d458d8 100644 --- a/src/GeomLib/GeomLib_CheckCurveOnSurface.cxx +++ b/src/GeomLib/GeomLib_CheckCurveOnSurface.cxx @@ -36,6 +36,8 @@ #include #include +typedef NCollection_Array1 Array1OfHCurve; + class GeomLib_CheckCurveOnSurface_TargetFunc; static @@ -46,11 +48,11 @@ 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, + Standard_Integer& theNbParticles, TColStd_Array1OfReal* const theSubIntervals = 0); //======================================================================= @@ -62,11 +64,11 @@ class GeomLib_CheckCurveOnSurface_TargetFunc : { public: GeomLib_CheckCurveOnSurface_TargetFunc( const Adaptor3d_Curve& theC3D, - const Adaptor3d_Curve& theAdCS, + const Adaptor3d_Curve& theCurveOnSurface, const Standard_Real theFirst, const Standard_Real theLast): myCurve1(theC3D), - myCurve2(theAdCS), + myCurve2(theCurveOnSurface), myFirst(theFirst), myLast(theLast) { @@ -214,7 +216,7 @@ class GeomLib_CheckCurveOnSurface_TargetFunc : } private: - GeomLib_CheckCurveOnSurface_TargetFunc operator=(GeomLib_CheckCurveOnSurface_TargetFunc&); + GeomLib_CheckCurveOnSurface_TargetFunc operator=(GeomLib_CheckCurveOnSurface_TargetFunc&) Standard_DELETE; //checks if the function can be computed when its parameter is //equal to theParam @@ -237,50 +239,43 @@ class GeomLib_CheckCurveOnSurface_Local { public: GeomLib_CheckCurveOnSurface_Local( - const Handle(Geom_Curve)& theCurve3D, - const Handle(Geom2d_Curve)& theCurve2D, - const Handle(Geom_Surface)& theSurface, - const TColStd_Array1OfReal& theIntervalsArr, - const Standard_Real theEpsilonRange, - const Standard_Integer theNbParticles): - myCurve3D(theCurve3D), - myCurve2D(theCurve2D), - mySurface(theSurface), - mySubIntervals(theIntervalsArr), - myEpsilonRange(theEpsilonRange), - myNbParticles(theNbParticles), - myArrOfDist(theIntervalsArr.Lower(), theIntervalsArr.Upper()-1), - myArrOfParam(theIntervalsArr.Lower(), theIntervalsArr.Upper()-1) + const Array1OfHCurve& theCurveArray, + const Array1OfHCurve& theCurveOnSurfaceArray, + const TColStd_Array1OfReal& theIntervalsArr, + const Standard_Real theEpsilonRange, + const Standard_Integer theNbParticles): + myCurveArray(theCurveArray), + myCurveOnSurfaceArray(theCurveOnSurfaceArray), + 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 + void operator()(Standard_Integer theThreadIndex, Standard_Integer theElemIndex) const { //For every sub-interval (which is set by mySubIntervals array) this method //computes optimal value of GeomLib_CheckCurveOnSurface_TargetFunc function. //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, - mySubIntervals.Value(theIndex), - mySubIntervals.Value(theIndex+1)); + GeomLib_CheckCurveOnSurface_TargetFunc aFunc(*(myCurveArray.Value(theThreadIndex).get()), + *(myCurveOnSurfaceArray.Value(theThreadIndex).get()), + mySubIntervals.Value(theElemIndex), + mySubIntervals.Value(theElemIndex + 1)); Standard_Real aMinDist = RealLast(), aPar = 0.0; - if(!MinComputing(aFunc, myEpsilonRange, myNbParticles, aMinDist, aPar)) + if (!MinComputing(aFunc, myEpsilonRange, myNbParticles, aMinDist, aPar)) { - myArrOfDist(theIndex) = RealLast(); - myArrOfParam(theIndex) = aFunc.FirstParameter(); + myArrOfDist(theElemIndex) = RealLast(); + myArrOfParam(theElemIndex) = aFunc.FirstParameter(); return; } - myArrOfDist(theIndex) = aMinDist; - myArrOfParam(theIndex) = aPar; + myArrOfDist(theElemIndex) = aMinDist; + myArrOfParam(theElemIndex) = aPar; } //Returns optimal value (inverse of square of maximal distance) @@ -302,10 +297,11 @@ public: } private: - GeomLib_CheckCurveOnSurface_Local operator=(GeomLib_CheckCurveOnSurface_Local&); - const Handle(Geom_Curve)& myCurve3D; - const Handle(Geom2d_Curve)& myCurve2D; - const Handle(Geom_Surface)& mySurface; + GeomLib_CheckCurveOnSurface_Local operator=(const GeomLib_CheckCurveOnSurface_Local&) Standard_DELETE; + +private: + const Array1OfHCurve& myCurveArray; + const Array1OfHCurve& myCurveOnSurfaceArray; const TColStd_Array1OfReal& mySubIntervals; const Standard_Real myEpsilonRange; @@ -320,8 +316,6 @@ private: //======================================================================= GeomLib_CheckCurveOnSurface::GeomLib_CheckCurveOnSurface() : - myFirst(0.), - myLast(0.), myErrorStatus(0), myMaxDistance(RealLast()), myMaxParameter(0.), @@ -334,15 +328,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 +345,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 +355,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,21 +369,18 @@ 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)) + if ((myCurve->FirstParameter() - theCurveOnSurface->FirstParameter() > myTolRange) || + (myCurve->LastParameter() - theCurveOnSurface->LastParameter() < -myTolRange)) { myErrorStatus = 2; return; @@ -421,9 +397,9 @@ void GeomLib_CheckCurveOnSurface::Perform(const Handle(Geom2d_Curve)& thePCurve, //at least one particle in every monotonicity interval. Therefore, //number of particles should be equal to n. - const Standard_Integer aNbSubIntervals = - FillSubIntervals( myCurve, thePCurve, - myFirst, myLast, aNbParticles); + const Standard_Integer aNbSubIntervals = + FillSubIntervals(myCurve, theCurveOnSurface->GetCurve(), + myCurve->FirstParameter(), myCurve->LastParameter(), aNbParticles); if(!aNbSubIntervals) { @@ -431,22 +407,45 @@ void GeomLib_CheckCurveOnSurface::Perform(const Handle(Geom2d_Curve)& thePCurve, return; } - try { + try + { 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); - - OSD_Parallel::For(anIntervals.Lower(), anIntervals.Upper(), aComp, !isMultiThread); + TColStd_Array1OfReal anIntervals(1, aNbSubIntervals + 1); + FillSubIntervals(myCurve, theCurveOnSurface->GetCurve(), + myCurve->FirstParameter(), myCurve->LastParameter(), aNbParticles, &anIntervals); + const Standard_Integer aNbThreads = isMultiThread ? Min(anIntervals.Size(), OSD_ThreadPool::DefaultPool()->NbDefaultThreadsToLaunch()) : 1; + Array1OfHCurve aCurveArray(0, aNbThreads - 1); + Array1OfHCurve aCurveOnSurfaceArray(0, aNbThreads - 1); + for (Standard_Integer anI = 0; anI < aNbThreads; ++anI) + { + aCurveArray.SetValue(anI, aNbThreads > 1 ? myCurve->ShallowCopy() : myCurve); + aCurveOnSurfaceArray.SetValue(anI, aNbThreads > 1 + ? theCurveOnSurface->ShallowCopy() + : static_cast (theCurveOnSurface)); + } + GeomLib_CheckCurveOnSurface_Local aComp(aCurveArray, aCurveOnSurfaceArray, anIntervals, + anEpsilonRange, aNbParticles); + if (aNbThreads > 1) + { + const Handle(OSD_ThreadPool)& aThreadPool = OSD_ThreadPool::DefaultPool(); + OSD_ThreadPool::Launcher aLauncher(*aThreadPool, aNbThreads); + aLauncher.Perform(anIntervals.Lower(), anIntervals.Upper(), aComp); + } + else + { + for (Standard_Integer anI = anIntervals.Lower(); anI < anIntervals.Upper(); ++anI) + { + aComp(0, anI); + } + } aComp.OptimalValues(myMaxDistance, myMaxParameter); myMaxDistance = sqrt(Abs(myMaxDistance)); } - catch (Standard_Failure const&) { + catch (Standard_Failure const&) + { myErrorStatus = 3; } } @@ -458,11 +457,11 @@ 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, + Standard_Integer& theNbParticles, TColStd_Array1OfReal* const theSubIntervals) { const Standard_Integer aMaxKnots = 101; @@ -475,33 +474,18 @@ Standard_Integer FillSubIntervals(const Handle(Geom_Curve)& theCurve3d, Standard_Boolean isTrimmed3D = Standard_False, isTrimmed2D = Standard_False; // - if (theCurve3d->IsKind(STANDARD_TYPE(Geom_TrimmedCurve))) + if (theCurve3d->GetType() == GeomAbs_BSplineCurve) { - aBS3DCurv = Handle(Geom_BSplineCurve):: - DownCast(Handle(Geom_TrimmedCurve):: - DownCast(theCurve3d)->BasisCurve()); - isTrimmed3D = Standard_True; + aBS3DCurv = theCurve3d->BSpline(); } - else + if (theCurve2d->GetType() == GeomAbs_BSplineCurve) { - aBS3DCurv = Handle(Geom_BSplineCurve)::DownCast(theCurve3d); + aBS2DCurv = theCurve2d->BSpline(); } - if (theCurve2d->IsKind(STANDARD_TYPE(Geom2d_TrimmedCurve))) - { - aBS2DCurv = Handle(Geom2d_BSplineCurve):: - DownCast(Handle(Geom2d_TrimmedCurve):: - DownCast(theCurve2d)->BasisCurve()); - isTrimmed2D = Standard_True; - } - else - { - aBS2DCurv = Handle(Geom2d_BSplineCurve)::DownCast(theCurve2d); - } + Handle(TColStd_HArray1OfReal) anArrKnots3D, anArrKnots2D; - Handle(TColStd_HArray1OfReal) anArrKnots3D, anArrKnots2D; - - if(!aBS3DCurv.IsNull()) + if (!aBS3DCurv.IsNull()) { if(aBS3DCurv->NbKnots() <= aMaxKnots) { diff --git a/src/GeomLib/GeomLib_CheckCurveOnSurface.hxx b/src/GeomLib/GeomLib_CheckCurveOnSurface.hxx index 1e89a2191a..bc68342407 100644 --- a/src/GeomLib/GeomLib_CheckCurveOnSurface.hxx +++ b/src/GeomLib/GeomLib_CheckCurveOnSurface.hxx @@ -15,12 +15,11 @@ #ifndef _GeomLib_CheckCurveOnSurface_HeaderFile #define _GeomLib_CheckCurveOnSurface_HeaderFile -#include +#include #include #include -class Geom_Surface; -class Geom2d_Curve; +class Adaptor3d_CurveOnSurface; //! Computes the max distance between 3D-curve and 2D-curve //! in some surface. @@ -35,48 +34,22 @@ 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 Standard_EXPORT void Init(); //! Computes the max distance for the 3d curve - //! and 2d curve + //! and 2d curve //! If isMultiThread == Standard_True then computation will be performed in parallel. - Standard_EXPORT void Perform(const Handle(Geom2d_Curve)& thePCurve, - 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; - } + Standard_EXPORT void Perform(const Handle(Adaptor3d_CurveOnSurface)& theCurveOnSurface, + const Standard_Boolean isMultiThread = Standard_False); //! Returns true if the max distance has been found Standard_Boolean IsDone() const @@ -109,10 +82,7 @@ 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; 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; }