The method *TDF_Tool::Label()*, which returns a label by an entry, becomes faster for about 10 .. 20 times.
It has sense for applications, which use an entry as a unique key to access the data in OCAF tree.
Also, the method *TDF_Tool::Entry()*, which returns an entry for a label, is accelerated as well.
+
+@subsection upgrade_occt760_bop_progress_indicator Progress indicator in Boolean operations
+
+Method SetProgressIndicator() has been removed due to Progress indicator mechanism refactoring.
+To enable progress indicator and user break in Boolean operations user has to pass progress range as a parameter to Perform or Build method.
+For example:
+~~~~
+Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
+BRepAlgoApi_Cut(S1, S2, aProgress->Start()); // method Start() creates range for usage in cut algorithm
+~~~~
#include <TopoDS_AlertWithShape.hxx>
+//! Boolean operation was stopped by user
+DEFINE_SIMPLE_ALERT(BOPAlgo_AlertUserBreak)
+
//! Boolean operation of given type is not allowed on the given inputs
DEFINE_SIMPLE_ALERT(BOPAlgo_AlertBOPNotAllowed)
#include <BOPAlgo_Algo.hxx>
+#include <TColStd_MapOfInteger.hxx>
+
//=======================================================================
// function:
// purpose:
{
GetReport()->Clear(Message_Fail);
}
+
+//=======================================================================
+// function: analyzeProgress
+// purpose:
+//=======================================================================
+void BOPAlgo_Algo::analyzeProgress(const Standard_Real theWhole,
+ BOPAlgo_PISteps& theSteps) const
+{
+ Standard_Real aWhole = theWhole;
+
+ // Fill progress steps for constant operations
+ fillPIConstants(theWhole, theSteps);
+
+ TColStd_Array1OfReal& aSteps = theSteps.ChangeSteps();
+ TColStd_MapOfInteger aMIConst;
+ for (Standard_Integer i = aSteps.Lower(); i <= aSteps.Upper(); ++i)
+ {
+ if (aSteps(i) > 0.)
+ {
+ aMIConst.Add(i);
+ aWhole -= aSteps(i);
+ }
+ }
+
+ // Fill progress steps for other operations
+ fillPISteps(theSteps);
+
+ Standard_Real aSum = 0.;
+ for (Standard_Integer i = aSteps.Lower(); i <= aSteps.Upper(); ++i)
+ {
+ if (!aMIConst.Contains(i))
+ {
+ aSum += aSteps(i);
+ }
+ }
+
+ // Normalize steps
+ if (aSum > 0.)
+ {
+ for (Standard_Integer i = aSteps.Lower(); i <= aSteps.Upper(); ++i)
+ {
+ if (!aMIConst.Contains(i))
+ {
+ aSteps(i) = aWhole * aSteps(i) / aSum;
+ }
+ }
+ }
+}
+
+//=======================================================================
+// function: fillPIConstants
+// purpose:
+//=======================================================================
+void BOPAlgo_Algo::fillPIConstants (const Standard_Real, BOPAlgo_PISteps&) const
+{
+}
+
+//=======================================================================
+// function: fillPISteps
+// purpose:
+//=======================================================================
+void BOPAlgo_Algo::fillPISteps(BOPAlgo_PISteps&) const
+{
+}
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
+#include <Message_ProgressRange.hxx>
+#include <TColStd_Array1OfReal.hxx>
#include <BOPAlgo_Options.hxx>
+class BOPAlgo_PISteps;
+
//! The class provides the root interface for the algorithms in Boolean Component.<br>
class BOPAlgo_Algo : public BOPAlgo_Options
{
DEFINE_STANDARD_ALLOC
- Standard_EXPORT virtual void Perform() = 0;
+ //! The main method to implement the operation
+ //! Providing the range allows to enable Progress indicator User break functionalities.
+ Standard_EXPORT virtual void Perform(const Message_ProgressRange& theRange = Message_ProgressRange()) = 0;
protected:
//! Checks the obtained result
Standard_EXPORT virtual void CheckResult();
+protected: //! @name Analyzing operations to fill progress indicator
+
+ //! Analyze progress steps of the whole operation.
+ //! @param theWhole - sum of progress of all operations.
+ //! @oaram theSteps - steps of the operations supported by PI
+ //!
+ //! To use this method, one has to override the following methods:
+ //! * fillPIConstants - method filling values for constant operations.
+ //! * fillPISteps - method filling steps for the rest of operations.
+ Standard_EXPORT void analyzeProgress(const Standard_Real theWhole,
+ BOPAlgo_PISteps& theSteps) const;
+
+ //! Fills the values for constant operations - the operations having constant relative running time.
+ //! @param theWhole - sum of all operations supported by PI, i.e. the value to normalize the steps to, if necessary.
+ //! @param theSteps - steps of the operations supported by PI
+ Standard_EXPORT virtual void fillPIConstants(const Standard_Real theWhole,
+ BOPAlgo_PISteps& theSteps) const;
+
+ //! Fills the values for the operations dependent on the inputs.
+ //! Filled values may not be normalized to represent percentage of total running time.
+ //! The values should just correlate to each other.
+ //! E.g. if progress depends on the number of input shapes, the values may look like this:
+ //! step1 = number_of_input_vertices;
+ //! step2 = 2 * number_of_input_edges;
+ //! step3 = 10 * number_of_input_faces.
+ //! Normalization of these values will be done automatically in analyzeProgress() method.
+ Standard_EXPORT virtual void fillPISteps(BOPAlgo_PISteps& theSteps) const;
+};
+
+//! Additional root class to provide interface to be launched from parallel vector.
+//! It already has the range as a field, and has to be used with caution to create
+//! scope from the range only once.
+class BOPAlgo_ParallelAlgo : public BOPAlgo_Algo
+{
+public:
+ DEFINE_STANDARD_ALLOC
+
+ //! The main method to implement the operation
+ Standard_EXPORT virtual void Perform() = 0;
+
+public:
+ //! Sets the range for a single run
+ void SetProgressRange(const Message_ProgressRange& theRange)
+ {
+ myProgressRange = theRange;
+ }
+
+private:
+ //! Disable the range enabled method
+ virtual void Perform(const Message_ProgressRange& /*theRange*/ = Message_ProgressRange()) {};
+
+protected:
+ Message_ProgressRange myProgressRange;
+};
+
+//! Class for representing the relative contribution of each step of
+//! the operation to the whole progress
+class BOPAlgo_PISteps
+{
+public:
+ //! Constructor
+ BOPAlgo_PISteps(const Standard_Integer theNbOp)
+ : mySteps(0, theNbOp - 1)
+ {
+ mySteps.Init(0);
+ }
+
+ //! Returns the steps
+ const TColStd_Array1OfReal& Steps() const { return mySteps; }
+ //! Returns modifiable steps
+ TColStd_Array1OfReal& ChangeSteps() { return mySteps; }
+
+ //! Assign the value theStep to theOperation
+ void SetStep(const Standard_Integer theOperation, const Standard_Real theStep)
+ {
+ if (theOperation >= mySteps.Lower() && theOperation <= mySteps.Upper())
+ {
+ mySteps(theOperation) = theStep;
+ }
+ }
+
+ //! Returns the step assigned to the operation
+ Standard_Real GetStep(const Standard_Integer theOperation)
+ {
+ if (theOperation < mySteps.Lower() || theOperation > mySteps.Upper())
+ {
+ return 0.;
+ }
+ return mySteps(theOperation);
+ }
+
+protected:
+ TColStd_Array1OfReal mySteps;
};
#endif // _BOPAlgo_Algo_HeaderFile
// function: Perform
// purpose:
// ================================================================================
-void BOPAlgo_ArgumentAnalyzer::Perform()
+void BOPAlgo_ArgumentAnalyzer::Perform(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPS(theRange, "Analyze shapes", 10);
try {
OCC_CATCH_SIGNALS
myResult.Clear();
- //
- UserBreak();
- //
+ if (UserBreak(aPS))
+ {
+ return;
+ }
// 1. Prepare
Prepare();
//
- UserBreak();
- //
// 2. Test types
if(myArgumentTypeMode) {
TestTypes();
+ if (UserBreak(aPS))
+ {
+ return;
+ }
}
//
- UserBreak();
- //
// 3. Test self-interference
if(mySelfInterMode) {
- TestSelfInterferences();
+ TestSelfInterferences(aPS.Next(8));
+ if (UserBreak(aPS))
+ {
+ return;
+ }
}
//
- UserBreak();
- //
// 4. Test small edges
if(mySmallEdgeMode) {
if(!(!myResult.IsEmpty() && myStopOnFirst))
TestSmallEdge();
+ if (UserBreak(aPS))
+ {
+ return;
+ }
}
//
- UserBreak();
- //
// 5. Test possibility to rebuild faces
if(myRebuildFaceMode) {
if(!(!myResult.IsEmpty() && myStopOnFirst))
TestRebuildFace();
+ if (UserBreak(aPS))
+ {
+ return;
+ }
}
//
- UserBreak();
- //
// 6. Test tangent
if(myTangentMode) {
- if(!(!myResult.IsEmpty() && myStopOnFirst))
+ if (!(!myResult.IsEmpty() && myStopOnFirst))
+ {
TestTangent();
+ if (UserBreak(aPS))
+ {
+ return;
+ }
+ }
}
//
- UserBreak();
- //
// 7. Test merge vertices
if(myMergeVertexMode) {
if(!(!myResult.IsEmpty() && myStopOnFirst))
TestMergeVertex();
+ if (UserBreak(aPS))
+ {
+ return;
+ }
}
//
- UserBreak();
- //
// 8. Test merge edges
if(myMergeEdgeMode) {
if(!(!myResult.IsEmpty() && myStopOnFirst))
TestMergeEdge();
+ if (UserBreak(aPS))
+ {
+ return;
+ }
}
//
- UserBreak();
- //
// 9. Test shapes continuity
if(myContinuityMode) {
if(!(!myResult.IsEmpty() && myStopOnFirst))
TestContinuity();
+ if (UserBreak(aPS))
+ {
+ return;
+ }
}
//
- UserBreak();
- //
// 10. Test validity of the curves on the surfaces
if(myCurveOnSurfaceMode) {
if(!(!myResult.IsEmpty() && myStopOnFirst))
//function : TestSelfInterferences
//purpose :
//=======================================================================
-void BOPAlgo_ArgumentAnalyzer::TestSelfInterferences()
+void BOPAlgo_ArgumentAnalyzer::TestSelfInterferences(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPS(theRange, NULL, (!myShape1.IsNull() && !myShape2.IsNull() ? 2 : 1));
Standard_Integer ii;
//
for(ii = 0; ii < 2; ii++) {
aChecker.SetNonDestructive(Standard_True);
aChecker.SetRunParallel(myRunParallel);
aChecker.SetFuzzyValue(myFuzzyValue);
- aChecker.SetProgressIndicator(*myProgressScope);
//
- aChecker.Perform();
+ aChecker.Perform(aPS.Next());
Standard_Boolean hasError = aChecker.HasErrors();
//
const BOPDS_DS& aDS=*(aChecker.PDS());
Standard_Boolean& CurveOnSurfaceMode();
//! performs analysis
- Standard_EXPORT void Perform();
+ Standard_EXPORT void Perform(const Message_ProgressRange& theRange = Message_ProgressRange());
//! result of test
Standard_EXPORT Standard_Boolean HasFaulty() const;
Standard_EXPORT void TestTypes();
- Standard_EXPORT void TestSelfInterferences();
+ Standard_EXPORT void TestSelfInterferences(const Message_ProgressRange& theRange);
Standard_EXPORT void TestSmallEdge();
//function : Perform
//purpose :
//=======================================================================
-void BOPAlgo_BOP::Perform()
+void BOPAlgo_BOP::Perform(const Message_ProgressRange& theRange)
{
Handle(NCollection_BaseAllocator) aAllocator;
BOPAlgo_PaveFiller* pPF;
pPF=new BOPAlgo_PaveFiller(aAllocator);
pPF->SetArguments(aLS);
pPF->SetRunParallel(myRunParallel);
- if (myProgressScope != NULL)
- {
- pPF->SetProgressIndicator(*myProgressScope);
- }
+ Message_ProgressScope aPS(theRange, "Performing Boolean operation", 10);
+
pPF->SetFuzzyValue(myFuzzyValue);
pPF->SetNonDestructive(myNonDestructive);
pPF->SetGlue(myGlue);
pPF->SetUseOBB(myUseOBB);
//
- pPF->Perform();
+ pPF->Perform(aPS.Next(9));
//
myEntryPoint=1;
- PerformInternal(*pPF);
+ PerformInternal(*pPF, aPS.Next());
+}
+
+//=======================================================================
+// function: fillPIConstants
+// purpose:
+//=======================================================================
+void BOPAlgo_BOP::fillPIConstants (const Standard_Real theWhole, BOPAlgo_PISteps& theSteps) const
+{
+ BOPAlgo_Builder::fillPIConstants(theWhole, theSteps);
+ theSteps.SetStep (PIOperation_BuildShape, (myOperation == BOPAlgo_FUSE ? 10. : 5.) * theWhole / 100.);
}
+
//=======================================================================
//function : PerformInternal1
//purpose :
//=======================================================================
-void BOPAlgo_BOP::PerformInternal1(const BOPAlgo_PaveFiller& theFiller)
+void BOPAlgo_BOP::PerformInternal1(const BOPAlgo_PaveFiller& theFiller,
+ const Message_ProgressRange& theRange)
{
myPaveFiller=(BOPAlgo_PaveFiller*)&theFiller;
myDS=myPaveFiller->PDS();
{
Standard_Boolean bDone = TreatEmptyShape();
if (bDone) {
- PrepareHistory();
+ PrepareHistory (theRange);
return;
}
}
+ Message_ProgressScope aPS(theRange, "Building the result of Boolean operation", 100);
//
+ BOPAlgo_PISteps aSteps (PIOperation_Last);
+ analyzeProgress (100, aSteps);
+
// 3. Fill Images
// 3.1 Vertices
- FillImagesVertices();
+ FillImagesVertices(aPS.Next(aSteps.GetStep(PIOperation_TreatVertices)));
if (HasErrors()) {
return;
}
return;
}
// 3.2 Edges
- FillImagesEdges();
+ FillImagesEdges(aPS.Next(aSteps.GetStep(PIOperation_TreatEdges)));
if (HasErrors()) {
return;
}
}
//
// 3.3 Wires
- FillImagesContainers(TopAbs_WIRE);
+ FillImagesContainers(TopAbs_WIRE, aPS.Next(aSteps.GetStep(PIOperation_TreatWires)));
if (HasErrors()) {
return;
}
}
//
// 3.4 Faces
- FillImagesFaces();
+ FillImagesFaces(aPS.Next(aSteps.GetStep(PIOperation_TreatFaces)));
if (HasErrors()) {
return;
}
-
+
BuildResult(TopAbs_FACE);
if (HasErrors()) {
return;
}
//
// 3.5 Shells
- FillImagesContainers(TopAbs_SHELL);
+ FillImagesContainers(TopAbs_SHELL, aPS.Next(aSteps.GetStep(PIOperation_TreatShells)));
if (HasErrors()) {
return;
}
}
//
// 3.6 Solids
- FillImagesSolids();
+ FillImagesSolids(aPS.Next(aSteps.GetStep(PIOperation_TreatSolids)));
if (HasErrors()) {
return;
}
}
//
// 3.7 CompSolids
- FillImagesContainers(TopAbs_COMPSOLID);
+ FillImagesContainers(TopAbs_COMPSOLID, aPS.Next(aSteps.GetStep(PIOperation_TreatCompsolids)));
if (HasErrors()) {
return;
}
}
//
// 3.8 Compounds
- FillImagesCompounds();
+ FillImagesCompounds(aPS.Next(aSteps.GetStep(PIOperation_TreatCompounds)));
if (HasErrors()) {
return;
}
}
//
// 4.BuildShape;
- BuildShape();
+ BuildShape(aPS.Next(aSteps.GetStep(PIOperation_BuildShape)));
if (HasErrors()) {
return;
}
//
// 5.History
- PrepareHistory();
+ PrepareHistory(aPS.Next(aSteps.GetStep(PIOperation_FillHistory)));
+ if (HasErrors()) {
+ return;
+ }
//
// 6 Post-treatment
- PostTreat();
+ PostTreat(aPS.Next(aSteps.GetStep(PIOperation_PostTreat)));
}
//=======================================================================
//function : BuildRC
//purpose :
//=======================================================================
-void BOPAlgo_BOP::BuildRC()
+void BOPAlgo_BOP::BuildRC(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPS(theRange, NULL, 1);
+
TopAbs_ShapeEnum aType;
TopoDS_Compound aC;
BRep_Builder aBB;
return;
}
//
+ if (UserBreak(aPS))
+ {
+ return;
+ }
// B. Common, Cut, Cut21
//
Standard_Integer i, j, aNb, iDim;
}
}
//
+ if (UserBreak(aPS))
+ {
+ return;
+ }
+ //
bCheckEdges = Standard_False;
//
// get splits of building elements
return;
}
//
+ if (UserBreak(aPS))
+ {
+ return;
+ }
// The squats around degenerated edges
Standard_Integer nVD;
TopTools_IndexedMapOfShape aMVC;
//function : BuildShape
//purpose :
//=======================================================================
-void BOPAlgo_BOP::BuildShape()
+void BOPAlgo_BOP::BuildShape(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPS(theRange, NULL, 10.);
+
if (myDims[0] == 3 && myDims[1] == 3)
{
// For the Boolean operation on solids we need to check first
if (hasNotClosedSolids)
{
Handle(Message_Report) aReport = new Message_Report();
- BuildBOP(myArguments, myTools, myOperation, aReport);
+ BuildBOP(myArguments, myTools, myOperation, Message_ProgressRange(), aReport);
if (aReport->GetAlerts(Message_Fail).IsEmpty())
{
// Success. Merge the report into the main report.
}
// Build the result using splits of arguments.
-
- BuildRC();
+ BuildRC(aPS.Next(2.));
//
if ((myOperation == BOPAlgo_FUSE) && (myDims[0] == 3)) {
- BuildSolid();
+ BuildSolid(aPS.Next(8.));
+ return;
+ }
+
+ // Check for user break
+ if (UserBreak(aPS))
+ {
return;
}
//
CollectContainers(aS, aLSC);
}
}
+ // Check for user break
+ if (UserBreak(aPS))
+ {
+ return;
+ }
// make containers
TopTools_ListOfShape aLCRes;
TopTools_MapOfShape aMInpFence;
}
//
RemoveDuplicates(aLCRes);
+
+ // Check for user break
+ if (UserBreak(aPS))
+ {
+ return;
+ }
//
// add containers to result
TopoDS_Compound aResult;
//function : BuildSolid
//purpose :
//=======================================================================
-void BOPAlgo_BOP::BuildSolid()
+void BOPAlgo_BOP::BuildSolid(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPS(theRange, NULL, 10.);
// Containers
TopTools_ListOfShape aLSC;
//
CollectContainers(aSA, aLSC);
}
}
+ // Check for user break
+ if (UserBreak(aPS))
+ {
+ return;
+ }
//
// Find solids in input arguments sharing faces with other solids
TopTools_MapOfShape aMTSols;
}
}
}
+ // Check for user break
+ if (UserBreak(aPS))
+ {
+ return;
+ }
//
TopTools_IndexedDataMapOfShapeListOfShape aMEF;
// Fill the list of faces to build the result solids
aBS.SetContext(myContext);
aBS.SetShapes(aSFS);
aBS.SetAvoidInternalShapes (Standard_True);
- aBS.Perform();
+ aBS.Perform(aPS.Next(8.));
if (aBS.HasErrors()) {
AddError (new BOPAlgo_AlertSolidBuilderFailed); // SolidBuilder failed
return;
TopoDS_Shape aResult;
BOPTools_AlgoTools::MakeContainer(TopAbs_COMPOUND, aResult);
//
+
aIt.Initialize(aRC);
if (!aIt.More()) {
// no solids in the result
}
}
//
+ // Check for user break
+ if (UserBreak(aPS))
+ {
+ return;
+ }
// build connexity blocks from new solids
TopTools_ListOfShape aLCBS;
BOPTools_AlgoTools::MakeConnexityBlocks(aRC, TopAbs_FACE, TopAbs_SOLID, aLCBS);
Standard_EXPORT BOPAlgo_Operation Operation() const;
- Standard_EXPORT virtual void Perform() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Perform(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
protected:
//! Performs calculations using prepared Filler
//! object <thePF>
- Standard_EXPORT virtual void PerformInternal1 (const BOPAlgo_PaveFiller& thePF) Standard_OVERRIDE;
-
+ Standard_EXPORT virtual void PerformInternal1 (const BOPAlgo_PaveFiller& thePF,
+ const Message_ProgressRange& theRange) Standard_OVERRIDE;
+
Standard_EXPORT virtual void BuildResult (const TopAbs_ShapeEnum theType) Standard_OVERRIDE;
- Standard_EXPORT void BuildShape();
+ Standard_EXPORT void BuildShape(const Message_ProgressRange& theRange);
- Standard_EXPORT void BuildRC();
+ Standard_EXPORT void BuildRC(const Message_ProgressRange& theRange);
- Standard_EXPORT void BuildSolid();
+ Standard_EXPORT void BuildSolid(const Message_ProgressRange& theRange);
//! Treatment of the cases with empty shapes.<br>
//! It returns TRUE if there is nothing to do, i.e.
//! for building the result shape.
Standard_EXPORT virtual Standard_Boolean CheckArgsForOpenSolid();
+protected:
+
+ //! Extend list of operations to be supported by the Progress Indicator
+ enum BOPAlgo_PIOperation
+ {
+ PIOperation_BuildShape = BOPAlgo_ToolsProvider::PIOperation_Last,
+ PIOperation_Last
+ };
+
+ //! Fill PI steps
+ Standard_EXPORT virtual void fillPIConstants(const Standard_Real theWhole, BOPAlgo_PISteps& theSteps) const Standard_OVERRIDE;
+
protected:
BOPAlgo_Operation myOperation;
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopTools_MapOfOrientedShape.hxx>
-
//=======================================================================
//function :
//purpose :
//function : Perform
//purpose :
//=======================================================================
-void BOPAlgo_Builder::Perform()
+void BOPAlgo_Builder::Perform(const Message_ProgressRange& theRange)
{
GetReport()->Clear();
//
//
pPF->SetArguments(myArguments);
pPF->SetRunParallel(myRunParallel);
- if (myProgressScope != NULL)
- {
- pPF->SetProgressIndicator(*myProgressScope);
- }
+ Message_ProgressScope aPS(theRange, "Performing General Fuse operation", 10);
pPF->SetFuzzyValue(myFuzzyValue);
pPF->SetNonDestructive(myNonDestructive);
pPF->SetGlue(myGlue);
pPF->SetUseOBB(myUseOBB);
//
- pPF->Perform();
+ pPF->Perform(aPS.Next(9));
//
myEntryPoint=1;
- PerformInternal(*pPF);
+ PerformInternal(*pPF, aPS.Next(1));
}
//=======================================================================
//function : PerformWithFiller
//purpose :
//=======================================================================
-void BOPAlgo_Builder::PerformWithFiller(const BOPAlgo_PaveFiller& theFiller)
+void BOPAlgo_Builder::PerformWithFiller(const BOPAlgo_PaveFiller& theFiller, const Message_ProgressRange& theRange)
{
GetReport()->Clear();
myEntryPoint=0;
myFuzzyValue = theFiller.FuzzyValue();
myGlue = theFiller.Glue();
myUseOBB = theFiller.UseOBB();
- PerformInternal(theFiller);
+ PerformInternal(theFiller, theRange);
}
//=======================================================================
//function : PerformInternal
//purpose :
//=======================================================================
-void BOPAlgo_Builder::PerformInternal(const BOPAlgo_PaveFiller& theFiller)
+void BOPAlgo_Builder::PerformInternal(const BOPAlgo_PaveFiller& theFiller, const Message_ProgressRange& theRange)
{
GetReport()->Clear();
//
try {
OCC_CATCH_SIGNALS
- PerformInternal1(theFiller);
+ PerformInternal1(theFiller, theRange);
}
//
catch (Standard_Failure const&) {
AddError (new BOPAlgo_AlertBuilderFailed);
}
}
+
+//=======================================================================
+//function : getNbShapes
+//purpose :
+//=======================================================================
+BOPAlgo_Builder::NbShapes BOPAlgo_Builder::getNbShapes() const
+{
+ NbShapes aCounter;
+ aCounter.NbVertices() = myDS->ShapesSD().Size();
+ for (Standard_Integer i = 0; i < myDS->NbSourceShapes(); ++i)
+ {
+ const BOPDS_ShapeInfo& aSI = myDS->ShapeInfo(i);
+ switch (aSI.ShapeType())
+ {
+ case TopAbs_EDGE:
+ {
+ if (myDS->HasPaveBlocks(i))
+ {
+ aCounter.NbEdges()++;
+ }
+ break;
+ }
+ case TopAbs_WIRE:
+ aCounter.NbWires()++;
+ break;
+ case TopAbs_FACE:
+ {
+ if (myDS->HasFaceInfo(i))
+ {
+ aCounter.NbFaces()++;
+ }
+ break;
+ }
+ case TopAbs_SHELL:
+ aCounter.NbShells()++;
+ break;
+ case TopAbs_SOLID:
+ aCounter.NbSolids()++;
+ break;
+ case TopAbs_COMPSOLID:
+ aCounter.NbCompsolids()++;
+ break;
+ case TopAbs_COMPOUND:
+ aCounter.NbCompounds()++;
+ break;
+ default: break;
+ }
+ }
+ return aCounter;
+}
+
+//=======================================================================
+// function: fillPIConstants
+// purpose:
+//=======================================================================
+void BOPAlgo_Builder::fillPIConstants (const Standard_Real theWhole,
+ BOPAlgo_PISteps& theSteps) const
+{
+ // Fill in the constants:
+ if (myFillHistory)
+ {
+ // for FillHistroty, which takes about 5% of the whole operation
+ theSteps.SetStep(PIOperation_FillHistory, 0.05 * theWhole);
+ }
+
+ // and for PostTreat, which takes about 3% of the whole operation
+ theSteps.SetStep(PIOperation_PostTreat, 0.03 * theWhole);
+}
+
+//=======================================================================
+// function: fillPISteps
+// purpose:
+//=======================================================================
+void BOPAlgo_Builder::fillPISteps (BOPAlgo_PISteps& theSteps) const
+{
+ // Compute the rest of the operations - all depend on the number of sub-shapes of certain type
+ NbShapes aNbShapes = getNbShapes();
+
+ theSteps.SetStep(PIOperation_TreatVertices, aNbShapes.NbVertices());
+ theSteps.SetStep(PIOperation_TreatEdges, aNbShapes.NbEdges());
+ theSteps.SetStep(PIOperation_TreatWires, aNbShapes.NbWires());
+ theSteps.SetStep(PIOperation_TreatFaces, 20 * aNbShapes.NbFaces());
+ theSteps.SetStep(PIOperation_TreatShells, aNbShapes.NbShells());
+ theSteps.SetStep(PIOperation_TreatSolids, 50 * aNbShapes.NbSolids());
+ theSteps.SetStep(PIOperation_TreatCompsolids, aNbShapes.NbCompsolids());
+ theSteps.SetStep(PIOperation_TreatCompounds, aNbShapes.NbCompounds());
+}
+
//=======================================================================
//function : PerformInternal1
//purpose :
//=======================================================================
-void BOPAlgo_Builder::PerformInternal1(const BOPAlgo_PaveFiller& theFiller)
+void BOPAlgo_Builder::PerformInternal1(const BOPAlgo_PaveFiller& theFiller, const Message_ProgressRange& theRange)
{
myPaveFiller=(BOPAlgo_PaveFiller*)&theFiller;
myDS=myPaveFiller->PDS();
myFuzzyValue = myPaveFiller->FuzzyValue();
myNonDestructive = myPaveFiller->NonDestructive();
//
+ Message_ProgressScope aPS(theRange, "Building the result of General Fuse operation", 100);
// 1. CheckData
CheckData();
if (HasErrors()) {
return;
}
//
+ BOPAlgo_PISteps aSteps(PIOperation_Last);
+ analyzeProgress(100., aSteps);
// 3. Fill Images
// 3.1 Vertice
- FillImagesVertices();
+ FillImagesVertices(aPS.Next(aSteps.GetStep(PIOperation_TreatVertices)));
if (HasErrors()) {
return;
}
return;
}
// 3.2 Edges
- FillImagesEdges();
+ FillImagesEdges(aPS.Next(aSteps.GetStep(PIOperation_TreatEdges)));
if (HasErrors()) {
return;
}
}
//
// 3.3 Wires
- FillImagesContainers(TopAbs_WIRE);
+ FillImagesContainers(TopAbs_WIRE, aPS.Next(aSteps.GetStep(PIOperation_TreatWires)));
if (HasErrors()) {
return;
}
}
// 3.4 Faces
- FillImagesFaces();
+ FillImagesFaces(aPS.Next(aSteps.GetStep(PIOperation_TreatFaces)));
if (HasErrors()) {
return;
}
return;
}
// 3.5 Shells
- FillImagesContainers(TopAbs_SHELL);
+ FillImagesContainers(TopAbs_SHELL, aPS.Next(aSteps.GetStep(PIOperation_TreatShells)));
if (HasErrors()) {
return;
}
return;
}
// 3.6 Solids
- FillImagesSolids();
+ FillImagesSolids(aPS.Next(aSteps.GetStep(PIOperation_TreatSolids)));
if (HasErrors()) {
return;
}
return;
}
// 3.7 CompSolids
- FillImagesContainers(TopAbs_COMPSOLID);
+ FillImagesContainers(TopAbs_COMPSOLID, aPS.Next(aSteps.GetStep(PIOperation_TreatCompsolids)));
if (HasErrors()) {
return;
}
}
// 3.8 Compounds
- FillImagesCompounds();
+ FillImagesCompounds(aPS.Next(aSteps.GetStep(PIOperation_TreatCompounds)));
if (HasErrors()) {
return;
}
return;
}
//
- // 4.History
- PrepareHistory();
- //
+ // 4 History
+ PrepareHistory(aPS.Next(aSteps.GetStep(PIOperation_FillHistory)));
+ if (HasErrors()) {
+ return;
+ }
//
// 5 Post-treatment
- PostTreat();
-
+ PostTreat(aPS.Next(aSteps.GetStep(PIOperation_PostTreat)));
}
+
//=======================================================================
//function : PostTreat
//purpose :
//=======================================================================
-void BOPAlgo_Builder::PostTreat()
+void BOPAlgo_Builder::PostTreat(const Message_ProgressRange& theRange)
{
Standard_Integer i, aNbS;
TopAbs_ShapeEnum aType;
}
}
//
+ Message_ProgressScope aPS(theRange, "Post treatment of result shape", 2);
BOPTools_AlgoTools::CorrectTolerances(myShape, aMA, 0.05, myRunParallel);
+ aPS.Next();
BOPTools_AlgoTools::CorrectShapeTolerances(myShape, aMA, myRunParallel);
}
//function : BuildBOP
//purpose :
//=======================================================================
-void BOPAlgo_Builder::BuildBOP(const TopTools_ListOfShape& theObjects,
- const TopAbs_State theObjState,
- const TopTools_ListOfShape& theTools,
- const TopAbs_State theToolsState,
- Handle(Message_Report) theReport)
+void BOPAlgo_Builder::BuildBOP(const TopTools_ListOfShape& theObjects,
+ const TopAbs_State theObjState,
+ const TopTools_ListOfShape& theTools,
+ const TopAbs_State theToolsState,
+ const Message_ProgressRange& theRange,
+ Handle(Message_Report) theReport)
{
if (HasErrors())
return;
aReport->AddAlert(Message_Fail, new BOPAlgo_AlertBuilderFailed());
return;
}
-
// Check the input data
if ((theObjState != TopAbs_IN && theObjState != TopAbs_OUT) ||
(theToolsState != TopAbs_IN && theToolsState != TopAbs_OUT))
if (!aMFToAvoid.Contains(aRF))
aResFaces.Append(aRF);
}
-
+ Message_ProgressScope aPS(theRange, NULL, 2);
BRep_Builder aBB;
// Try to build closed solids from the faces
aBS.SetRunParallel(myRunParallel);
aBS.SetContext(myContext);
aBS.SetFuzzyValue(myFuzzyValue);
- if (myProgressScope != NULL)
- {
- aBS.SetProgressIndicator(*myProgressScope);
- }
- aBS.Perform();
+ aBS.Perform(aPS.Next());
// Resulting solids
TopTools_ListOfShape aResSolids;
}
}
}
+ else
+ {
+ return;
+ }
// Collect unused faces
TopoDS_Compound anUnUsedFaces;
aBB.Add(aResult, itLS.Value());
myShape = aResult;
- PrepareHistory();
+ PrepareHistory(aPS.Next());
}
//! Performs the operation.
//! The intersection will be performed also.
- Standard_EXPORT virtual void Perform() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Perform(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Performs the operation with the prepared filler.
//! The intersection will not be performed in this case.
- Standard_EXPORT virtual void PerformWithFiller (const BOPAlgo_PaveFiller& theFiller);
+ Standard_EXPORT virtual void PerformWithFiller (const BOPAlgo_PaveFiller& theFiller, const Message_ProgressRange& theRange = Message_ProgressRange());
public: //! @name BOPs on open solids
//! - BOPAlgo_AlertUnknownShape - the shape is unknown for the operation.
//!
//! Parameters:
- //! @param theObjects - The group of Objects for BOP;
- //! @param theObjState - State for objects faces to pass into result;
- //! @param theTools - The group of Tools for BOP;
- //! @param theObjState - State for tools faces to pass into result;
- //! @param theReport - The alternative report to avoid pollution of the main one.
- Standard_EXPORT virtual void BuildBOP(const TopTools_ListOfShape& theObjects,
- const TopAbs_State theObjState,
- const TopTools_ListOfShape& theTools,
- const TopAbs_State theToolsState,
- Handle(Message_Report) theReport = NULL);
+ //! @param theObjects - The group of Objects for BOP;
+ //! @param theObjState - State for objects faces to pass into result;
+ //! @param theTools - The group of Tools for BOP;
+ //! @param theToolsState - State for tools faces to pass into result;
+ //! @param theReport - The alternative report to avoid pollution of the main one.
+ Standard_EXPORT virtual void BuildBOP(const TopTools_ListOfShape& theObjects,
+ const TopAbs_State theObjState,
+ const TopTools_ListOfShape& theTools,
+ const TopAbs_State theToolsState,
+ const Message_ProgressRange& theRange,
+ Handle(Message_Report) theReport = NULL);
//! Builds the result of Boolean operation of given type
//! basing on the result of Builder operation (GF or any other).
//! @param theObjects - The group of Objects for BOP;
//! @param theTools - The group of Tools for BOP;
//! @param theOperation - The BOP type;
+ //! @param theRange - The parameter to progressIndicator
//! @param theReport - The alternative report to avoid pollution of the global one.
- void BuildBOP(const TopTools_ListOfShape& theObjects,
- const TopTools_ListOfShape& theTools,
- const BOPAlgo_Operation theOperation,
- Handle(Message_Report) theReport = NULL)
+ void BuildBOP(const TopTools_ListOfShape& theObjects,
+ const TopTools_ListOfShape& theTools,
+ const BOPAlgo_Operation theOperation,
+ const Message_ProgressRange& theRange,
+ Handle(Message_Report) theReport = NULL)
{
TopAbs_State anObjState, aToolsState;
switch (theOperation)
break;
}
}
- BuildBOP(theObjects, anObjState, theTools, aToolsState, theReport);
+ BuildBOP(theObjects, anObjState, theTools, aToolsState, theRange, theReport);
}
protected: //! @name History methods
//! Prepare information for history support.
- Standard_EXPORT void PrepareHistory();
+ Standard_EXPORT void PrepareHistory(const Message_ProgressRange& theRange);
//! Prepare history information for the input shapes taking into account possible
//! operation-specific modifications.
return myShapesSD;
}
+protected://! @name Analyze progress of the operation
+
+ //! List of operations to be supported by the Progress Indicator
+ enum BOPAlgo_PIOperation
+ {
+ PIOperation_TreatVertices = 0,
+ PIOperation_TreatEdges,
+ PIOperation_TreatWires,
+ PIOperation_TreatFaces,
+ PIOperation_TreatShells,
+ PIOperation_TreatSolids,
+ PIOperation_TreatCompsolids,
+ PIOperation_TreatCompounds,
+ PIOperation_FillHistory,
+ PIOperation_PostTreat,
+ PIOperation_Last
+ };
+
+
+ //! Auxiliary structure to get information about number of shapes
+ //! of each type participated in operation.
+ class NbShapes
+ {
+ public:
+ NbShapes()
+ {
+ for (Standard_Integer i = 0; i < 8; ++i)
+ {
+ myNbShapesArr[i] = 0;
+ }
+ }
+
+ Standard_Integer NbVertices() const { return myNbShapesArr[0]; }
+ Standard_Integer NbEdges() const { return myNbShapesArr[1]; }
+ Standard_Integer NbWires() const { return myNbShapesArr[2]; }
+ Standard_Integer NbFaces() const { return myNbShapesArr[3]; }
+ Standard_Integer NbShells() const { return myNbShapesArr[4]; }
+ Standard_Integer NbSolids() const { return myNbShapesArr[5]; }
+ Standard_Integer NbCompsolids() const { return myNbShapesArr[6]; }
+ Standard_Integer NbCompounds() const { return myNbShapesArr[7]; }
+
+ Standard_Integer& NbVertices() { return myNbShapesArr[0]; }
+ Standard_Integer& NbEdges() { return myNbShapesArr[1]; }
+ Standard_Integer& NbWires() { return myNbShapesArr[2]; }
+ Standard_Integer& NbFaces() { return myNbShapesArr[3]; }
+ Standard_Integer& NbShells() { return myNbShapesArr[4]; }
+ Standard_Integer& NbSolids() { return myNbShapesArr[5]; }
+ Standard_Integer& NbCompsolids() { return myNbShapesArr[6]; }
+ Standard_Integer& NbCompounds() { return myNbShapesArr[7]; }
+
+ private:
+ Standard_Integer myNbShapesArr[8];
+ };
+
+protected:
+
+ //! Compute number of shapes of certain type participating in operation
+ Standard_EXPORT NbShapes getNbShapes() const;
+
+ //! Filling steps for constant operations
+ Standard_EXPORT void fillPIConstants(const Standard_Real theWhole, BOPAlgo_PISteps& theSteps) const Standard_OVERRIDE;
+
+ //! Filling steps for all other operations
+ Standard_EXPORT void fillPISteps(BOPAlgo_PISteps& theSteps) const Standard_OVERRIDE;
protected: //! @name Methods for building the result
//! Performs the building of the result.
//! The method calls the PerformInternal1() method surrounded by a try-catch block.
- Standard_EXPORT virtual void PerformInternal (const BOPAlgo_PaveFiller& thePF);
+ Standard_EXPORT virtual void PerformInternal (const BOPAlgo_PaveFiller& thePF, const Message_ProgressRange& theRange);
//! Performs the building of the result.
//! To build the result of any other operation
//! it will be necessary to override this method.
- Standard_EXPORT virtual void PerformInternal1 (const BOPAlgo_PaveFiller& thePF);
+ Standard_EXPORT virtual void PerformInternal1 (const BOPAlgo_PaveFiller& thePF, const Message_ProgressRange& theRange);
//! Builds the result of operation.
//! The method is called for each of the arguments type and
protected: //! @name Fill Images of VERTICES
//! Fills the images of vertices.
- Standard_EXPORT void FillImagesVertices();
+ Standard_EXPORT void FillImagesVertices(const Message_ProgressRange& theRange);
protected: //! @name Fill Images of EDGES
//! Fills the images of edges.
- Standard_EXPORT void FillImagesEdges();
+ Standard_EXPORT void FillImagesEdges(const Message_ProgressRange& theRange);
protected: //! @name Fill Images of CONTAINERS
//! Fills the images of containers (WIRES/SHELLS/COMPSOLID).
- Standard_EXPORT void FillImagesContainers (const TopAbs_ShapeEnum theType);
+ Standard_EXPORT void FillImagesContainers (const TopAbs_ShapeEnum theType, const Message_ProgressRange& theRange);
//! Builds the image of the given container using the splits
//! of its sub-shapes.
//! 1. Build the splits of faces;
//! 2. Find SD faces;
//! 3. Add internal vertices (if any) to faces.
- Standard_EXPORT void FillImagesFaces();
+ Standard_EXPORT void FillImagesFaces(const Message_ProgressRange& theRange);
//! Builds the splits of faces using the information from the
//! intersection stage stored in Data Structure.
- Standard_EXPORT virtual void BuildSplitFaces();
+ Standard_EXPORT virtual void BuildSplitFaces(const Message_ProgressRange& theRange);
//! Looks for the same domain faces among the splits of the faces.
//! Updates the map of images with SD faces.
- Standard_EXPORT void FillSameDomainFaces();
+ Standard_EXPORT void FillSameDomainFaces(const Message_ProgressRange& theRange);
//! Classifies the alone vertices on faces relatively its splits
//! and adds them as INTERNAL into the splits.
- Standard_EXPORT void FillInternalVertices();
+ Standard_EXPORT void FillInternalVertices(const Message_ProgressRange& theRange);
protected: //! @name Fill Images of SOLIDS
//! 2. Find faces from other arguments located inside the solids;
//! 3. Build splits of solid using the inside faces;
//! 4. Fill internal shapes for the splits (Wires and vertices).
- Standard_EXPORT void FillImagesSolids();
+ Standard_EXPORT void FillImagesSolids(const Message_ProgressRange& theRange);
//! Builds the draft solid by rebuilding the shells of the solid
//! with the splits of faces.
TopTools_ListOfShape& theLIF);
//! Finds faces located inside each solid.
- Standard_EXPORT virtual void FillIn3DParts(TopTools_DataMapOfShapeShape& theDraftSolids);
+ Standard_EXPORT virtual void FillIn3DParts(TopTools_DataMapOfShapeShape& theDraftSolids,
+ const Message_ProgressRange& theRange);
//! Builds the splits of the solids using their draft versions
//! and faces located inside.
- Standard_EXPORT void BuildSplitSolids(TopTools_DataMapOfShapeShape& theDraftSolids);
+ Standard_EXPORT void BuildSplitSolids(TopTools_DataMapOfShapeShape& theDraftSolids,
+ const Message_ProgressRange& theRange);
//! Classifies the vertices and edges from the arguments relatively
//! splits of solids and makes them INTERNAL for solids.
- Standard_EXPORT void FillInternalShapes();
+ Standard_EXPORT void FillInternalShapes(const Message_ProgressRange& theRange);
protected: //! @name Fill Images of COMPOUNDS
//! Fills the images of compounds.
- Standard_EXPORT void FillImagesCompounds();
+ Standard_EXPORT void FillImagesCompounds(const Message_ProgressRange& theRange);
//! Builds the image of the given compound.
Standard_EXPORT void FillImagesCompound (const TopoDS_Shape& theS,
//! Post treatment of the result of the operation.
//! The method checks validity of the sub-shapes of the result
//! and updates the tolerances to make them valid.
- Standard_EXPORT virtual void PostTreat();
-
+ Standard_EXPORT virtual void PostTreat(const Message_ProgressRange& theRange);
protected: //! @name Fields
Standard_EXPORT BOPAlgo_BuilderArea(const Handle(NCollection_BaseAllocator)& theAllocator);
- virtual void PerformShapesToAvoid() = 0;
+ virtual void PerformShapesToAvoid(const Message_ProgressRange& theRange) = 0;
- virtual void PerformLoops() = 0;
+ virtual void PerformLoops(const Message_ProgressRange& theRange) = 0;
- virtual void PerformAreas() = 0;
+ virtual void PerformAreas(const Message_ProgressRange& theRange) = 0;
- virtual void PerformInternalShapes() = 0;
+ virtual void PerformInternalShapes(const Message_ProgressRange& theRange) = 0;
Handle(IntTools_Context) myContext;
//function : Perform
//purpose :
//=======================================================================
-void BOPAlgo_BuilderFace::Perform()
+void BOPAlgo_BuilderFace::Perform(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPS (theRange, NULL, 100);
+
GetReport()->Clear();
//
CheckData();
return;
}
//
- UserBreak();
- //
- PerformShapesToAvoid();
+ PerformShapesToAvoid (aPS.Next(1));
if (HasErrors()) {
return;
}
//
- UserBreak();
- //
- PerformLoops();
+ PerformLoops (aPS.Next(10));
if (HasErrors()) {
return;
}
//
- UserBreak();
- //
- PerformAreas();
+ PerformAreas (aPS.Next(80));
if (HasErrors()) {
return;
}
//
- UserBreak();
- //
- PerformInternalShapes();
- if (HasErrors()) {
- return;
- }
+ PerformInternalShapes(aPS.Next(9));
}
//=======================================================================
//function :PerformShapesToAvoid
//purpose :
//=======================================================================
-void BOPAlgo_BuilderFace::PerformShapesToAvoid()
+void BOPAlgo_BuilderFace::PerformShapesToAvoid(const Message_ProgressRange& theRange)
{
Standard_Boolean bFound;
Standard_Integer i, iCnt, aNbV, aNbE;
//
myShapesToAvoid.Clear();
//
+ Message_ProgressScope aPS(theRange, NULL, 1);
+ //
iCnt=0;
for(;;) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
+
++iCnt;
bFound=Standard_False;
//
if (!bFound) {
break;
}
- //
- }//while (1)
- //printf(" EdgesToAvoid=%d, iCnt=%d\n", EdgesToAvoid.Extent(), iCnt);
+ }
}
//=======================================================================
//function : PerformLoops
//purpose :
//=======================================================================
-void BOPAlgo_BuilderFace::PerformLoops()
+void BOPAlgo_BuilderFace::PerformLoops(const Message_ProgressRange& theRange)
{
Standard_Boolean bFlag;
Standard_Integer i, aNbEA;
BOPAlgo_WireEdgeSet aWES(myAllocator);
BOPAlgo_WireSplitter aWSp(myAllocator);
//
+ Message_ProgressScope aMainScope(theRange, "Making wires", 10);
+ //
// 1.
myLoops.Clear();
aWES.SetFace(myFace);
aWSp.SetWES(aWES);
aWSp.SetRunParallel(myRunParallel);
aWSp.SetContext(myContext);
- aWSp.Perform();
+ aWSp.Perform(aMainScope.Next(9));
if (aWSp.HasErrors()) {
return;
}
aMEP.Add(aE);
}
}
+ if (UserBreak (aMainScope)) {
+ return;
+ }
//
// b. collect all edges that are to avoid
aNbEA = myShapesToAvoid.Extent();
}
}
//
+ if (UserBreak (aMainScope)) {
+ return;
+ }
// 2. Internal Wires
myLoopsInternal.Clear();
//
aNbEA = myShapesToAvoid.Extent();
for (i = 1; i <= aNbEA; ++i) {
const TopoDS_Shape& aEE = myShapesToAvoid(i);
- TopExp::MapShapesAndAncestors(aEE,
- TopAbs_VERTEX,
- TopAbs_EDGE,
- aVEMap);
+ TopExp::MapShapesAndAncestors(aEE,
+ TopAbs_VERTEX,
+ TopAbs_EDGE,
+ aVEMap);
}
//
bFlag=Standard_True;
continue;
}
//
+ if (UserBreak (aMainScope)) {
+ return;
+ }
// make new wire
TopoDS_Wire aW;
aBB.MakeWire(aW);
//function : PerformAreas
//purpose :
//=======================================================================
-void BOPAlgo_BuilderFace::PerformAreas()
+void BOPAlgo_BuilderFace::PerformAreas(const Message_ProgressRange& theRange)
{
myAreas.Clear();
BRep_Builder aBB;
// Get tolerance of myFace
Standard_Real aTol = BRep_Tool::Tolerance(myFace);
+ Message_ProgressScope aMainScope (theRange, NULL, 10);
+
// Check if there are no loops at all
if (myLoops.IsEmpty())
{
TopTools_IndexedMapOfShape aMHE;
// Analyze the new wires - classify them to be the holes and growths
+ Message_ProgressScope aPSClass(aMainScope.Next(5), "Making faces", myLoops.Size());
TopTools_ListIteratorOfListOfShape aItLL(myLoops);
- for (; aItLL.More(); aItLL.Next())
+ for (; aItLL.More(); aItLL.Next(), aPSClass.Next())
{
+ if (UserBreak(aPSClass))
+ {
+ return;
+ }
+
const TopoDS_Shape& aWire = aItLL.Value();
TopoDS_Face aFace;
BOPTools_Box2dTreeSelector aSelector;
aSelector.SetBVHSet (&aBoxTree);
+ Message_ProgressScope aPSHoles(aMainScope.Next(4), "Adding holes", aNewFaces.Extent());
TopTools_ListIteratorOfListOfShape aItLS(aNewFaces);
- for (; aItLS.More(); aItLS.Next())
+ for (; aItLS.More(); aItLS.Next(), aPSHoles.Next())
{
+ if (UserBreak (aPSHoles))
+ {
+ return;
+ }
const TopoDS_Face& aFace = TopoDS::Face(aItLS.Value());
// Build box
}
// Add Holes to Faces and add them to myAreas
+ Message_ProgressScope aPSU (aMainScope.Next(), NULL, aNewFaces.Size());
aItLS.Initialize(aNewFaces);
- for ( ; aItLS.More(); aItLS.Next())
+ for ( ; aItLS.More(); aItLS.Next(), aPSU.Next())
{
+ if (UserBreak (aPSU))
+ {
+ return;
+ }
+
TopoDS_Face& aFace = *(TopoDS_Face*)&aItLS.Value();
const TopTools_ListOfShape* pLHoles = aFaceHolesMap.Seek(aFace);
if (pLHoles)
//function : PerformInternalShapes
//purpose :
//=======================================================================
-void BOPAlgo_BuilderFace::PerformInternalShapes()
+void BOPAlgo_BuilderFace::PerformInternalShapes(const Message_ProgressRange& theRange)
{
if (myAvoidInternalShapes)
// User-defined option to avoid internal edges
// Map of edges to classify
TopTools_IndexedMapOfShape anEdgesMap;
+ // Main progress scope
+ Message_ProgressScope aMainScope (theRange, "Adding internal shapes", 3);
+
// Fill the tree and the map
TopTools_ListIteratorOfListOfShape itLE(myLoopsInternal);
for (; itLE.More(); itLE.Next())
{
+ if (UserBreak (aMainScope))
+ {
+ return;
+ }
TopoDS_Iterator itE(itLE.Value());
for (; itE.More(); itE.Next())
{
// Build BVH
aBoxTree.Build();
+ aMainScope.Next();
+
// Fence map
TColStd_MapOfInteger aMEDone;
// Classify edges relatively faces
+ Message_ProgressScope aPSClass(aMainScope.Next(), NULL, myAreas.Size());
TopTools_ListIteratorOfListOfShape itLF(myAreas);
- for (; itLF.More(); itLF.Next())
+ for (; itLF.More(); itLF.Next(), aPSClass.Next())
{
+ if (UserBreak(aPSClass))
+ {
+ return;
+ }
TopoDS_Face& aF = *(TopoDS_Face*)&itLF.Value();
// Build box
Standard_EXPORT const TopoDS_Face& Face() const;
//! Performs the algorithm
- Standard_EXPORT virtual void Perform() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Perform(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
Standard_EXPORT TopAbs_Orientation Orientation() const;
//! Collect the edges that
//! a) are internal
//! b) are the same and have different orientation
- Standard_EXPORT virtual void PerformShapesToAvoid() Standard_OVERRIDE;
+ Standard_EXPORT virtual void PerformShapesToAvoid(const Message_ProgressRange& theRange) Standard_OVERRIDE;
//! Build draft wires
//! a)myLoops - draft wires that consist of
//! boundary edges
//! b)myLoopsInternal - draft wires that contains
//! inner edges
- Standard_EXPORT virtual void PerformLoops() Standard_OVERRIDE;
+ Standard_EXPORT virtual void PerformLoops(const Message_ProgressRange& theRange) Standard_OVERRIDE;
//! Build draft faces that contains boundary edges
- Standard_EXPORT virtual void PerformAreas() Standard_OVERRIDE;
+ Standard_EXPORT virtual void PerformAreas(const Message_ProgressRange& theRange) Standard_OVERRIDE;
//! Build finalized faces with internals
- Standard_EXPORT virtual void PerformInternalShapes() Standard_OVERRIDE;
+ Standard_EXPORT virtual void PerformInternalShapes(const Message_ProgressRange& theRange) Standard_OVERRIDE;
Standard_EXPORT virtual void CheckData() Standard_OVERRIDE;
+protected:
TopoDS_Face myFace;
TopAbs_Orientation myOrientation;
-
-
-private:
-
-
-
-
-
};
-
-
-
-
-
-
#endif // _BOPAlgo_BuilderFace_HeaderFile
//function : Perform
//purpose :
//=======================================================================
-void BOPAlgo_BuilderSolid::Perform()
+void BOPAlgo_BuilderSolid::Perform(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPS (theRange, NULL, 100);
+
GetReport()->Clear();
//
if (myShapes.IsEmpty())
aBB.Add(aC, aF);
}
//
- UserBreak();
- //
- PerformShapesToAvoid();
+ PerformShapesToAvoid (aPS.Next(1));
if (HasErrors()) {
return;
}
//
- UserBreak();
- //
- PerformLoops();
+ PerformLoops (aPS.Next(10));
if (HasErrors()) {
return;
}
//
- UserBreak();
- //
- PerformAreas();
+ PerformAreas (aPS.Next(80));
if (HasErrors()) {
return;
}
//
- UserBreak();
- //
- PerformInternalShapes();
- if (HasErrors()) {
- return;
- }
+ PerformInternalShapes (aPS.Next(9));
}
//=======================================================================
//function :PerformShapesToAvoid
//purpose :
//=======================================================================
-void BOPAlgo_BuilderSolid::PerformShapesToAvoid()
+void BOPAlgo_BuilderSolid::PerformShapesToAvoid(const Message_ProgressRange& theRange)
{
Standard_Boolean bFound;
Standard_Integer i, iCnt, aNbE, aNbF;
//
myShapesToAvoid.Clear();
//
+ Message_ProgressScope aPS(theRange, NULL, 1);
+ //
iCnt=0;
for(;;) {
+ if (UserBreak(aPS)) {
+ return;
+ }
++iCnt;
bFound=Standard_False;
//
//function : PerformLoops
//purpose :
//=======================================================================
-void BOPAlgo_BuilderSolid::PerformLoops()
+void BOPAlgo_BuilderSolid::PerformLoops(const Message_ProgressRange& theRange)
{
Standard_Integer i, aNbSh;
TopTools_ListIteratorOfListOfShape aIt;
NCollection_BaseAllocator::CommonBaseAllocator();
BOPAlgo_ShellSplitter aSSp(aAlr);
//
- // 1. Shells Usual
+ Message_ProgressScope aMainScope (theRange, "Building shells", 10);
+
+ // 1. Shells Usual
aIt.Initialize (myShapes);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Face& aF=*((TopoDS_Face*)&aIt.Value());
}
//
aSSp.SetRunParallel(myRunParallel);
- aSSp.Perform();
+ aSSp.Perform(aMainScope.Next(9));
if (aSSp.HasErrors()) {
// add warning status
+ if (aMainScope.More())
{
TopoDS_Compound aFacesSp;
BRep_Builder().MakeCompound(aFacesSp);
aMP.Add(aF);
}
}
+ if (UserBreak (aMainScope)) {
+ return;
+ }
//
// b. collect all edges that are to avoid
aNbSh = myShapesToAvoid.Extent();
}
}
//=================================================
+ if (UserBreak (aMainScope)) {
+ return;
+ }
//
// 3.Internal Shells
myLoopsInternal.Clear();
}
//
for (i = 1; i <= aNbSh; ++i) {
+ if (UserBreak(aMainScope)) {
+ return;
+ }
const TopoDS_Shape& aFF = myShapesToAvoid(i);
if (!AddedFacesMap.Add(aFF)) {
continue;
//function : PerformAreas
//purpose :
//=======================================================================
-void BOPAlgo_BuilderSolid::PerformAreas()
+void BOPAlgo_BuilderSolid::PerformAreas(const Message_ProgressRange& theRange)
{
myAreas.Clear();
BRep_Builder aBB;
// If the analyzed shell contains any of the hole faces, it is considered as growth.
TopTools_IndexedMapOfShape aMHF;
+ Message_ProgressScope aMainScope(theRange, "Building solids", 10);
+
// Analyze the shells
+ Message_ProgressScope aPSClass(aMainScope.Next(5), "Classify solids", myLoops.Size());
TopTools_ListIteratorOfListOfShape aItLL(myLoops);
- for (; aItLL.More(); aItLL.Next())
+ for (; aItLL.More(); aItLL.Next(), aPSClass.Next())
{
+ if (UserBreak (aPSClass))
+ {
+ return;
+ }
const TopoDS_Shape& aShell = aItLL.Value();
Standard_Boolean bIsGrowth = IsGrowthShell(aShell, aMHF);
// Find outer growth shell that is most close to each hole shell
TopTools_IndexedDataMapOfShapeShape aHoleSolidMap;
+ Message_ProgressScope aPSH(aMainScope.Next(4), "Adding holes", aNewSolids.Size());
TopTools_ListIteratorOfListOfShape aItLS(aNewSolids);
- for (; aItLS.More(); aItLS.Next())
+ for (; aItLS.More(); aItLS.Next(), aPSH.Next())
{
+ if (UserBreak (aPSH))
+ {
+ return;
+ }
const TopoDS_Shape& aSolid = aItLS.Value();
// Build box
}
// Add Holes to Solids and add them to myAreas
+ Message_ProgressScope aPSU (aMainScope.Next(), NULL, aNewSolids.Size());
aItLS.Initialize(aNewSolids);
- for ( ; aItLS.More(); aItLS.Next())
+ for ( ; aItLS.More(); aItLS.Next(), aPSU.Next())
{
+ if (UserBreak (aPSU))
+ {
+ return;
+ }
TopoDS_Solid& aSolid = *(TopoDS_Solid*)&aItLS.Value();
const TopTools_ListOfShape* pLHoles = aSolidHolesMap.Seek(aSolid);
if (pLHoles)
//function : PerformInternalShapes
//purpose :
//=======================================================================
-void BOPAlgo_BuilderSolid::PerformInternalShapes()
+void BOPAlgo_BuilderSolid::PerformInternalShapes(const Message_ProgressRange& theRange)
{
if (myAvoidInternalShapes)
// user-defined option to avoid internal parts is in force
// no internal parts
return;
+ Message_ProgressScope aMainScope (theRange, "Adding internal shapes", 2);
+
// Get all faces to classify
TopTools_IndexedMapOfShape aMFs;
TopTools_ListIteratorOfListOfShape aItLS(myLoopsInternal);
return;
}
+ if (UserBreak (aMainScope))
+ {
+ return;
+ }
+
// Classify faces relatively solids
// Prepare list of faces to classify
TopTools_IndexedDataMapOfShapeListOfShape aMSLF;
// Perform classification
- BOPAlgo_Tools::ClassifyFaces(aLFaces, myAreas, myRunParallel, myContext, aMSLF, myBoxes);
+ BOPAlgo_Tools::ClassifyFaces(aLFaces,
+ myAreas,
+ myRunParallel,
+ myContext,
+ aMSLF,
+ myBoxes,
+ TopTools_DataMapOfShapeListOfShape(),
+ aMainScope.Next());
// Update Solids by internal Faces
TopTools_MapOfShape aMFDone;
Standard_Integer aNbS = aMSLF.Extent();
- for (i = 1; i <= aNbS; ++i)
+ Message_ProgressScope aPSLoop(aMainScope.Next(), NULL, aNbS);
+ for (i = 1; i <= aNbS; ++i, aPSLoop.Next())
{
+ if (UserBreak (aPSLoop))
+ {
+ return;
+ }
const TopoDS_Shape& aSolid = aMSLF.FindKey(i);
TopoDS_Shape *pSolid = (TopoDS_Shape*)&aSolid;
public: //! @name Performing the operation
//! Performs the construction of the solids from the given faces
- Standard_EXPORT virtual void Perform() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Perform(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
public: //! @name Getting the bounding boxes of the created solids
//! - that are alone but given twice with different orientation.
//! These faces will be put into the map *myShapesToAvoid* and will be
//! avoided in shells construction, but will be classified later on.
- Standard_EXPORT virtual void PerformShapesToAvoid() Standard_OVERRIDE;
+ Standard_EXPORT virtual void PerformShapesToAvoid(const Message_ProgressRange& theRange) Standard_OVERRIDE;
//! Build all possible closed shells from the given faces.
//! The method fills the following maps:
//! - myLoops - Created closed shells;
//! - myLoopsInternal - The shells created from unused faces.
- Standard_EXPORT virtual void PerformLoops() Standard_OVERRIDE;
+ Standard_EXPORT virtual void PerformLoops(const Message_ProgressRange& theRange) Standard_OVERRIDE;
//! Classifies the created shells on the Holes and Growths.
//! Creates the solids from the Growths shells.
//! Puts the Hole shells into the closest Growths solids.
- Standard_EXPORT virtual void PerformAreas() Standard_OVERRIDE;
+ Standard_EXPORT virtual void PerformAreas(const Message_ProgressRange& theRange) Standard_OVERRIDE;
//! Classifies the unused faces relatively the created solids.
//! Puts the classified faces into the closest solids as internal shells.
//! Warns the user about unclassified faces if any.
- Standard_EXPORT virtual void PerformInternalShapes() Standard_OVERRIDE;
+ Standard_EXPORT virtual void PerformInternalShapes(const Message_ProgressRange& theRange) Standard_OVERRIDE;
private:
//function : FillImagesVertices
//purpose :
//=======================================================================
-void BOPAlgo_Builder::FillImagesVertices()
+void BOPAlgo_Builder::FillImagesVertices(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPS(theRange, "Filling splits of vertices", myDS->ShapesSD().Size());
TColStd_DataMapIteratorOfDataMapOfIntegerInteger aIt(myDS->ShapesSD());
- for (; aIt.More(); aIt.Next())
+ for (; aIt.More(); aIt.Next(), aPS.Next())
{
+ if (UserBreak(aPS))
+ {
+ return;
+ }
Standard_Integer nV = aIt.Key();
Standard_Integer nVSD = aIt.Value();
//function : FillImagesEdges
//purpose :
//=======================================================================
- void BOPAlgo_Builder::FillImagesEdges()
+ void BOPAlgo_Builder::FillImagesEdges(const Message_ProgressRange& theRange)
{
Standard_Integer i, aNbS = myDS->NbSourceShapes();
- for (i = 0; i < aNbS; ++i) {
+ Message_ProgressScope aPS(theRange, "Filling splits of edges", aNbS);
+ for (i = 0; i < aNbS; ++i, aPS.Next()) {
const BOPDS_ShapeInfo& aSI = myDS->ShapeInfo(i);
if (aSI.ShapeType() != TopAbs_EDGE) {
continue;
myShapesSD.Bind(aSp, aSpR);
}
}
+ if (UserBreak(aPS))
+ {
+ return;
+ }
}
}
//=======================================================================
// function: FillImagesContainers
// purpose:
//=======================================================================
- void BOPAlgo_Builder::FillImagesContainers(const TopAbs_ShapeEnum theType)
+ void BOPAlgo_Builder::FillImagesContainers(const TopAbs_ShapeEnum theType, const Message_ProgressRange& theRange)
{
Standard_Integer i, aNbS;
TopTools_MapOfShape aMFP(100, myAllocator);
//
aNbS=myDS->NbSourceShapes();
+ Message_ProgressScope aPS(theRange, "Building splits of containers", 1);
for (i=0; i<aNbS; ++i) {
const BOPDS_ShapeInfo& aSI=myDS->ShapeInfo(i);
if (aSI.ShapeType()==theType) {
const TopoDS_Shape& aC=aSI.Shape();
FillImagesContainer(aC, theType);
}
+ if (UserBreak(aPS))
+ {
+ return;
+ }
}// for (; aItS.More(); aItS.Next()) {
}
//=======================================================================
// function: FillImagesCompounds
// purpose:
//=======================================================================
- void BOPAlgo_Builder::FillImagesCompounds()
+ void BOPAlgo_Builder::FillImagesCompounds(const Message_ProgressRange& theRange)
{
Standard_Integer i, aNbS;
TopTools_MapOfShape aMFP(100, myAllocator);
//
aNbS=myDS->NbSourceShapes();
- for (i=0; i<aNbS; ++i) {
+ Message_ProgressScope aPS(theRange, "Building splits of compounds", aNbS);
+ for (i=0; i<aNbS; ++i, aPS.Next()) {
const BOPDS_ShapeInfo& aSI=myDS->ShapeInfo(i);
if (aSI.ShapeType()==TopAbs_COMPOUND) {
const TopoDS_Shape& aC=aSI.Shape();
FillImagesCompound(aC, aMFP);
}
+ if (UserBreak(aPS))
+ {
+ return;
+ }
}// for (; aItS.More(); aItS.Next()) {
}
//=======================================================================
//class : BOPAlgo_PairOfShapeBoolean
//purpose :
//=======================================================================
-class BOPAlgo_PairOfShapeBoolean : public BOPAlgo_Algo {
+class BOPAlgo_PairOfShapeBoolean : public BOPAlgo_ParallelAlgo {
public:
DEFINE_STANDARD_ALLOC
BOPAlgo_PairOfShapeBoolean() :
- BOPAlgo_Algo(),
+ BOPAlgo_ParallelAlgo(),
myFlag(Standard_False) {
}
//
}
//
virtual void Perform() {
- BOPAlgo_Algo::UserBreak();
- //
+ Message_ProgressScope aPS(myProgressRange, NULL, 1);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
+
const TopoDS_Face& aFj=*((TopoDS_Face*)&myShape1);
const TopoDS_Face& aFk=*((TopoDS_Face*)&myShape2);
myFlag=BOPTools_AlgoTools::AreFacesSameDomain(aFj, aFk, myContext, myFuzzyValue);
typedef NCollection_Vector<BOPAlgo_PairOfShapeBoolean> BOPAlgo_VectorOfPairOfShapeBoolean;
//=======================================================================
-// BuilderFace
-//
-typedef NCollection_Vector<BOPAlgo_BuilderFace> BOPAlgo_VectorOfBuilderFace;
+//class : BOPAlgo_SplitFace
+//purpose : Auxiliary class to extend BOPAlgo_BuilderFace with progress support
+//=======================================================================
+class BOPAlgo_SplitFace : public BOPAlgo_BuilderFace
+{
+public:
+ //! Sets progress range
+ void SetProgressRange(const Message_ProgressRange& theRange)
+ {
+ myRange = theRange;
+ }
+
+ // New perform method, using own progress range
+ void Perform()
+ {
+ Message_ProgressScope aPS(myRange, NULL, 1);
+ if (!aPS.More())
+ {
+ return;
+ }
+ BOPAlgo_BuilderFace::Perform(aPS.Next());
+ }
+
+private:
+ //! Disable the range enabled method
+ virtual void Perform(const Message_ProgressRange& /*theRange*/) {};
+
+private:
+ Message_ProgressRange myRange;
+};
+typedef NCollection_Vector<BOPAlgo_SplitFace> BOPAlgo_VectorOfBuilderFace;
//=======================================================================
//class : BOPAlgo_VFI
//purpose :
//=======================================================================
-class BOPAlgo_VFI : public BOPAlgo_Algo {
+class BOPAlgo_VFI : public BOPAlgo_ParallelAlgo {
public:
DEFINE_STANDARD_ALLOC
BOPAlgo_VFI() :
- BOPAlgo_Algo(),
+ BOPAlgo_ParallelAlgo(),
myIsInternal(Standard_False) {
}
//
}
//
virtual void Perform() {
+ Message_ProgressScope aPS(myProgressRange, NULL, 1);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
+
Standard_Real aT1, aT2, dummy;
//
- BOPAlgo_Algo::UserBreak();
Standard_Integer iFlag =
myContext->ComputeVF(myV, myF, aT1, aT2, dummy, myFuzzyValue);
myIsInternal = (iFlag == 0);
//function : FillImagesFaces
//purpose :
//=======================================================================
-void BOPAlgo_Builder::FillImagesFaces()
+void BOPAlgo_Builder::FillImagesFaces(const Message_ProgressRange& theRange)
{
- BuildSplitFaces();
- FillSameDomainFaces();
- FillInternalVertices();
+ Message_ProgressScope aPS(theRange, "Filing spligs of faces", 10);
+ BuildSplitFaces(aPS.Next(9));
+ if (HasErrors())
+ {
+ return;
+ }
+ FillSameDomainFaces(aPS.Next(0.5));
+ if (HasErrors())
+ {
+ return;
+ }
+ FillInternalVertices(aPS.Next(0.5));
}
//=======================================================================
//function : BuildSplitFaces
//purpose :
//=======================================================================
-void BOPAlgo_Builder::BuildSplitFaces()
+void BOPAlgo_Builder::BuildSplitFaces(const Message_ProgressRange& theRange)
{
Standard_Boolean bHasFaceInfo, bIsClosed, bIsDegenerated, bToReverse;
Standard_Integer i, j, k, aNbS, aNbPBIn, aNbPBOn, aNbPBSc, aNbAV, nSp;
TopTools_ListOfShape aLE(aAllocator);
TopTools_MapOfShape aMDE(100, aAllocator);
//
+ Message_ProgressScope aPSOuter(theRange, NULL, 10);
// Build temporary map of faces images to avoid rebuilding
// of the faces without any IN or section edges
NCollection_IndexedDataMap<Standard_Integer, TopTools_ListOfShape> aFacesIm;
if (aSI.ShapeType()!=TopAbs_FACE) {
continue;
}
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
//
const TopoDS_Face& aF=(*(TopoDS_Face*)(&aSI.Shape()));
Standard_Boolean isUClosed = Standard_False,
BRepLib::BuildPCurveForEdgesOnPlane(aLE, aFF);
}
// 3 Build split faces
- BOPAlgo_BuilderFace& aBF=aVBF.Appended();
+ BOPAlgo_SplitFace& aBF=aVBF.Appended();
aBF.SetFace(aF);
aBF.SetShapes(aLE);
aBF.SetRunParallel(myRunParallel);
- if (myProgressScope != NULL)
- {
- aBF.SetProgressIndicator(*myProgressScope);
- }
//
}// for (i=0; i<aNbS; ++i) {
+
+ // close preparation task
+ aPSOuter.Next();
//
+ Standard_Integer aNbBF = aVBF.Length();
+ // Set progress range for each task to be run in parallel
+ Message_ProgressScope aPSParallel(aPSOuter.Next(9), "Splitting faces", aNbBF);
+ for (Standard_Integer iF = 0; iF < aNbBF; iF++)
+ {
+ BOPAlgo_SplitFace& aBF = aVBF.ChangeValue(iF);
+ aBF.SetProgressRange(aPSParallel.Next());
+ }
//===================================================
BOPTools_Parallel::Perform (myRunParallel, aVBF);
//===================================================
- //
- Standard_Integer aNbBF = aVBF.Length();
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
for (k = 0; k < aNbBF; ++k)
{
BOPAlgo_BuilderFace& aBF = aVBF(k);
//function : FillSameDomainFaces
//purpose :
//=======================================================================
-void BOPAlgo_Builder::FillSameDomainFaces()
+void BOPAlgo_Builder::FillSameDomainFaces(const Message_ProgressRange& theRange)
{
// It is necessary to analyze all Face/Face intersections
// and find all faces with equal sets of edges
if (!aNbFFs)
return;
+ Message_ProgressScope aPSOuter(theRange, NULL, 10);
+
Handle(NCollection_BaseAllocator) aAllocator = new NCollection_IncAllocator;
// Vector to store the indices of faces for future sorting
// Fill the vector with indices of faces
for (Standard_Integer i = 0; i < aNbFFs; ++i)
{
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const BOPDS_InterfFF& aFF = aFFs(i);
// get indices
Standard_Integer nF[2];
Standard_Integer aNbF = aFIVec.Length();
for (Standard_Integer i = 0; i < aNbF; ++i)
{
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const Standard_Integer nF = aFIVec(i);
const BOPDS_ShapeInfo& aSI = myDS->ShapeInfo(nF);
const TopoDS_Shape& aF = aSI.Shape();
Standard_Integer aNbSets = anESetFaces.Extent();
for (Standard_Integer i = 1; i <= aNbSets; ++i)
{
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const TopTools_ListOfShape& aLF = anESetFaces(i);
if (aLF.Extent() < 2)
continue;
aPSB.Shape1() = aF1;
aPSB.Shape2() = aF2;
aPSB.SetFuzzyValue(myFuzzyValue);
- if (myProgressScope != NULL)
- {
- aPSB.SetProgressIndicator(*myProgressScope);
- }
}
}
}
+ aPSOuter.Next();
+
+ // Set progress range for each task to be run in parallel
+ Message_ProgressScope aPSParallel(aPSOuter.Next(6), "Checking SD faces", aVPSB.Size());
+ for (Standard_Integer iPSB = 0; iPSB < aVPSB.Size(); ++iPSB)
+ {
+ aVPSB.ChangeValue(iPSB).SetProgressRange(aPSParallel.Next());
+ }
//================================================================
// Perform analysis
BOPTools_Parallel::Perform (myRunParallel, aVPSB, myContext);
//================================================================
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
NCollection_List<TopTools_ListOfShape> aMBlocks(aAllocator);
// Fill map with SD faces to make the blocks
BOPAlgo_Tools::MakeBlocks<TopoDS_Shape, TopTools_ShapeMapHasher>
(aDMSLS, aMBlocks, aAllocator);
+ Message_ProgressScope aPS(aPSOuter.Next(3), "Filling same domain faces map", aMBlocks.Size());
// Fill same domain faces map
NCollection_List<TopTools_ListOfShape>::Iterator aItB(aMBlocks);
- for (; aItB.More(); aItB.Next())
+ for (; aItB.More(); aItB.Next(), aPS.Next())
{
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const TopTools_ListOfShape& aLSD = aItB.Value();
// If the group contains some original faces, the one with minimal
// index in the DS will be chosen as the SD for the whole group.
// function: FillImagesFaces1
// purpose:
//=======================================================================
-void BOPAlgo_Builder::FillInternalVertices()
+void BOPAlgo_Builder::FillInternalVertices(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPSOuter(theRange, NULL, 1);
+
// Vector of pairs of Vertex/Face for classification of the vertices
// relatively faces, and adding them as internal into the faces
BOPAlgo_VectorOfVFI aVVFI;
if (aSI.ShapeType() != TopAbs_FACE)
continue;
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
+
const TopoDS_Shape& aF = aSI.Shape();
const TopTools_ListOfShape* pLFIm = myImages.Seek(aF);
if (!pLFIm)
aVFI.SetVertex(aV);
aVFI.SetFace(aFIm);
aVFI.SetFuzzyValue(myFuzzyValue);
- if (myProgressScope != NULL)
- {
- aVFI.SetProgressIndicator(*myProgressScope);
- }
}
}
}
+ // Set progress range for each task to be run in parallel
+ Message_ProgressScope aPSParallel(aPSOuter.Next(), "Looking for internal shapes", aVVFI.Size());
+ for (Standard_Integer iVFI = 0; iVFI< aVVFI.Size(); ++iVFI)
+ {
+ aVVFI.ChangeValue(iVFI).SetProgressRange(aPSParallel.Next());
+ }
// Perform classification
//================================================================
BOPTools_Parallel::Perform (myRunParallel, aVVFI, myContext);
//================================================================
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
Standard_Integer aNbVFI = aVVFI.Length();
for (Standard_Integer i = 0; i < aNbVFI; ++i)
//function : FillImagesSolids
//purpose :
//=======================================================================
-void BOPAlgo_Builder::FillImagesSolids()
+void BOPAlgo_Builder::FillImagesSolids(const Message_ProgressRange& theRange)
{
- Standard_Boolean bHasSolids;
- Standard_Integer i, aNbS;
- //
- bHasSolids=Standard_False;
- aNbS=myDS->NbSourceShapes();
- for (i=0; i<aNbS; ++i) {
- const BOPDS_ShapeInfo& aSI=myDS->ShapeInfo(i);
- if (aSI.ShapeType()==TopAbs_SOLID) {
- bHasSolids=!bHasSolids;
+ Standard_Integer i = 0, aNbS = myDS->NbSourceShapes();
+ for (i = 0; i < aNbS; ++i) {
+ const BOPDS_ShapeInfo& aSI = myDS->ShapeInfo(i);
+ if (aSI.ShapeType() == TopAbs_SOLID)
+ {
break;
}
}
- //
- if (!bHasSolids) {
+ if (i >= aNbS) {
return;
}
+ Message_ProgressScope aPS(theRange, "Building splits of solids", 10);
// Draft solids
TopTools_DataMapOfShapeShape aDraftSolids;
// Find all IN faces for all IN faces
- FillIn3DParts(aDraftSolids);
+ FillIn3DParts(aDraftSolids, aPS.Next(4));
+ if (HasErrors())
+ {
+ return;
+ }
// Build split of the solids
- BuildSplitSolids(aDraftSolids);
+ BuildSplitSolids(aDraftSolids, aPS.Next(5));
+ if (HasErrors())
+ {
+ return;
+ }
// Fill solids with internal parts
- FillInternalShapes();
+ FillInternalShapes(aPS.Next());
}
//=======================================================================
//function : FillIn3DParts
//purpose :
//=======================================================================
-void BOPAlgo_Builder::FillIn3DParts(TopTools_DataMapOfShapeShape& theDraftSolids)
+void BOPAlgo_Builder::FillIn3DParts(TopTools_DataMapOfShapeShape& theDraftSolids,
+ const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPS(theRange, NULL, 2);
+
Handle(NCollection_BaseAllocator) anAlloc = new NCollection_IncAllocator;
// Find all faces that are IN solids
if (aSI.ShapeType() != TopAbs_FACE)
continue;
+ if (UserBreak(aPS))
+ {
+ return;
+ }
+
const TopoDS_Shape& aS = aSI.Shape();
const TopTools_ListOfShape* pLSIm = myImages.Seek(aS);
{
BOPDS_ShapeInfo& aSI = myDS->ChangeShapeInfo(i);
if (aSI.ShapeType() != TopAbs_SOLID)
+ {
continue;
-
+ }
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const TopoDS_Shape& aS = aSI.Shape();
const TopoDS_Solid& aSolid = (*(TopoDS_Solid*)(&aS));
//
TopTools_IndexedDataMapOfShapeListOfShape anInParts;
BOPAlgo_Tools::ClassifyFaces(aLFaces, aLSolids, myRunParallel,
- myContext, anInParts, aShapeBoxMap, aSolidsIF);
+ myContext, anInParts, aShapeBoxMap,
+ aSolidsIF, aPS.Next());
// Analyze the results of classification
Standard_Integer aNbSol = aDraftSolid.Extent();
for (i = 1; i <= aNbSol; ++i)
{
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const TopoDS_Solid& aSolid = TopoDS::Solid(aDraftSolid.FindKey(i));
const TopoDS_Solid& aSDraft = TopoDS::Solid(aDraftSolid(i));
const TopTools_ListOfShape& aLInFaces = anInParts.FindFromKey(aSDraft);
//! Returns the solid
const TopoDS_Solid& Solid() const { return mySolid; }
+ //! Sets progress range
+ void SetProgressRange(const Message_ProgressRange& theRange)
+ {
+ myRange = theRange;
+ }
+
+ // New perform method, using own progress range
+ void Perform()
+ {
+ Message_ProgressScope aPS(myRange, NULL, 1);
+ if (!aPS.More())
+ {
+ return;
+ }
+ BOPAlgo_BuilderSolid::Perform(aPS.Next());
+ }
+
+private:
+ //! Disable the range enabled method
+ virtual void Perform(const Message_ProgressRange&/* theRange*/) {}
+
private:
TopoDS_Solid mySolid; //!< Solid to split
+ Message_ProgressRange myRange;
};
// Vector of Solid Builders
//function : BuildSplitSolids
//purpose :
//=======================================================================
-void BOPAlgo_Builder::BuildSplitSolids(TopTools_DataMapOfShapeShape& theDraftSolids)
+void BOPAlgo_Builder::BuildSplitSolids(TopTools_DataMapOfShapeShape& theDraftSolids,
+ const Message_ProgressRange& theRange)
{
Standard_Boolean bFlagSD;
Standard_Integer i, aNbS;
BOPTools_MapOfSet aMST(100, aAlr0);
BOPAlgo_VectorOfBuilderSolid aVBS;
//
+ Message_ProgressScope aPSOuter (theRange, NULL, 10);
// 0. Find same domain solids for non-interfered solids
aNbS=myDS->NbSourceShapes();
for (i=0; i<aNbS; ++i) {
if (aSI.ShapeType()!=TopAbs_SOLID) {
continue;
}
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
//
const TopoDS_Shape& aS=aSI.Shape();
if (!aMFence.Add(aS)) {
aBS.SetSolid(aSolid);
aBS.SetShapes(aSFS);
aBS.SetRunParallel(myRunParallel);
- if (myProgressScope != NULL)
- {
- aBS.SetProgressIndicator(*myProgressScope);
- }
}//for (i=0; i<aNbS; ++i) {
//
Standard_Integer k, aNbBS;
//
aNbBS=aVBS.Length();
+ // Set progress range for each task to be run in parallel
+ Message_ProgressScope aPSParallel(aPSOuter.Next(9), "Splitting solids", aNbBS);
+ for (Standard_Integer iS = 0; iS < aNbBS; iS++)
+ {
+ BOPAlgo_SplitSolid& aSplitSolid = aVBS.ChangeValue(iS);
+ aSplitSolid.SetProgressRange(aPSParallel.Next());
+ }
//
//===================================================
BOPTools_Parallel::Perform (myRunParallel, aVBS);
//===================================================
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
//
for (k = 0; k < aNbBS; ++k)
{
//function :FillInternalShapes
//purpose :
//=======================================================================
-void BOPAlgo_Builder::FillInternalShapes()
+void BOPAlgo_Builder::FillInternalShapes(const Message_ProgressRange& theRange)
{
Standard_Integer i, j, aNbS, aNbSI, aNbSx;
TopAbs_ShapeEnum aType;
TopTools_ListOfShape aLArgs(aAllocator);
TopTools_ListOfShape aLSC(aAllocator);
TopTools_ListOfShape aLSI(aAllocator);
+
+ Message_ProgressScope aPS(theRange, NULL, 10);
//
// 1. Shapes to process
//
}
}
}
-
+ if (UserBreak(aPS))
+ {
+ return;
+ }
+
aNbSI=aMSI.Extent();
//
// 2. Internal vertices, edges from source solids
if (aSI.ShapeType()!=TopAbs_SOLID) {
continue;
}
- //
- UserBreak();
+ if (UserBreak(aPS))
+ {
+ return;
+ }
//
const TopoDS_Shape& aS=aSI.Shape();
//
if (!aNbSI) {
return;
}
+
+ aPS.Next();
//
// 5 Settle internal vertices and edges into solids
aMx.Clear();
+
+ Message_ProgressScope aPSLoop(aPS.Next(9), "Looking for internal shapes", aLSd.Size());
+
aIt.Initialize(aLSd);
- for (; aIt.More(); aIt.Next()) {
+ for (; aIt.More(); aIt.Next(), aPSLoop.Next()) {
TopoDS_Solid aSd=TopoDS::Solid(aIt.Value());
//
aIt1.Initialize(aLSI);
//function : PrepareHistory
//purpose :
//=======================================================================
-void BOPAlgo_Builder::PrepareHistory()
+void BOPAlgo_Builder::PrepareHistory(const Message_ProgressRange& theRange)
{
if (!HasHistory())
return;
// - Shapes that have no trace in the result shape. Add them as Deleted
// during the operation.
Standard_Integer aNbS = myDS->NbSourceShapes();
- for (Standard_Integer i = 0; i < aNbS; ++i)
+ Message_ProgressScope aPS(theRange, "Preparing history information", aNbS);
+ for (Standard_Integer i = 0; i < aNbS; ++i, aPS.Next())
{
const TopoDS_Shape& aS = myDS->Shape(i);
if (!BRepTools_History::IsSupportedType(aS))
continue;
+ if (UserBreak(aPS))
+ {
+ return;
+ }
+
Standard_Boolean isModified = Standard_False;
// Check if the shape has any splits
//function : PerformInternal1
//purpose :
//=======================================================================
-void BOPAlgo_CellsBuilder::PerformInternal1(const BOPAlgo_PaveFiller& theFiller)
+void BOPAlgo_CellsBuilder::PerformInternal1(const BOPAlgo_PaveFiller& theFiller, const Message_ProgressRange& theRange)
{
// Avoid filling history after GF operation as later
// in this method the result shape will be nullified
Standard_Boolean isHistory = HasHistory();
SetToFillHistory(Standard_False);
// Perform splitting of the arguments
- BOPAlgo_Builder::PerformInternal1(theFiller);
+ Message_ProgressScope aPS(theRange, "Performing MakeCells operation", 1);
+ BOPAlgo_Builder::PerformInternal1(theFiller, aPS.Next());
if (HasErrors()) {
return;
}
//
if (!theUpdate) {
if (bChanged) {
- PrepareHistory();
+ PrepareHistory(Message_ProgressRange());
}
}
else {
}
//
if (!theUpdate) {
- PrepareHistory();
+ PrepareHistory(Message_ProgressRange());
}
else {
RemoveInternalBoundaries();
if (bChanged) {
myShape = aResult;
//
- PrepareHistory();
+ PrepareHistory(Message_ProgressRange());
}
}
myShapeMaterial.Clear();
myMapModified.Clear();
//
- PrepareHistory();
+ PrepareHistory(Message_ProgressRange());
}
//=======================================================================
//
myShape = aResult;
//
- PrepareHistory();
+ PrepareHistory(Message_ProgressRange());
}
}
//! Redefined method PerformInternal1 - makes all split parts,
//! nullifies the result <myShape>, and index all parts.
- Standard_EXPORT virtual void PerformInternal1 (const BOPAlgo_PaveFiller& thePF) Standard_OVERRIDE;
+ Standard_EXPORT virtual void PerformInternal1 (const BOPAlgo_PaveFiller& thePF, const Message_ProgressRange& theRange) Standard_OVERRIDE;
//! Indexes the parts for quick access to the arguments.
Standard_EXPORT void IndexParts();
//=======================================================================
class BOPAlgo_FaceSelfIntersect :
public IntTools_FaceFace,
- public BOPAlgo_Algo {
+ public BOPAlgo_ParallelAlgo {
public:
DEFINE_STANDARD_ALLOC
BOPAlgo_FaceSelfIntersect() :
IntTools_FaceFace(),
- BOPAlgo_Algo(),
+ BOPAlgo_ParallelAlgo(),
myIF(-1), myTolF(1.e-7) {
}
//
}
//
virtual void Perform() {
- BOPAlgo_Algo::UserBreak();
+ Message_ProgressScope aPS(myProgressRange, NULL, 1);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
IntTools_FaceFace::Perform (myF, myF, myRunParallel);
}
//
//function : Init
//purpose :
//=======================================================================
-void BOPAlgo_CheckerSI::Init()
+void BOPAlgo_CheckerSI::Init(const Message_ProgressRange& /*theRange*/)
{
Clear();
//
//function : Perform
//purpose :
//=======================================================================
-void BOPAlgo_CheckerSI::Perform()
+void BOPAlgo_CheckerSI::Perform(const Message_ProgressRange& theRange)
{
try {
OCC_CATCH_SIGNALS
return;
}
//
+ Message_ProgressScope aPS(theRange, "Checking shape on self-intersection", 10);
// Perform intersection of sub shapes
- BOPAlgo_PaveFiller::Perform();
+ BOPAlgo_PaveFiller::Perform(aPS.Next(8));
+ if (UserBreak(aPS))
+ {
+ return;
+ }
//
- CheckFaceSelfIntersection();
+ CheckFaceSelfIntersection(aPS.Next());
+ Message_ProgressScope aPSZZ(aPS.Next(), NULL, 4);
// Perform intersection with solids
if (!HasErrors())
- PerformVZ();
+ PerformVZ(aPSZZ.Next());
//
if (!HasErrors())
- PerformEZ();
+ PerformEZ(aPSZZ.Next());
//
if (!HasErrors())
- PerformFZ();
+ PerformFZ(aPSZZ.Next());
//
if (!HasErrors())
- PerformZZ();
+ PerformZZ(aPSZZ.Next());
//
+ if (HasErrors())
+ return;
+
// Treat the intersection results
PostTreat();
}
//function : CheckFaceSelfIntersection
//purpose :
//=======================================================================
-void BOPAlgo_CheckerSI::CheckFaceSelfIntersection()
+void BOPAlgo_CheckerSI::CheckFaceSelfIntersection(const Message_ProgressRange& theRange)
{
if (myLevelOfCheck < 5)
return;
BOPAlgo_VectorOfFaceSelfIntersect aVFace;
Standard_Integer aNbS=myDS->NbSourceShapes();
+
+ Message_ProgressScope aPSOuter(theRange, NULL, 1);
//
for (Standard_Integer i = 0; i < aNbS; i++)
aFaceSelfIntersect.SetIndex(i);
aFaceSelfIntersect.SetFace(aF);
aFaceSelfIntersect.SetTolF(aTolF);
- //
- if (myProgressScope != NULL)
- {
- aFaceSelfIntersect.SetProgressIndicator(*myProgressScope);
- }
}
Standard_Integer aNbFace = aVFace.Length();
+ Message_ProgressScope aPSParallel(aPSOuter.Next(), "Checking surface on self-intersection", aNbFace);
+ for (Standard_Integer iF = 0; iF < aNbFace; ++iF)
+ {
+ aVFace.ChangeValue(iF).SetProgressRange(aPSParallel.Next());
+ }
//======================================================
BOPTools_Parallel::Perform (myRunParallel, aVFace);
//======================================================
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
//
for (Standard_Integer k = 0; k < aNbFace; k++)
{
Standard_EXPORT BOPAlgo_CheckerSI();
Standard_EXPORT virtual ~BOPAlgo_CheckerSI();
- Standard_EXPORT virtual void Perform() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Perform(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Sets the level of checking shape on self-interference.<br>
//! It defines which interferences will be checked:<br>
protected:
- Standard_EXPORT virtual void Init() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Init(const Message_ProgressRange& theRange) Standard_OVERRIDE;
//! Treats the intersection results
Standard_EXPORT void PostTreat();
- Standard_EXPORT void CheckFaceSelfIntersection();
+ Standard_EXPORT void CheckFaceSelfIntersection(const Message_ProgressRange& theRange);
//! Methods for intersection with solids
//! Vertex/Solid intersection
- Standard_EXPORT virtual void PerformVZ();
+ Standard_EXPORT virtual void PerformVZ(const Message_ProgressRange& theRange);
//! Edge/Solid intersection
- Standard_EXPORT virtual void PerformEZ();
+ Standard_EXPORT virtual void PerformEZ(const Message_ProgressRange& theRange);
//! Face/Solid intersection
- Standard_EXPORT virtual void PerformFZ();
+ Standard_EXPORT virtual void PerformFZ(const Message_ProgressRange& theRange);
//! Solid/Solid intersection
- Standard_EXPORT virtual void PerformZZ();
+ Standard_EXPORT virtual void PerformZZ(const Message_ProgressRange& theRange);
//! Used for intersection of edges and faces with solids
- Standard_EXPORT virtual void PerformSZ(const TopAbs_ShapeEnum aTS);
+ Standard_EXPORT virtual void PerformSZ(const TopAbs_ShapeEnum aTS, const Message_ProgressRange& theRange);
Standard_Integer myLevelOfCheck;
//class : BOPAlgo_VertexSolid
//purpose :
//=======================================================================
-class BOPAlgo_VertexSolid {
+class BOPAlgo_VertexSolid {
public:
DEFINE_STANDARD_ALLOC
- BOPAlgo_VertexSolid()
- : myIV(-1), myIZ(-1), myState(TopAbs_UNKNOWN) {
+ BOPAlgo_VertexSolid() :
+ myIV(-1), myIZ(-1), myState(TopAbs_UNKNOWN) {
};
//
virtual ~BOPAlgo_VertexSolid(){
return myState;
};
//
- void Perform() {
+ void SetProgressRange(const Message_ProgressRange& theRange)
+ {
+ myProgressRange = theRange;
+ }
+ //
+ virtual void Perform() {
+ Message_ProgressScope aPS(myProgressRange, NULL, 1);
+ if (!aPS.More())
+ {
+ return;
+ }
+
Standard_Real aTol;
gp_Pnt aPV;
//
TopoDS_Vertex myV;
TopoDS_Solid myZ;
Handle(IntTools_Context) myContext;
+ Message_ProgressRange myProgressRange;
};
//=======================================================================
typedef NCollection_Vector<BOPAlgo_VertexSolid> BOPAlgo_VectorOfVertexSolid;
//class : BOPAlgo_ShapeSolid
//purpose :
//=======================================================================
-class BOPAlgo_ShapeSolid {
+class BOPAlgo_ShapeSolid {
public:
DEFINE_STANDARD_ALLOC
return myHasInterf;
};
//
+ void SetProgressRange(const Message_ProgressRange& theRange)
+ {
+ myProgressRange = theRange;
+ }
+ //
virtual void Perform() {
+ Message_ProgressScope aPS(myProgressRange, NULL, 1);
+ if (!aPS.More())
+ {
+ return;
+ }
+
Standard_Boolean bHasInterf;
//
myHasInterf=Standard_False;
Standard_Integer myIZ;
Standard_Boolean myHasInterf;
BOPDS_DS* myDS;
+ Message_ProgressRange myProgressRange;
};
//=======================================================================
typedef NCollection_Vector<BOPAlgo_ShapeSolid> BOPAlgo_VectorOfShapeSolid;
};
//
virtual void Perform() {
+ Message_ProgressScope aPS(myProgressRange, NULL, 1);
+ if (!aPS.More())
+ {
+ return;
+ }
+
Standard_Boolean bFlag;
//
bFlag=Standard_False;
//function : PerformVZ
//purpose :
//=======================================================================
-void BOPAlgo_CheckerSI::PerformVZ()
+void BOPAlgo_CheckerSI::PerformVZ(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPSOuter(theRange, NULL, 1);
+
Standard_Integer iSize, nV, nZ, k, aNbVVS;
TopAbs_State aState;
BOPDS_MapOfPair aMPK;
BOPAlgo_VectorOfVertexSolid aVVS;
//
for (; myIterator->More(); myIterator->Next()) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
myIterator->Value(nV, nZ);
//
if (myDS->HasInterfShapeSubShapes(nV, nZ)) {
}
//
aNbVVS=aVVS.Length();
+
+ Message_ProgressScope aPSParallel(aPSOuter.Next(), "Performing Vertex-Solid intersection", aNbVVS);
+ for (Standard_Integer iVS = 0; iVS < aNbVVS; ++iVS)
+ {
+ aVVS.ChangeValue(iVS).SetProgressRange(aPSParallel.Next());
+ }
//=============================================================
BOPTools_Parallel::Perform (myRunParallel, aVVS, myContext);
//=============================================================
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
for (k=0; k < aNbVVS; ++k) {
const BOPAlgo_VertexSolid& aVertexSolid=aVVS(k);
aState=aVertexSolid.State();
//function : PerformEZ
//purpose :
//=======================================================================
-void BOPAlgo_CheckerSI::PerformEZ()
+void BOPAlgo_CheckerSI::PerformEZ(const Message_ProgressRange& theRange)
{
- PerformSZ(TopAbs_EDGE);
+ PerformSZ(TopAbs_EDGE, theRange);
}
//=======================================================================
//function : PerformFZ
//purpose :
//=======================================================================
-void BOPAlgo_CheckerSI::PerformFZ()
+void BOPAlgo_CheckerSI::PerformFZ(const Message_ProgressRange& theRange)
{
- PerformSZ(TopAbs_FACE);
+ PerformSZ(TopAbs_FACE, theRange);
}
//=======================================================================
//function : PerformZZ
//purpose :
//=======================================================================
-void BOPAlgo_CheckerSI::PerformZZ()
+void BOPAlgo_CheckerSI::PerformZZ(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPSOuter(theRange, NULL, 1);
+
Standard_Boolean bHasInterf;
Standard_Integer iSize, nZ1, nZ, k, aNbSolidSolid;
//
}
//
aNbSolidSolid=aVSolidSolid.Length();
+
+ Message_ProgressScope aPSParallel(aPSOuter.Next(), "Performing Solid-Solid intersection", aNbSolidSolid);
+ for (Standard_Integer iSS = 0; iSS < aNbSolidSolid; ++iSS)
+ {
+ aVSolidSolid.ChangeValue(iSS).SetProgressRange(aPSParallel.Next());
+ }
//======================================================
BOPTools_Parallel::Perform (myRunParallel, aVSolidSolid);
//======================================================
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
//
BOPDS_VectorOfInterfZZ& aZZs=myDS->InterfZZ();
//
//function : PerformSZ
//purpose :
//=======================================================================
-void BOPAlgo_CheckerSI::PerformSZ(const TopAbs_ShapeEnum aTS)
+void BOPAlgo_CheckerSI::PerformSZ(const TopAbs_ShapeEnum theTS, const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPSOuter(theRange, NULL, 1);
+
Standard_Boolean bHasInterf;
Standard_Integer iSize, nS, nZ, k, aNbShapeSolid;
//
- myIterator->Initialize(aTS, TopAbs_SOLID);
+ myIterator->Initialize(theTS, TopAbs_SOLID);
iSize=myIterator->ExpectedLength();
if (!iSize) {
return;
}
//
aNbShapeSolid=aVShapeSolid.Length();
+
+ Message_ProgressScope aPSParallel(aPSOuter.Next(),
+ theTS == TopAbs_EDGE ? "Performing Edge-Solid intersection" :
+ "Performing Face-Solid intersection",
+ aNbShapeSolid);
+ for (Standard_Integer iSS = 0; iSS < aNbShapeSolid; ++iSS)
+ {
+ aVShapeSolid.ChangeValue(iSS).SetProgressRange(aPSParallel.Next());
+ }
//======================================================
BOPTools_Parallel::Perform (myRunParallel, aVShapeSolid);
//======================================================
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
//
BOPDS_VectorOfInterfEZ& aEZs=myDS->InterfEZ();
BOPDS_VectorOfInterfFZ& aFZs=myDS->InterfFZ();
//
- if (aTS==TopAbs_EDGE) {
+ if (theTS==TopAbs_EDGE) {
aEZs.SetIncrement(iSize);
}
else {//if (aTS==TopAbs_FACE)
if (bHasInterf) {
aShapeSolid.Indices(nS, nZ);
//
- if (aTS==TopAbs_EDGE) {
+ if (theTS==TopAbs_EDGE) {
BOPDS_InterfEZ& aEZ=aEZs.Appended();
aEZ.SetIndices(nS, nZ);
}
//function : Perform
//purpose :
//=======================================================================
-void BOPAlgo_MakerVolume::Perform()
+void BOPAlgo_MakerVolume::Perform(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPS(theRange, "Performing MakeVolume operation", 10);
+ Standard_Real anInterPart = myIntersect ? 9 : 0.5;
+ Standard_Real aBuildPart = 10. - anInterPart;
+
GetReport()->Clear();
//
if (myEntryPoint == 1) {
}
//
pPF->SetRunParallel(myRunParallel);
- if (myProgressScope != NULL)
- {
- pPF->SetProgressIndicator(*myProgressScope);
- }
pPF->SetFuzzyValue(myFuzzyValue);
pPF->SetNonDestructive(myNonDestructive);
pPF->SetGlue(myGlue);
pPF->SetUseOBB(myUseOBB);
- pPF->Perform();
+ pPF->Perform(aPS.Next(anInterPart));
//
myEntryPoint = 1;
- PerformInternal(*pPF);
+ PerformInternal(*pPF, aPS.Next(aBuildPart));
}
//=======================================================================
//purpose :
//=======================================================================
void BOPAlgo_MakerVolume::PerformInternal1
- (const BOPAlgo_PaveFiller& theFiller)
+ (const BOPAlgo_PaveFiller& theFiller, const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPS(theRange, "Building volumes", 100);
myPaveFiller = (BOPAlgo_PaveFiller*)&theFiller;
myDS = myPaveFiller->PDS();
myContext = myPaveFiller->Context();
return;
}
//
+ BOPAlgo_PISteps aSteps(PIOperation_Last);
+ analyzeProgress(100., aSteps);
+
// 3. Fill Images
- // 3.1. Vertice
if (myIntersect) {
- FillImagesVertices();
+ // 3.1. Vertices
+ FillImagesVertices(aPS.Next(aSteps.GetStep(PIOperation_TreatVertices)));
if (HasErrors()) {
return;
}
// 3.2. Edges
- FillImagesEdges();
+ FillImagesEdges(aPS.Next(aSteps.GetStep(PIOperation_TreatEdges)));
if (HasErrors()) {
return;
}
// 3.3. Wires
- FillImagesContainers(TopAbs_WIRE);
+ FillImagesContainers(TopAbs_WIRE, aPS.Next(aSteps.GetStep(PIOperation_TreatWires)));
if (HasErrors()) {
return;
}
// 3.4. Faces
- FillImagesFaces();
+ FillImagesFaces(aPS.Next(aSteps.GetStep(PIOperation_TreatFaces)));
if (HasErrors()) {
return;
}
MakeBox(aBoxFaces);
//
// 6. Make volumes
- BuildSolids(aLSR);
+ BuildSolids(aLSR, aPS.Next(aSteps.GetStep(PIOperation_BuildSolids)));
if (HasErrors()) {
return;
}
BuildShape(aLSR);
//
// 10. History
- PrepareHistory();
+ PrepareHistory(aPS.Next(aSteps.GetStep(PIOperation_FillHistory)));
+ if (HasErrors()) {
+ return;
+ }
//
// 11. Post-treatment
- PostTreat();
+ PostTreat(aPS.Next(aSteps.GetStep(PIOperation_PostTreat)));
+}
+
+//=======================================================================
+//function : fillPISteps
+//purpose :
+//=======================================================================
+void BOPAlgo_MakerVolume::fillPISteps(BOPAlgo_PISteps& theSteps) const
+{
+ NbShapes aNbShapes = getNbShapes();
+ if (myIntersect)
+ {
+ theSteps.SetStep(PIOperation_TreatVertices, aNbShapes.NbVertices());
+ theSteps.SetStep(PIOperation_TreatEdges, aNbShapes.NbEdges());
+ theSteps.SetStep(PIOperation_TreatWires, aNbShapes.NbWires());
+ theSteps.SetStep(PIOperation_TreatFaces, 50 * aNbShapes.NbFaces());
+ }
+ theSteps.SetStep(PIOperation_BuildSolids, 50 * aNbShapes.NbFaces());
}
//=======================================================================
//=======================================================================
void BOPAlgo_MakerVolume::CollectFaces()
{
- UserBreak();
//
Standard_Integer i, aNbShapes;
TopTools_ListIteratorOfListOfShape aIt;
//=======================================================================
void BOPAlgo_MakerVolume::MakeBox(TopTools_MapOfShape& theBoxFaces)
{
- UserBreak();
//
Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax, anExt;
//
//function : BuildSolids
//purpose :
//=======================================================================
-void BOPAlgo_MakerVolume::BuildSolids(TopTools_ListOfShape& theLSR)
+void BOPAlgo_MakerVolume::BuildSolids(TopTools_ListOfShape& theLSR,
+ const Message_ProgressRange& theRange)
{
- UserBreak();
- //
BOPAlgo_BuilderSolid aBS;
//
aBS.SetShapes(myFaces);
aBS.SetRunParallel(myRunParallel);
aBS.SetAvoidInternalShapes(myAvoidInternalShapes);
- aBS.Perform();
+ aBS.Perform(theRange);
if (aBS.HasErrors())
{
AddError (new BOPAlgo_AlertSolidBuilderFailed); // SolidBuilder failed
void BOPAlgo_MakerVolume::RemoveBox(TopTools_ListOfShape& theLSR,
const TopTools_MapOfShape& theBoxFaces)
{
- UserBreak();
//
TopTools_ListIteratorOfListOfShape aIt;
TopExp_Explorer aExp;
return;
}
- UserBreak();
-
// Get all non-compound shapes
TopTools_ListOfShape aLSC;
// Fence map
DEFINE_STANDARD_ALLOC
-
-
//! Empty constructor.
BOPAlgo_MakerVolume();
virtual ~BOPAlgo_MakerVolume();
}
//! Performs the operation.
- Standard_EXPORT virtual void Perform() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Perform(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
protected:
Standard_EXPORT virtual void CheckData() Standard_OVERRIDE;
//! Performs the operation.
- Standard_EXPORT virtual void PerformInternal1 (const BOPAlgo_PaveFiller& thePF) Standard_OVERRIDE;
+ Standard_EXPORT virtual void PerformInternal1 (const BOPAlgo_PaveFiller& thePF, const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Collects all faces.
Standard_EXPORT void CollectFaces();
Standard_EXPORT void MakeBox (TopTools_MapOfShape& theBoxFaces);
//! Builds solids.
- Standard_EXPORT void BuildSolids (TopTools_ListOfShape& theLSR);
+ Standard_EXPORT void BuildSolids (TopTools_ListOfShape& theLSR,
+ const Message_ProgressRange& theRange);
//! Removes the covering box.
Standard_EXPORT void RemoveBox (TopTools_ListOfShape& theLSR, const TopTools_MapOfShape& theBoxFaces);
//! Builds the result.
Standard_EXPORT void BuildShape (const TopTools_ListOfShape& theLSR);
+protected:
+ //! List of operations to be supported by the Progress Indicator.
+ //! Enumeration is going to contain some extra operations from base class,
+ //! which are not going to be used here. So, the array of steps will also
+ //! contain some extra zero values. This is the only extra resource that is
+ //! going to be used, but it allows us not to override the methods that use
+ //! the values of the enumeration of base class.
+ //! Starting the enumeration from the middle of enumeration of base class is
+ //! not a good idea as the values in enumeration may be swapped.
+ enum BOPAlgo_PIOperation
+ {
+ PIOperation_BuildSolids = BOPAlgo_Builder::PIOperation_Last,
+ PIOperation_Last
+ };
+
+ //! Analyze progress steps
+ Standard_EXPORT void fillPISteps(BOPAlgo_PISteps& theSteps) const Standard_OVERRIDE;
+
+protected:
Standard_Boolean myIntersect;
Bnd_Box myBBox;
#include <Precision.hxx>
#include <Standard_NotImplemented.hxx>
#include <Standard_ProgramError.hxx>
+#include <BOPAlgo_Alerts.hxx>
namespace
{
myReport(new Message_Report),
myRunParallel(myGlobalRunParallel),
myFuzzyValue(Precision::Confusion()),
- myProgressScope(0L),
myUseOBB(Standard_False)
{
BOPAlgo_LoadMessages();
myReport(new Message_Report),
myRunParallel(myGlobalRunParallel),
myFuzzyValue(Precision::Confusion()),
- myProgressScope(0L),
myUseOBB(Standard_False)
{
BOPAlgo_LoadMessages();
myFuzzyValue = Max(theFuzz, Precision::Confusion());
}
-
-//=======================================================================
-//function : SetProgressIndicator
-//purpose :
-//=======================================================================
-void BOPAlgo_Options::SetProgressIndicator
- (const Message_ProgressScope& theScope)
+Standard_Boolean BOPAlgo_Options::UserBreak(const Message_ProgressScope& thePS)
{
- myProgressScope = &theScope;
-}
-
-//=======================================================================
-//function : UserBreak
-//purpose :
-//=======================================================================
-void BOPAlgo_Options::UserBreak() const
-{
- if (!myProgressScope) {
- return;
- }
- if (myProgressScope->UserBreak()) {
- throw Standard_NotImplemented("BOPAlgo_Options::UserBreak(), method is not implemented");
+ if (thePS.UserBreak())
+ {
+ AddError(new BOPAlgo_AlertUserBreak);
+ return Standard_True;
}
+ return Standard_False;
}
+
//! - *Parallel processing mode* - provides the possibility to perform operation in parallel mode;
//! - *Fuzzy tolerance* - additional tolerance for the operation to detect
//! touching or coinciding cases;
-//! - *Progress indicator* - provides interface to track the progress of
-//! operation and stop the operation by user's break.
//! - *Using the Oriented Bounding Boxes* - Allows using the Oriented Bounding Boxes of the shapes
//! for filtering the intersections.
//!
return myFuzzyValue;
}
-public:
- //!@name Progress indicator
-
- //! Set the Progress Indicator object.
- Standard_EXPORT void SetProgressIndicator(const Message_ProgressScope& theProgress);
-
public:
//!@name Usage of Oriented Bounding boxes
protected:
- //! Breaks the execution if the break signal
- //! is indicated by myProgressIndicator.
- Standard_EXPORT void UserBreak() const;
+ //! Adds error to the report if the break signal was caught. Returns true in this case, false otherwise.
+ Standard_EXPORT Standard_Boolean UserBreak(const Message_ProgressScope& thePS);
protected:
Handle(Message_Report) myReport;
Standard_Boolean myRunParallel;
Standard_Real myFuzzyValue;
- const Message_ProgressScope* myProgressScope;
Standard_Boolean myUseOBB;
};
#include <TopoDS_Vertex.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
+namespace
+{
+ //=======================================================================
+ //function : BOPAlgo_PIOperation
+ //purpose : List of operations to be supported by the Progress Indicator
+ //=======================================================================
+ enum BOPAlgo_PIOperation
+ {
+ PIOperation_Prepare = 0,
+ PIOperation_PerformVV,
+ PIOperation_PerformVE,
+ PIOperation_PerformEE,
+ PIOperation_PerformVF,
+ PIOperation_PerformEF,
+ PIOperation_RepeatIntersection,
+ PIOperation_ForceInterfEE,
+ PIOperation_ForceInterfEF,
+ PIOperation_PerformFF,
+ PIOperation_MakeSplitEdges,
+ PIOperation_MakeBlocks,
+ PIOperation_MakePCurves,
+ PIOperation_ProcessDE,
+ PIOperation_Last
+ };
+}
+
//=======================================================================
//function :
//purpose :
//=======================================================================
BOPAlgo_PaveFiller::BOPAlgo_PaveFiller()
-:
+ :
BOPAlgo_Algo()
{
myDS = NULL;
//purpose :
//=======================================================================
BOPAlgo_PaveFiller::BOPAlgo_PaveFiller
- (const Handle(NCollection_BaseAllocator)& theAllocator)
-:
- BOPAlgo_Algo(theAllocator),
- myFPBDone(1, theAllocator),
- myIncreasedSS(1, theAllocator),
- myVertsToAvoidExtension(1, theAllocator),
- myDistances(1, theAllocator)
+(const Handle (NCollection_BaseAllocator)& theAllocator)
+ :
+ BOPAlgo_Algo (theAllocator),
+ myFPBDone (1, theAllocator),
+ myIncreasedSS (1, theAllocator),
+ myVertsToAvoidExtension (1, theAllocator),
+ myDistances (1, theAllocator)
{
myDS = NULL;
myIterator = NULL;
//function : SetNonDestructive
//purpose :
//=======================================================================
-void BOPAlgo_PaveFiller::SetNonDestructive(const Standard_Boolean bFlag)
+void BOPAlgo_PaveFiller::SetNonDestructive (const Standard_Boolean bFlag)
{
- myNonDestructive=bFlag;
+ myNonDestructive = bFlag;
}
//=======================================================================
//function : NonDestructive
//purpose :
//=======================================================================
-Standard_Boolean BOPAlgo_PaveFiller::NonDestructive()const
+Standard_Boolean BOPAlgo_PaveFiller::NonDestructive() const
{
return myNonDestructive;
}
//function : SetGlue
//purpose :
//=======================================================================
-void BOPAlgo_PaveFiller::SetGlue(const BOPAlgo_GlueEnum theGlue)
+void BOPAlgo_PaveFiller::SetGlue (const BOPAlgo_GlueEnum theGlue)
{
- myGlue=theGlue;
+ myGlue = theGlue;
}
//=======================================================================
//function : Glue
//purpose :
//=======================================================================
-BOPAlgo_GlueEnum BOPAlgo_PaveFiller::Glue() const
+BOPAlgo_GlueEnum BOPAlgo_PaveFiller::Glue() const
{
return myGlue;
}
//function : SetIsPrimary
//purpose :
//=======================================================================
-void BOPAlgo_PaveFiller::SetIsPrimary(const Standard_Boolean bFlag)
+void BOPAlgo_PaveFiller::SetIsPrimary (const Standard_Boolean bFlag)
{
- myIsPrimary=bFlag;
+ myIsPrimary = bFlag;
}
//=======================================================================
//function : IsPrimary
//purpose :
//=======================================================================
-Standard_Boolean BOPAlgo_PaveFiller::IsPrimary()const
+Standard_Boolean BOPAlgo_PaveFiller::IsPrimary() const
{
return myIsPrimary;
}
BOPAlgo_Algo::Clear();
if (myIterator) {
delete myIterator;
- myIterator=NULL;
+ myIterator = NULL;
}
if (myDS) {
delete myDS;
- myDS=NULL;
+ myDS = NULL;
}
myIncreasedSS.Clear();
}
//function : Context
//purpose :
//=======================================================================
-const Handle(IntTools_Context)& BOPAlgo_PaveFiller::Context()
+const Handle (IntTools_Context)& BOPAlgo_PaveFiller::Context()
{
return myContext;
}
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::SetSectionAttribute
- (const BOPAlgo_SectionAttribute& theSecAttr)
+(const BOPAlgo_SectionAttribute& theSecAttr)
{
mySectionAttribute = theSecAttr;
}
// function: Init
// purpose:
//=======================================================================
-void BOPAlgo_PaveFiller::Init()
+void BOPAlgo_PaveFiller::Init (const Message_ProgressRange& theRange)
{
if (!myArguments.Extent()) {
AddError (new BOPAlgo_AlertTooFewArguments);
return;
}
//
- TopTools_ListIteratorOfListOfShape aIt(myArguments);
+ Message_ProgressScope aPS (theRange, "Initialization of Intersection algorithm", 1);
+ TopTools_ListIteratorOfListOfShape aIt (myArguments);
for (; aIt.More(); aIt.Next()) {
if (aIt.Value().IsNull()) {
AddError (new BOPAlgo_AlertNullInputShapes);
Clear();
//
// 1.myDS
- myDS=new BOPDS_DS(myAllocator);
- myDS->SetArguments(myArguments);
- myDS->Init(myFuzzyValue);
+ myDS = new BOPDS_DS (myAllocator);
+ myDS->SetArguments (myArguments);
+ myDS->Init (myFuzzyValue);
//
// 2 myContext
- myContext=new IntTools_Context;
+ myContext = new IntTools_Context;
//
// 3.myIterator
- myIterator=new BOPDS_Iterator(myAllocator);
- myIterator->SetRunParallel(myRunParallel);
- myIterator->SetDS(myDS);
- myIterator->Prepare(myContext, myUseOBB, myFuzzyValue);
+ myIterator = new BOPDS_Iterator (myAllocator);
+ myIterator->SetRunParallel (myRunParallel);
+ myIterator->SetDS (myDS);
+ myIterator->Prepare (myContext, myUseOBB, myFuzzyValue);
//
// 4 NonDestructive flag
SetNonDestructive();
}
+
//=======================================================================
// function: Perform
// purpose:
//=======================================================================
-void BOPAlgo_PaveFiller::Perform()
+void BOPAlgo_PaveFiller::Perform (const Message_ProgressRange& theRange)
{
try {
OCC_CATCH_SIGNALS
- //
- PerformInternal();
+ //
+ PerformInternal (theRange);
}
//
catch (Standard_Failure const&) {
AddError (new BOPAlgo_AlertIntersectionFailed);
- }
+ }
}
+
//=======================================================================
// function: PerformInternal
// purpose:
//=======================================================================
-void BOPAlgo_PaveFiller::PerformInternal()
+void BOPAlgo_PaveFiller::PerformInternal (const Message_ProgressRange& theRange)
{
- Init();
+ Message_ProgressScope aPS (theRange, "Performing intersection of shapes", 100);
+
+ Init (aPS.Next (5));
if (HasErrors()) {
- return;
+ return;
}
+
+ // Compute steps of the PI
+ BOPAlgo_PISteps aSteps (PIOperation_Last);
+ analyzeProgress (95, aSteps);
//
- Prepare();
+ Prepare (aPS.Next (aSteps.GetStep (PIOperation_Prepare)));
if (HasErrors()) {
- return;
+ return;
}
// 00
- PerformVV();
+ PerformVV (aPS.Next (aSteps.GetStep (PIOperation_PerformVV)));
if (HasErrors()) {
- return;
+ return;
}
// 01
- PerformVE();
+ PerformVE (aPS.Next (aSteps.GetStep (PIOperation_PerformVE)));
if (HasErrors()) {
- return;
+ return;
}
//
UpdatePaveBlocksWithSDVertices();
// 11
- PerformEE();
+ PerformEE (aPS.Next (aSteps.GetStep (PIOperation_PerformEE)));
if (HasErrors()) {
- return;
+ return;
}
UpdatePaveBlocksWithSDVertices();
// 02
- PerformVF();
+ PerformVF (aPS.Next (aSteps.GetStep (PIOperation_PerformVF)));
if (HasErrors()) {
- return;
+ return;
}
UpdatePaveBlocksWithSDVertices();
// 12
- PerformEF();
+ PerformEF (aPS.Next (aSteps.GetStep (PIOperation_PerformEF)));
if (HasErrors()) {
- return;
+ return;
}
UpdatePaveBlocksWithSDVertices();
UpdateInterfsWithSDVertices();
// Repeat Intersection with increased vertices
- RepeatIntersection();
+ RepeatIntersection (aPS.Next (aSteps.GetStep (PIOperation_RepeatIntersection)));
if (HasErrors())
return;
-
// Force intersection of edges after increase
// of the tolerance values of their vertices
- ForceInterfEE();
+ ForceInterfEE (aPS.Next (aSteps.GetStep (PIOperation_ForceInterfEE)));
+ if (HasErrors())
+ {
+ return;
+ }
// Force Edge/Face intersection after increase
// of the tolerance values of their vertices
- ForceInterfEF();
+ ForceInterfEF (aPS.Next (aSteps.GetStep (PIOperation_ForceInterfEF)));
+ if (HasErrors())
+ {
+ return;
+ }
//
// 22
- PerformFF();
+ PerformFF (aPS.Next (aSteps.GetStep (PIOperation_PerformFF)));
if (HasErrors()) {
- return;
+ return;
}
//
UpdateBlocksWithSharedVertices();
//
myDS->RefineFaceInfoIn();
//
- MakeSplitEdges();
+ MakeSplitEdges (aPS.Next (aSteps.GetStep (PIOperation_MakeSplitEdges)));
if (HasErrors()) {
return;
}
//
UpdatePaveBlocksWithSDVertices();
//
- MakeBlocks();
+ MakeBlocks (aPS.Next (aSteps.GetStep (PIOperation_MakeBlocks)));
if (HasErrors()) {
- return;
+ return;
}
//
CheckSelfInterference();
//
RemoveMicroEdges();
//
- MakePCurves();
+ MakePCurves (aPS.Next (aSteps.GetStep (PIOperation_MakePCurves)));
if (HasErrors()) {
- return;
+ return;
}
//
- ProcessDE();
+ ProcessDE (aPS.Next (aSteps.GetStep (PIOperation_ProcessDE)));
if (HasErrors()) {
- return;
+ return;
}
}
// function: RepeatIntersection
// purpose:
//=======================================================================
-void BOPAlgo_PaveFiller::RepeatIntersection()
+void BOPAlgo_PaveFiller::RepeatIntersection (const Message_ProgressRange& theRange)
{
// Find all vertices with increased tolerance
TColStd_MapOfInteger anExtraInterfMap;
const Standard_Integer aNbS = myDS->NbSourceShapes();
+ Message_ProgressScope aPS (theRange, "Repeat intersection", 3);
for (Standard_Integer i = 0; i < aNbS; ++i)
{
- const BOPDS_ShapeInfo& aSI = myDS->ShapeInfo(i);
+ const BOPDS_ShapeInfo& aSI = myDS->ShapeInfo (i);
if (aSI.ShapeType() != TopAbs_VERTEX)
continue;
// Check if the tolerance of the original vertex has been increased
- if (myIncreasedSS.Contains(i))
+ if (myIncreasedSS.Contains (i))
{
- anExtraInterfMap.Add(i);
+ anExtraInterfMap.Add (i);
continue;
}
// Check if the vertex created a new vertex with greater tolerance
Standard_Integer nVSD;
- if (!myDS->HasShapeSD(i, nVSD))
+ if (!myDS->HasShapeSD (i, nVSD))
continue;
- if (myIncreasedSS.Contains(nVSD))
- anExtraInterfMap.Add(i);
+ if (myIncreasedSS.Contains (nVSD))
+ anExtraInterfMap.Add (i);
}
if (anExtraInterfMap.IsEmpty())
return;
// Update iterator of pairs of shapes with interfering boxes
- myIterator->IntersectExt(anExtraInterfMap);
+ myIterator->IntersectExt (anExtraInterfMap);
// Perform intersections with vertices
- PerformVV();
+
+ PerformVV (aPS.Next());
if (HasErrors())
return;
UpdatePaveBlocksWithSDVertices();
- PerformVE();
+ PerformVE (aPS.Next());
if (HasErrors())
return;
UpdatePaveBlocksWithSDVertices();
- PerformVF();
+ PerformVF (aPS.Next());
if (HasErrors())
return;
UpdatePaveBlocksWithSDVertices();
UpdateInterfsWithSDVertices();
}
+
+
+//=======================================================================
+// function: fillPISteps
+// purpose:
+//=======================================================================
+void BOPAlgo_PaveFiller::fillPIConstants (const Standard_Real theWhole,
+ BOPAlgo_PISteps& theSteps) const
+{
+ if (!myNonDestructive)
+ {
+ theSteps.SetStep (PIOperation_Prepare, 1 * theWhole / 100.);
+ }
+}
+
+//=======================================================================
+// function: fillPISteps
+// purpose:
+//=======================================================================
+void BOPAlgo_PaveFiller::fillPISteps (BOPAlgo_PISteps& theSteps) const
+{
+ // Get number of all intersecting pairs
+ Standard_Integer aVVSize = 0, aVESize = 0, aEESize = 0, aVFSize = 0, aEFSize = 0, aFFSize = 0;
+
+ myIterator->Initialize (TopAbs_VERTEX, TopAbs_VERTEX);
+ aVVSize = myIterator->ExpectedLength();
+
+ myIterator->Initialize (TopAbs_VERTEX, TopAbs_EDGE);
+ aVESize = myIterator->ExpectedLength();
+
+ myIterator->Initialize (TopAbs_EDGE, TopAbs_EDGE);
+ aEESize = myIterator->ExpectedLength();
+
+ myIterator->Initialize (TopAbs_VERTEX, TopAbs_FACE);
+ aVFSize = myIterator->ExpectedLength();
+
+ if (myGlue != BOPAlgo_GlueFull)
+ {
+ myIterator->Initialize (TopAbs_EDGE, TopAbs_FACE);
+ aEFSize = myIterator->ExpectedLength();
+ }
+
+ myIterator->Initialize (TopAbs_FACE, TopAbs_FACE);
+ aFFSize = myIterator->ExpectedLength();
+
+ theSteps.SetStep (PIOperation_PerformVV, aVVSize);
+ theSteps.SetStep (PIOperation_PerformVE, 2 * aVESize);
+ theSteps.SetStep (PIOperation_PerformEE, 5 * aEESize);
+ theSteps.SetStep (PIOperation_PerformVF, 5 * aVFSize);
+ theSteps.SetStep (PIOperation_PerformEF, 10 * aEFSize);
+ theSteps.SetStep (PIOperation_RepeatIntersection, 0.2 * (aVVSize + aVESize + aVFSize));
+ theSteps.SetStep (PIOperation_ForceInterfEE, 2 * aEESize);
+ theSteps.SetStep (PIOperation_ForceInterfEF, 2 * aEFSize);
+ theSteps.SetStep (PIOperation_PerformFF, (myGlue == BOPAlgo_GlueFull ? 1 : 30) * aFFSize);
+ theSteps.SetStep (PIOperation_MakeSplitEdges, aEESize);
+ theSteps.SetStep (PIOperation_MakeBlocks, (myGlue == BOPAlgo_GlueFull ? 0 : 5) * aFFSize);
+ theSteps.SetStep (PIOperation_MakePCurves, myAvoidBuildPCurve ? 0 : 0.2 * (aEESize + aEFSize));
+ theSteps.SetStep (PIOperation_ProcessDE, 0.1 * aEESize);
+}
//! a copy of a sub-shape is created in the result if it is needed to be updated.
Standard_EXPORT Standard_Boolean NonDestructive() const;
- Standard_EXPORT virtual void Perform() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Perform(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean IsPrimary() const;
- Standard_EXPORT virtual void PerformInternal();
+ Standard_EXPORT virtual void PerformInternal(const Message_ProgressRange& theRange);
Standard_EXPORT virtual void Clear() Standard_OVERRIDE;
- Standard_EXPORT virtual void Init();
+ Standard_EXPORT virtual void Init(const Message_ProgressRange& theRange);
- Standard_EXPORT void Prepare();
+ Standard_EXPORT void Prepare(const Message_ProgressRange& theRange);
- Standard_EXPORT virtual void PerformVV();
+ Standard_EXPORT virtual void PerformVV(const Message_ProgressRange& theRange);
- Standard_EXPORT virtual void PerformVE();
+ Standard_EXPORT virtual void PerformVE(const Message_ProgressRange& theRange);
//! Performs the intersection of the vertices with edges.
Standard_EXPORT void IntersectVE(const BOPDS_IndexedDataMapOfPaveBlockListOfInteger& theVEPairs,
+ const Message_ProgressRange& theRange,
const Standard_Boolean bAddInterfs = Standard_True);
//! Splits the Pave Blocks of the given edges with the extra paves.<br>
//! of the Pave Blocks will also form a Common Block.
Standard_EXPORT void SplitPaveBlocks(const TColStd_MapOfInteger& theMEdges,
const Standard_Boolean theAddInterfs);
+
+ Standard_EXPORT virtual void PerformVF(const Message_ProgressRange& theRange);
- Standard_EXPORT virtual void PerformVF();
-
- Standard_EXPORT virtual void PerformEE();
+ Standard_EXPORT virtual void PerformEE(const Message_ProgressRange& theRange);
- Standard_EXPORT virtual void PerformEF();
+ Standard_EXPORT virtual void PerformEF(const Message_ProgressRange& theRange);
- Standard_EXPORT virtual void PerformFF();
+ Standard_EXPORT virtual void PerformFF(const Message_ProgressRange& theRange);
Standard_EXPORT void TreatVerticesEE();
Standard_EXPORT void MakeSDVerticesFF(const TColStd_DataMapOfIntegerListOfInteger& aDMVLV,
TColStd_DataMapOfIntegerInteger& theDMNewSD);
- Standard_EXPORT void MakeSplitEdges();
+ Standard_EXPORT void MakeSplitEdges(const Message_ProgressRange& theRange);
- Standard_EXPORT void MakeBlocks();
+ Standard_EXPORT void MakeBlocks(const Message_ProgressRange& theRange);
- Standard_EXPORT void MakePCurves();
+ Standard_EXPORT void MakePCurves(const Message_ProgressRange& theRange);
Standard_EXPORT Standard_Integer MakeSDVertices(const TColStd_ListOfInteger& theVertIndices,
const Standard_Boolean theAddInterfs = 1);
- Standard_EXPORT void ProcessDE();
+ Standard_EXPORT void ProcessDE(const Message_ProgressRange& theRange);
Standard_EXPORT void FillShrunkData (Handle(BOPDS_PaveBlock)& thePB);
//! Performs intersection of new vertices, obtained in E/E and E/F intersections
Standard_EXPORT void PerformNewVertices(BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& theMVCPB,
const Handle(NCollection_BaseAllocator)& theAllocator,
+ const Message_ProgressRange& theRange,
const Standard_Boolean theIsEEIntersection = Standard_True);
Standard_EXPORT Standard_Boolean CheckFacePaves (const TopoDS_Vertex& theVnew,
TColStd_DataMapOfIntegerInteger& theDMNewSD,
const BOPDS_IndexedMapOfPaveBlock& theMicroPB,
const TopTools_IndexedMapOfShape& theVertsOnRejectedPB,
- const Handle(NCollection_BaseAllocator)& theAllocator);
+ const Handle(NCollection_BaseAllocator)& theAllocator,
+ const Message_ProgressRange& theRange);
Standard_EXPORT void FindPaveBlocks (const Standard_Integer theV,
const Standard_Integer theF,
//! If the intersection says that the section edge is lying on the face
//! it will be added into FaceInfo structure of the face as IN edge
//! and will be used for splitting.
- Standard_EXPORT void PutSEInOtherFaces();
+ Standard_EXPORT void PutSEInOtherFaces(const Message_ProgressRange& theRange);
//! Analyzes the results of interferences of sub-shapes of the shapes
//! looking for self-interfering entities by the following rules:<br>
const TopoDS_Shape& theS2);
//! Repeat intersection of sub-shapes with increased vertices.
- Standard_EXPORT void RepeatIntersection();
+ Standard_EXPORT void RepeatIntersection(const Message_ProgressRange& theRange);
//! Updates vertices of CommonBlocks with real tolerance of CB.
Standard_EXPORT void UpdateVerticesOfCB();
//! The method looks for the additional common blocks among pairs of edges
//! with the same bounding vertices.
- Standard_EXPORT void ForceInterfEE();
+ Standard_EXPORT void ForceInterfEE(const Message_ProgressRange& theRange);
//! The method looks for the additional edge/face common blocks
//! among pairs of edge/face having the same vertices.
- Standard_EXPORT void ForceInterfEF();
+ Standard_EXPORT void ForceInterfEF(const Message_ProgressRange& theRange);
//! Performs intersection of given pave blocks
//! with all faces from arguments.
Standard_EXPORT void ForceInterfEF(const BOPDS_IndexedMapOfPaveBlock& theMPB,
+ const Message_ProgressRange& theRange,
const Standard_Boolean theAddInterf);
//! When all section edges are created and no increase of the tolerance
{}
};
+protected: //! Analyzing Progress steps
+
+ //! Filling steps for constant operations
+ Standard_EXPORT void fillPIConstants(const Standard_Real theWhole, BOPAlgo_PISteps& theSteps) const Standard_OVERRIDE;
+ //! Filling steps for all other operations
+ Standard_EXPORT void fillPISteps(BOPAlgo_PISteps& theSteps) const Standard_OVERRIDE;
+
protected: //! Fields
TopTools_ListOfShape myArguments;
// function: PerformVV
// purpose:
//=======================================================================
-void BOPAlgo_PaveFiller::PerformVV()
+void BOPAlgo_PaveFiller::PerformVV(const Message_ProgressRange& theRange)
{
Standard_Integer n1, n2, iFlag, aSize;
Handle(NCollection_BaseAllocator) aAllocator;
//
myIterator->Initialize(TopAbs_VERTEX, TopAbs_VERTEX);
aSize=myIterator->ExpectedLength();
+ Message_ProgressScope aPS(theRange, NULL, 2.);
if (!aSize) {
return;
}
NCollection_List<TColStd_ListOfInteger> aMBlocks(aAllocator);
//
// 1. Map V/LV
- for (; myIterator->More(); myIterator->Next()) {
+ // Split progress range on intersection stage and making blocks. Display only intersection stage.
+ Message_ProgressScope aPSLoop(aPS.Next(1.), "Performing Vertex-Vertex intersection", aSize);
+ for (; myIterator->More(); myIterator->Next(), aPSLoop.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
myIterator->Value(n1, n2);
//
if (myDS->HasInterf(n1, n2))
// 3. Make vertices
NCollection_List<TColStd_ListOfInteger>::Iterator aItB(aMBlocks);
for (; aItB.More(); aItB.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const TColStd_ListOfInteger& aLI = aItB.Value();
MakeSDVertices(aLI);
}
TColStd_DataMapOfIntegerInteger& aDMII=myDS->ShapesSD();
aItDMII.Initialize(aDMII);
for (; aItDMII.More(); aItDMII.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
n1=aItDMII.Key();
myDS->InitPaveBlocksForVertex(n1);
}
}
//=======================================================================
-// function: PerformVV
+// function: MakeSDVertices
// purpose:
//=======================================================================
Standard_Integer BOPAlgo_PaveFiller::MakeSDVertices
//class : BOPAlgo_VertexEdge
//purpose :
//=======================================================================
-class BOPAlgo_VertexEdge : public BOPAlgo_Algo {
+class BOPAlgo_VertexEdge : public BOPAlgo_ParallelAlgo {
public:
DEFINE_STANDARD_ALLOC
BOPAlgo_VertexEdge() :
- BOPAlgo_Algo(),
+ BOPAlgo_ParallelAlgo(),
myIV(-1), myIE(-1), myFlag(-1), myT(-1.), myTolVNew(-1.) {
};
//
}
//
virtual void Perform() {
- BOPAlgo_Algo::UserBreak();
+ Message_ProgressScope aPS(myProgressRange, NULL, 1);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
try
{
OCC_CATCH_SIGNALS
// function: PerformVE
// purpose:
//=======================================================================
-void BOPAlgo_PaveFiller::PerformVE()
+void BOPAlgo_PaveFiller::PerformVE(const Message_ProgressRange& theRange)
{
FillShrunkData(TopAbs_VERTEX, TopAbs_EDGE);
//
myIterator->Initialize(TopAbs_VERTEX, TopAbs_EDGE);
+ Message_ProgressScope aPS(theRange, NULL, 1);
+
Standard_Integer iSize = myIterator->ExpectedLength();
if (!iSize) {
return;
// Prepare pairs for intersection
BOPDS_IndexedDataMapOfPaveBlockListOfInteger aMVEPairs;
for (; myIterator->More(); myIterator->Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
Standard_Integer nV, nE;
myIterator->Value(nV, nE);
//
pLV->Append(nV);
}
//
- IntersectVE(aMVEPairs);
+ IntersectVE(aMVEPairs, aPS.Next());
}
//=======================================================================
//=======================================================================
void BOPAlgo_PaveFiller::IntersectVE
(const BOPDS_IndexedDataMapOfPaveBlockListOfInteger& theVEPairs,
+ const Message_ProgressRange& theRange,
const Standard_Boolean theAddInterfs)
{
Standard_Integer i, aNbVE = theVEPairs.Extent();
// intersection of the same SD vertex with edge
NCollection_DataMap<BOPDS_Pair, TColStd_ListOfInteger, BOPDS_PairMapHasher> aDMVSD;
//
+ Message_ProgressScope aPSOuter(theRange, NULL, 10);
for (i = 1; i <= aNbVE; ++i) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const Handle(BOPDS_PaveBlock)& aPB = theVEPairs.FindKey(i);
Standard_Integer nE = aPB->OriginalEdge();
//
aVESolver.SetEdge(aE);
aVESolver.SetPaveBlock(aPB);
aVESolver.SetFuzzyValue(myFuzzyValue);
- if (myProgressScope != NULL)
- {
- aVESolver.SetProgressIndicator(*myProgressScope);
- }
}
}
//
+ aNbVE = aVVE.Length();
+
+ Message_ProgressScope aPS(aPSOuter.Next(9), "Performing Vertex-Edge intersection", aNbVE);
+ for (i = 0; i < aNbVE; i++)
+ {
+ BOPAlgo_VertexEdge& aVESolver = aVVE.ChangeValue(i);
+ aVESolver.SetProgressRange(aPS.Next());
+ }
// Perform intersection
//=============================================================
BOPTools_Parallel::Perform (myRunParallel, aVVE, myContext);
//=============================================================
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
//
// Keep the modified edges for further update
TColStd_MapOfInteger aMEdges;
//
// Analyze intersections
- aNbVE = aVVE.Length();
for (i = 0; i < aNbVE; ++i) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const BOPAlgo_VertexEdge& aVESolver = aVVE(i);
if (aVESolver.Flag() != 0) {
if (aVESolver.HasErrors())
//=======================================================================
class BOPAlgo_EdgeEdge :
public IntTools_EdgeEdge,
- public BOPAlgo_Algo {
+ public BOPAlgo_ParallelAlgo {
public:
//
BOPAlgo_EdgeEdge():
IntTools_EdgeEdge(),
- BOPAlgo_Algo() {
+ BOPAlgo_ParallelAlgo() {
};
//
virtual ~BOPAlgo_EdgeEdge(){
}
//
virtual void Perform() {
- BOPAlgo_Algo::UserBreak();
+ Message_ProgressScope aPS(myProgressRange, NULL, 1);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
TopoDS_Edge anE1 = myEdge1, anE2 = myEdge2;
Standard_Boolean hasTrsf = false;
try
// function: PerformEE
// purpose:
//=======================================================================
-void BOPAlgo_PaveFiller::PerformEE()
+void BOPAlgo_PaveFiller::PerformEE(const Message_ProgressRange& theRange)
{
FillShrunkData(TopAbs_EDGE, TopAbs_EDGE);
//
myIterator->Initialize(TopAbs_EDGE, TopAbs_EDGE);
Standard_Integer iSize = myIterator->ExpectedLength();
+ Message_ProgressScope aPSOuter(theRange, NULL, 10);
if (!iSize) {
return;
}
aEEs.SetIncrement(iSize);
//
for (; myIterator->More(); myIterator->Next()) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
myIterator->Value(nE1, nE2);
//
const BOPDS_ShapeInfo& aSIE1=myDS->ShapeInfo(nE1);
//
aIt1.Initialize(aLPB1);
for (; aIt1.More(); aIt1.Next()) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
Bnd_Box aBB1;
//
Handle(BOPDS_PaveBlock)& aPB1=aIt1.ChangeValue();
anEdgeEdge.SetEdge2(aE2, aT21, aT22);
anEdgeEdge.SetBoxes (aBB1, aBB2);
anEdgeEdge.SetFuzzyValue(myFuzzyValue);
- if (myProgressScope != NULL)
- {
- anEdgeEdge.SetProgressIndicator(*myProgressScope);
- }
}//for (; aIt2.More(); aIt2.Next()) {
}//for (; aIt1.More(); aIt1.Next()) {
}//for (; myIterator->More(); myIterator->Next()) {
//
aNbEdgeEdge=aVEdgeEdge.Length();
+
+ Message_ProgressScope aPS(aPSOuter.Next(9), "Performing Edge-edge intersection", aNbEdgeEdge);
+ for (k = 0; k < aNbEdgeEdge; k++)
+ {
+ BOPAlgo_EdgeEdge& anEdgeEdge = aVEdgeEdge.ChangeValue(k);
+ anEdgeEdge.SetProgressRange(aPS.Next());
+ }
//======================================================
BOPTools_Parallel::Perform (myRunParallel, aVEdgeEdge);
//======================================================
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
//
for (k = 0; k < aNbEdgeEdge; ++k) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
Bnd_Box aBB1, aBB2;
//
BOPAlgo_EdgeEdge& anEdgeEdge=aVEdgeEdge(k);
}
//
for (i=1; i<=aNbCPrts; ++i) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const IntTools_CommonPrt& aCPart=aCPrts(i);
//
const TopoDS_Edge& aE1=aCPart.Edge1();
// Update vertices of common blocks with real CB tolerances
UpdateVerticesOfCB();
- PerformNewVertices(aMVCPB, aAllocator);
+ PerformNewVertices(aMVCPB, aAllocator, aPSOuter.Next());
+ if (HasErrors())
+ {
+ return;
+ }
//
if (aMEdges.Extent()) {
Standard_Integer aNbV = aMVCPB.Extent();
void BOPAlgo_PaveFiller::PerformNewVertices
(BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& theMVCPB,
const Handle(NCollection_BaseAllocator)& theAllocator,
+ const Message_ProgressRange& theRange,
const Standard_Boolean bIsEEIntersection)
{
Standard_Integer aNbV = theMVCPB.Extent();
BOPDS_VectorOfInterfEE& aEEs = myDS->InterfEE();
BOPDS_VectorOfInterfEF& aEFs = myDS->InterfEF();
//
+ // 4. Compute Extra Paves and split Pave blocks by the Extra paves
+ Message_ProgressScope aPS(theRange, NULL, 2);
Standard_Integer i, aNb = aImages.Extent();
- for (i = 1; i <= aNb; ++i) {
+ Message_ProgressScope aPS1(aPS.Next(), NULL, aNb + aNbV);
+ for (i = 1; i <= aNb; ++i, aPS1.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const TopoDS_Vertex& aV = TopoDS::Vertex(aImages.FindKey(i));
const TopTools_ListOfShape& aLVSD = aImages.FindFromIndex(i);
//
//
// 3. Map PaveBlock/ListOfVertices to add to this PaveBlock ->aMPBLI
BOPDS_IndexedDataMapOfPaveBlockListOfInteger aMPBLI(100, theAllocator);
- for (i = 1; i <= aNbV; ++i) {
+ for (i = 1; i <= aNbV; ++i, aPS1.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const BOPDS_CoupleOfPaveBlocks& aCPB = theMVCPB.FindFromIndex(i);
Standard_Integer iV = aCPB.Index();
//
}
}
}
- //
// 4. Compute Extra Paves and split Pave blocks by the Extra paves
- IntersectVE(aMPBLI, Standard_False);
+ IntersectVE(aMPBLI, aPS.Next(), Standard_False);
}
//=======================================================================
//function : TreatNewVertices
//function : ForceInterfEE
//purpose :
//=======================================================================
-void BOPAlgo_PaveFiller::ForceInterfEE()
+void BOPAlgo_PaveFiller::ForceInterfEE(const Message_ProgressRange& theRange)
{
// Now that we have vertices increased and unified, try to find additional
// common blocks among the pairs of edges.
// those pairs of pave blocks with the same bounding vertices.
Handle(NCollection_IncAllocator) anAlloc = new NCollection_IncAllocator;
-
+ Message_ProgressScope aPSOuter(theRange, NULL, 10);
// Initialize pave blocks for all vertices which participated in intersections
const Standard_Integer aNbS = myDS->NbSourceShapes();
for (Standard_Integer i = 0; i < aNbS; ++i)
if (myDS->HasInterf(i))
myDS->InitPaveBlocksForVertex(i);
}
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
}
-
// Fill the connection map from bounding vertices to pave blocks
// having those bounding vertices
NCollection_IndexedDataMap<BOPDS_Pair,
if (aSI.HasFlag())
// Degenerated edge
continue;
-
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const BOPDS_ListOfPaveBlock& aLPB = myDS->PaveBlocks(i);
BOPDS_ListIteratorOfListOfPaveBlock aItLPB(aLPB);
for (; aItLPB.More(); aItLPB.Next())
for (Standard_Integer i = 1; i <= aNbPB; ++i)
{
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const BOPDS_ListOfPaveBlock& aLPB = aPBMap(i);
if (aLPB.Extent() < 2)
continue;
{
anEdgeEdge.SetFuzzyValue(myFuzzyValue);
}
- if (myProgressScope != NULL)
- {
- anEdgeEdge.SetProgressIndicator(*myProgressScope);
- }
}
}
}
if (!aNbPairs)
return;
+ // close preparation step
+ aPSOuter.Next(0.7);
+
aPBMap.Clear();
aMPBFence.Clear();
anAlloc->Reset();
+ Message_ProgressScope aPS(aPSOuter.Next(9), "Checking for coinciding edges", aNbPairs);
+ for (Standard_Integer i = 0; i < aNbPairs; i++)
+ {
+ BOPAlgo_EdgeEdge& anEdgeEdge = aVEdgeEdge.ChangeValue(i);
+ anEdgeEdge.SetProgressRange(aPS.Next());
+ }
+
// Perform intersection of the found pairs
BOPTools_Parallel::Perform (myRunParallel, aVEdgeEdge);
-
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
BOPDS_VectorOfInterfEE& aEEs = myDS->InterfEE();
if (aEEs.IsEmpty())
aEEs.SetIncrement(10);
// intersection type only.
BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock aMPBLPB(1, anAlloc);
-
for (Standard_Integer i = 0; i < aNbPairs; ++i)
{
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
BOPAlgo_EdgeEdge& anEdgeEdge = aVEdgeEdge(i);
if (!anEdgeEdge.IsDone() || anEdgeEdge.HasErrors())
{
//class : BOPAlgo_VertexFace
//purpose :
//=======================================================================
-class BOPAlgo_VertexFace : public BOPAlgo_Algo {
+class BOPAlgo_VertexFace : public BOPAlgo_ParallelAlgo {
public:
DEFINE_STANDARD_ALLOC
BOPAlgo_VertexFace() :
- BOPAlgo_Algo(),
+ BOPAlgo_ParallelAlgo(),
myIV(-1), myIF(-1),
myFlag(-1), myT1(-1.), myT2(-1.), myTolVNew(-1.) {
}
}
//
virtual void Perform() {
- BOPAlgo_Algo::UserBreak();
+ Message_ProgressScope aPS(myProgressRange, NULL, 1);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
try
{
OCC_CATCH_SIGNALS
// function: PerformVF
// purpose:
//=======================================================================
-void BOPAlgo_PaveFiller::PerformVF()
+void BOPAlgo_PaveFiller::PerformVF(const Message_ProgressRange& theRange)
{
myIterator->Initialize(TopAbs_VERTEX, TopAbs_FACE);
Standard_Integer iSize = myIterator->ExpectedLength();
//
Standard_Integer nV, nF;
//
+ Message_ProgressScope aPSOuter(theRange, NULL, 10);
if (myGlue == BOPAlgo_GlueFull) {
// there is no need to intersect vertices with faces in this mode
// just initialize FaceInfo for all faces
// Avoid repeated intersection of the same vertex with face in case
// the group of vertices formed a single SD vertex
NCollection_DataMap<BOPDS_Pair, TColStd_MapOfInteger, BOPDS_PairMapHasher> aMVFPairs;
-
for (; myIterator->More(); myIterator->Next()) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
myIterator->Value(nV, nF);
//
if (myDS->IsSubShape(nV, nF)) {
aVertexFace.SetVertex(aV);
aVertexFace.SetFace(aF);
aVertexFace.SetFuzzyValue(myFuzzyValue);
- if (myProgressScope != NULL)
- {
- aVertexFace.SetProgressIndicator(*myProgressScope);
- }
+
}//for (; myIterator->More(); myIterator->Next()) {
//
aNbVF=aVVF.Length();
+ Message_ProgressScope aPS(aPSOuter.Next(9), "Performing Vertex-Face intersection", aNbVF);
+ for (k = 0; k < aNbVF; k++)
+ {
+ BOPAlgo_VertexFace& aVertexFace = aVVF.ChangeValue(k);
+ aVertexFace.SetProgressRange(aPS.Next());
+ }
//================================================================
BOPTools_Parallel::Perform (myRunParallel, aVVF, myContext);
//================================================================
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
//
for (k=0; k < aNbVF; ++k) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const BOPAlgo_VertexFace& aVertexFace=aVVF(k);
//
iFlag=aVertexFace.Flag();
//=======================================================================
class BOPAlgo_EdgeFace :
public IntTools_EdgeFace,
- public BOPAlgo_Algo {
+ public BOPAlgo_ParallelAlgo {
public:
DEFINE_STANDARD_ALLOC
BOPAlgo_EdgeFace() :
IntTools_EdgeFace(),
- BOPAlgo_Algo(),
+ BOPAlgo_ParallelAlgo(),
myIE(-1), myIF(-1) {
};
//
}
//
virtual void Perform() {
- BOPAlgo_Algo::UserBreak();
+ Message_ProgressScope aPS(myProgressRange, NULL, 1);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
TopoDS_Face aFace = myFace;
TopoDS_Edge anEdge = myEdge;
Standard_Boolean hasTrsf = false;
//function : PerformEF
//purpose :
//=======================================================================
-void BOPAlgo_PaveFiller::PerformEF()
+void BOPAlgo_PaveFiller::PerformEF(const Message_ProgressRange& theRange)
{
FillShrunkData(TopAbs_EDGE, TopAbs_FACE);
//
myIterator->Initialize(TopAbs_EDGE, TopAbs_FACE);
+ Message_ProgressScope aPSOuter(theRange, NULL, 10);
Standard_Integer iSize = myIterator->ExpectedLength();
if (!iSize) {
return;
aEFs.SetIncrement(iSize);
//
for (; myIterator->More(); myIterator->Next()) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
myIterator->Value(nE, nF);
//
const BOPDS_ShapeInfo& aSIE=myDS->ShapeInfo(nE);
BOPDS_ListOfPaveBlock& aLPB=myDS->ChangePaveBlocks(nE);
aIt.Initialize(aLPB);
for (; aIt.More(); aIt.Next()) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
Handle(BOPDS_PaveBlock)& aPB=aIt.ChangeValue();
//
const Handle(BOPDS_PaveBlock) aPBR=myDS->RealPaveBlock(aPB);
aEdgeFace.SetBoxes (myDS->ShapeInfo(nE).Box(), myDS->ShapeInfo (nF).Box());
aEdgeFace.SetFuzzyValue(myFuzzyValue);
aEdgeFace.UseQuickCoincidenceCheck(bExpressCompute);
- //
+
IntTools_Range aSR(aTS1, aTS2);
- IntTools_Range anewSR=aSR;
+ IntTools_Range anewSR = aSR;
BOPTools_AlgoTools::CorrectRange(aE, aF, aSR, anewSR);
aEdgeFace.SetNewSR(anewSR);
//
IntTools_Range aPBRange(aT1, aT2);
aSR = aPBRange;
BOPTools_AlgoTools::CorrectRange(aE, aF, aSR, aPBRange);
- aEdgeFace.SetRange (aPBRange);
- if (myProgressScope != NULL)
- {
- aEdgeFace.SetProgressIndicator(*myProgressScope);
- }
+ aEdgeFace.SetRange(aPBRange);
+ //
// Save the pair to avoid their forced intersection
BOPDS_MapOfPaveBlock* pMPB = myFPBDone.ChangeSeek(nF);
if (!pMPB)
}//for (; myIterator->More(); myIterator->Next()) {
//
aNbEdgeFace=aVEdgeFace.Length();
+ Message_ProgressScope aPS(aPSOuter.Next(9), "Performing Edge-Face intersection", aNbEdgeFace);
+ for (Standard_Integer index = 0; index < aNbEdgeFace; index++)
+ {
+ BOPAlgo_EdgeFace& aEdgeFace = aVEdgeFace.ChangeValue(index);
+ aEdgeFace.SetProgressRange(aPS.Next());
+ }
//=================================================================
BOPTools_Parallel::Perform (myRunParallel, aVEdgeFace, myContext);
//=================================================================
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
//
for (k=0; k < aNbEdgeFace; ++k) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
BOPAlgo_EdgeFace& aEdgeFace=aVEdgeFace(k);
if (!aEdgeFace.IsDone() || aEdgeFace.HasErrors()) {
// Warn about failed intersection of sub-shapes
}
//
for (i=1; i<=aNbCPrts; ++i) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const IntTools_CommonPrt& aCPart=aCPrts(i);
aType=aCPart.Type();
switch (aType) {
//=========================================
BOPAlgo_Tools::PerformCommonBlocks(aMPBLI, aAllocator, myDS, myContext);
UpdateVerticesOfCB();
- PerformNewVertices(aMVCPB, aAllocator, Standard_False);
+ PerformNewVertices(aMVCPB, aAllocator, aPSOuter.Next(1), Standard_False);
+ if (HasErrors())
+ {
+ return;
+ }
//
// Update FaceInfoIn for all faces having EF common parts
myDS->UpdateFaceInfoIn (aMIEFC);
//function : ForceInterfEF
//purpose :
//=======================================================================
-void BOPAlgo_PaveFiller::ForceInterfEF()
+void BOPAlgo_PaveFiller::ForceInterfEF(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPS(theRange, NULL, 1);
if (!myIsPrimary)
return;
// Degenerated edge
continue;
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const BOPDS_ListOfPaveBlock& aLPB = myDS->PaveBlocks(nE);
BOPDS_ListIteratorOfListOfPaveBlock aItLPB(aLPB);
for (; aItLPB.More(); aItLPB.Next())
}
// Perform intersection of collected pave blocks with faces
- ForceInterfEF(aMPB, Standard_True);
+
+ ForceInterfEF(aMPB, aPS.Next(), Standard_True);
}
//=======================================================================
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::ForceInterfEF(const BOPDS_IndexedMapOfPaveBlock& theMPB,
+ const Message_ProgressRange& theRange,
const Standard_Boolean theAddInterf)
{
+ // Split progress on preparation, intersection and post-treatment stages
+ Message_ProgressScope aPSOuter(theRange, NULL, 10);
if (theMPB.IsEmpty())
return;
-
// Fill the tree with bounding boxes of the pave blocks
BOPTools_BoxTree aBBTree;
if (!aPB->HasShrunkData())
continue;
}
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
Standard_Real f, l;
Bnd_Box aPBBox;
// Face has no face info
continue;
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
+
const Bnd_Box& aBoxF = aSI.Box();
BOPTools_BoxTreeSelector aSelector;
aSelector.SetBox(Bnd_Tools::Bnd2BVH(aBoxF));
aEdgeFace.SetFuzzyValue(myFuzzyValue + aTolAdd);
aEdgeFace.UseQuickCoincidenceCheck(Standard_True);
aEdgeFace.SetRange(IntTools_Range(aPB->Pave1().Parameter(), aPB->Pave2().Parameter()));
- if (myProgressScope != NULL)
- {
- aEdgeFace.SetProgressIndicator(*myProgressScope);
- }
}
}
}
Standard_Integer aNbEFs = aVEdgeFace.Length();
if (!aNbEFs)
+ {
return;
+ }
+
+ // close preparation step
+ aPSOuter.Next(0.7);
aPBMap.Clear();
anAlloc->Reset();
+ Message_ProgressScope aPS(aPSOuter.Next(9), "Checking for edges coinciding with faces", aNbEFs);
+ for (Standard_Integer i = 0; i < aNbEFs; i++)
+ {
+ BOPAlgo_EdgeFace& aEdgeFace = aVEdgeFace.ChangeValue(i);
+ aEdgeFace.SetProgressRange(aPS.Next());
+ }
// Perform intersection of the found pairs
BOPTools_Parallel::Perform (myRunParallel, aVEdgeFace, myContext);
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
BOPDS_VectorOfInterfEF& aEFs = myDS->InterfEF();
if (theAddInterf && aEFs.IsEmpty())
// Collect all pairs for common block creation
BOPDS_IndexedDataMapOfPaveBlockListOfInteger aMPBLI(1, anAlloc);
-
for (Standard_Integer i = 0; i < aNbEFs; ++i)
{
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
BOPAlgo_EdgeFace& anEdgeFace = aVEdgeFace(i);
if (!anEdgeFace.IsDone() || anEdgeFace.HasErrors())
{
//=======================================================================
class BOPAlgo_FaceFace :
public IntTools_FaceFace,
- public BOPAlgo_Algo {
+ public BOPAlgo_ParallelAlgo {
public:
DEFINE_STANDARD_ALLOC
BOPAlgo_FaceFace() :
IntTools_FaceFace(),
- BOPAlgo_Algo(),
+ BOPAlgo_ParallelAlgo(),
myIF1(-1), myIF2(-1), myTolFF(1.e-7) {
}
//
const gp_Trsf& Trsf() const { return myTrsf; }
//
virtual void Perform() {
- BOPAlgo_Algo::UserBreak();
+ Message_ProgressScope aPS(myProgressRange, NULL, 1);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
try
{
OCC_CATCH_SIGNALS
//function : PerformFF
//purpose :
//=======================================================================
-void BOPAlgo_PaveFiller::PerformFF()
+void BOPAlgo_PaveFiller::PerformFF(const Message_ProgressRange& theRange)
{
myIterator->Initialize(TopAbs_FACE, TopAbs_FACE);
Standard_Integer iSize = myIterator->ExpectedLength();
+ Message_ProgressScope aPSOuter(theRange, NULL, 1);
if (!iSize) {
return;
}
// Initialize interferences
myIterator->Initialize(TopAbs_FACE, TopAbs_FACE);
for (; myIterator->More(); myIterator->Next()) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
myIterator->Value(nF1, nF2);
if (myGlue == BOPAlgo_GlueOff)
//
aFaceFace.SetParameters(bApprox, bCompC2D1, bCompC2D2, anApproxTol);
aFaceFace.SetFuzzyValue(myFuzzyValue);
- if (myProgressScope != NULL)
- {
- aFaceFace.SetProgressIndicator(*myProgressScope);
- }
}
else {
// for the Glue mode just add all interferences of that type
}
}//for (; myIterator->More(); myIterator->Next()) {
//
+ Standard_Integer k, aNbFaceFace = aVFaceFace.Length();;
+ Message_ProgressScope aPS(aPSOuter.Next(), "Performing Face-Face intersection", aNbFaceFace);
+ for (k = 0; k < aNbFaceFace; k++)
+ {
+ BOPAlgo_FaceFace& aFaceFace = aVFaceFace.ChangeValue(k);
+ aFaceFace.SetProgressRange(aPS.Next());
+ }
//======================================================
// Perform intersection
BOPTools_Parallel::Perform (myRunParallel, aVFaceFace);
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
//======================================================
// Treatment of the results
- Standard_Integer k, aNbFaceFace = aVFaceFace.Length();
+
for (k = 0; k < aNbFaceFace; ++k) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
BOPAlgo_FaceFace& aFaceFace = aVFaceFace(k);
aFaceFace.Indices(nF1, nF2);
if (!aFaceFace.IsDone() || aFaceFace.HasErrors()) {
//
BOPDS_VectorOfCurve& aVNC = aFF.ChangeCurves();
for (Standard_Integer i = 1; i <= aNbCurves; ++i) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
Bnd_Box aBox;
const IntTools_Curve& aIC = aCvsX(i);
Standard_Boolean bIsValid = IntTools_Tools::CheckCurve(aIC, aBox);
//function : MakeBlocks
//purpose :
//=======================================================================
-void BOPAlgo_PaveFiller::MakeBlocks()
+void BOPAlgo_PaveFiller::MakeBlocks(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPSOuter(theRange, NULL, 4);
if (myGlue != BOPAlgo_GlueOff) {
return;
}
//
BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
Standard_Integer aNbFF = aFFs.Length();
+ Message_ProgressScope aPS(aPSOuter.Next(), "Building section edges", aNbFF);
if (!aNbFF) {
return;
}
// Map of PaveBlocks with the faces to which it has to be added
BOPAlgo_DataMapOfPaveBlockListOfInteger aPBFacesMap;
//
- for (i=0; i<aNbFF; ++i) {
- //
- UserBreak();
+ for (i=0; i<aNbFF; ++i, aPS.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
//
BOPDS_InterfFF& aFF=aFFs(i);
aFF.Indices(nF1, nF2);
// post treatment
MakeSDVerticesFF(aDMVLV, aDMNewSD);
- PostTreatFF(aMSCPB, aDMExEdges, aDMNewSD, aMicroPB, aVertsOnRejectedPB, aAllocator);
+ PostTreatFF(aMSCPB, aDMExEdges, aDMNewSD, aMicroPB, aVertsOnRejectedPB, aAllocator, aPSOuter.Next(2));
if (HasErrors()) {
return;
}
//
// Treat possible common zones by trying to put each section edge
// into all faces, not participated in creation of that edge, as IN edge
- PutSEInOtherFaces();
+
+ PutSEInOtherFaces(aPSOuter.Next());
//
//-----------------------------------------------------scope t
aMVStick.Clear();
TColStd_DataMapOfIntegerInteger& aDMNewSD,
const BOPDS_IndexedMapOfPaveBlock& theMicroPB,
const TopTools_IndexedMapOfShape& theVertsOnRejectedPB,
- const Handle(NCollection_BaseAllocator)& theAllocator)
+ const Handle(NCollection_BaseAllocator)& theAllocator,
+ const Message_ProgressRange& theRange)
{
Standard_Integer aNbS = theMSCPB.Extent();
if (!aNbS) {
}
}
//
+ Message_ProgressScope aPS(theRange, "Intersection of section edges", 1);
+
// 2 Fuse shapes
- if (myProgressScope != NULL)
- {
- aPF.SetProgressIndicator(*myProgressScope);
- }
aPF.SetRunParallel(myRunParallel);
aPF.SetArguments(aLS);
- aPF.Perform();
+ aPF.Perform(aPS.Next());
if (aPF.HasErrors()) {
AddError (new BOPAlgo_AlertPostTreatFF);
return;
//function : PutSEInOtherFaces
//purpose :
//=======================================================================
-void BOPAlgo_PaveFiller::PutSEInOtherFaces()
+void BOPAlgo_PaveFiller::PutSEInOtherFaces(const Message_ProgressRange& theRange)
{
// Try to intersect each section edge with the faces
// not participated in its creation
BOPDS_VectorOfInterfFF& aFFs = myDS->InterfFF();
const Standard_Integer aNbFF = aFFs.Length();
+ Message_ProgressScope aPS(theRange, NULL, 1);
for (Standard_Integer i = 0; i < aNbFF; ++i)
{
const BOPDS_VectorOfCurve& aVNC = aFFs(i).Curves();
}
}
// Perform intersection of collected pave blocks
- ForceInterfEF(aMPBScAll, Standard_False);
+ ForceInterfEF(aMPBScAll, aPS.Next(), Standard_False);
}
//=======================================================================
//class : BOPAlgo_SplitEdge
//purpose :
//=======================================================================
-class BOPAlgo_SplitEdge : public BOPAlgo_Algo {
+class BOPAlgo_SplitEdge : public BOPAlgo_ParallelAlgo {
public:
DEFINE_STANDARD_ALLOC
BOPAlgo_SplitEdge() :
- BOPAlgo_Algo() {
+ BOPAlgo_ParallelAlgo() {
myT1=0.;
myT2=0.;
myTol = 0.;
}
//
virtual void Perform () {
- BOPAlgo_Algo::UserBreak();
+ Message_ProgressScope aPS(myProgressRange, NULL, 1);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
myTol = BOPAlgo_Tools::ComputeToleranceOfCB(myCB, myDS, myContext);
BOPTools_AlgoTools::MakeSplitEdge(myE,
myV1, myT1,
//class : BOPAlgo_MPC
//purpose :
//=======================================================================
-class BOPAlgo_MPC : public BOPAlgo_Algo {
+class BOPAlgo_MPC : public BOPAlgo_ParallelAlgo {
public:
DEFINE_STANDARD_ALLOC
BOPAlgo_MPC() :
- BOPAlgo_Algo(),
+ BOPAlgo_ParallelAlgo(),
myFlag(Standard_False) {
};
//
}
//
virtual void Perform() {
+ Message_ProgressScope aPS(myProgressRange, NULL, 1);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
try
{
OCC_CATCH_SIGNALS
Standard_Boolean IsToUpdate() const {
return myToUpdate;
}
+ void SetRange(const Message_ProgressRange& theRange)
+ {
+ myRange = theRange;
+ }
//
void Perform() {
+ Message_ProgressScope aPS(myRange, NULL, 1);
+ if (!aPS.More())
+ {
+ return;
+ }
BRepLib::BuildPCurveForEdgeOnPlane(myE, myF, myCurve, myToUpdate);
};
//
TopoDS_Face myF;
Handle(Geom2d_Curve) myCurve;
Standard_Boolean myToUpdate;
+private:
+ Message_ProgressRange myRange;
};
//=======================================================================
typedef NCollection_Vector<BOPAlgo_BPC> BOPAlgo_VectorOfBPC;
// function: MakeSplitEdges
// purpose:
//=======================================================================
-void BOPAlgo_PaveFiller::MakeSplitEdges()
+void BOPAlgo_PaveFiller::MakeSplitEdges(const Message_ProgressRange& theRange)
{
BOPDS_VectorOfListOfPaveBlock& aPBP=myDS->ChangePaveBlocksPool();
Standard_Integer aNbPBP = aPBP.Length();
+ Message_ProgressScope aPSOuter(theRange, NULL, 1);
if(!aNbPBP) {
return;
}
//
for (i = 0; i < aNbPBP; ++i)
{
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
BOPDS_ListOfPaveBlock& aLPB = aPBP(i);
//
aItPB.Initialize(aLPB);
aBSE.SetCommonBlock(aCB);
}
aBSE.SetDS(myDS);
- if (myProgressScope != NULL)
- {
- aBSE.SetProgressIndicator(*myProgressScope);
- }
} // for (; aItPB.More(); aItPB.Next()) {
} // for (i=0; i<aNbPBP; ++i) {
//
aNbVBSE=aVBSE.Length();
+ Message_ProgressScope aPS(aPSOuter.Next(), "Splitting edges", aNbVBSE);
+ for (k = 0; k < aNbVBSE; k++)
+ {
+ BOPAlgo_SplitEdge& aBSE = aVBSE.ChangeValue(k);
+ aBSE.SetProgressRange(aPS.Next());
+ }
//======================================================
BOPTools_Parallel::Perform (myRunParallel, aVBSE, myContext);
//======================================================
+ if (HasErrors())
+ {
+ return;
+ }
//
for (k=0; k < aNbVBSE; ++k) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
BOPAlgo_SplitEdge& aBSE=aVBSE(k);
//
const TopoDS_Edge& aSp=aBSE.SplitEdge();
// function: MakePCurves
// purpose:
//=======================================================================
-void BOPAlgo_PaveFiller::MakePCurves()
+void BOPAlgo_PaveFiller::MakePCurves(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPSOuter(theRange, NULL, 1);
if (myAvoidBuildPCurve ||
(!mySectionAttribute.PCurveOnS1() && !mySectionAttribute.PCurveOnS2()))
return;
//
aNbFI=aFIP.Length();
for (i=0; i<aNbFI; ++i) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const BOPDS_FaceInfo& aFI=aFIP(i);
nF1=aFI.Index();
//
BOPAlgo_MPC& aMPC=aVMPC.Appended();
aMPC.SetEdge(aE);
aMPC.SetFace(aF1F);
- if (myProgressScope != NULL)
- {
- aMPC.SetProgressIndicator(*myProgressScope);
- }
}
//
// On
aMPC.SetEdge(aE);
aMPC.SetFace(aF1F);
- if (myProgressScope != NULL)
- {
- aMPC.SetProgressIndicator(*myProgressScope);
- }
}
}// for (i=0; i<aNbFI; ++i) {
//
aMPC.SetEdge(aE);
aMPC.SetFace(aFf[m]);
aMPC.SetFlag(Standard_True);
- if (myProgressScope != NULL)
- {
- aMPC.SetProgressIndicator(*myProgressScope);
- }
}
}
}
}// for (i=0; i<aNbFF; ++i) {
}//if (bPCurveOnS1 || bPCurveOnS2 ) {
//
+ Message_ProgressScope aPS(aPSOuter.Next(), "Projecting edges on faces", aVMPC.Length());
+ for (i = 0; i < aVMPC.Length(); i++)
+ {
+ BOPAlgo_MPC& aMPC = aVMPC.ChangeValue(i);
+ aMPC.SetProgressRange(aPS.Next());
+ }
//======================================================
BOPTools_Parallel::Perform (myRunParallel, aVMPC, myContext);
//======================================================
+ if (HasErrors())
+ {
+ return;
+ }
// Add warnings of the failed projections and update edges with new pcurves
Standard_Integer aNb = aVMPC.Length();
for (i = 0; i < aNb; ++i)
{
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const BOPAlgo_MPC& aMPC = aVMPC(i);
if (aMPC.HasErrors())
{
// function: Prepare
// purpose:
//=======================================================================
-void BOPAlgo_PaveFiller::Prepare()
+void BOPAlgo_PaveFiller::Prepare(const Message_ProgressRange& theRange)
{
if (myNonDestructive) {
// do not allow storing pcurves in original edges if non-destructive mode is on
TopTools_IndexedMapOfShape aMF;
//
aNb=3;
+ Message_ProgressScope aPSOuter(theRange, NULL, 1);
for(i=0; i<aNb; ++i) {
myIterator->Initialize(aType[i], aType[2]);
for (; myIterator->More(); myIterator->Next()) {
}
}
//
+ Message_ProgressScope aPS(aPSOuter.Next(), "Building 2d curves on planar faces", aVBPC.Length());
+ for (i = 0; i < aVBPC.Length(); i++)
+ {
+ BOPAlgo_BPC& aBPC = aVBPC.ChangeValue(i);
+ aBPC.SetRange(aPS.Next());
+ }
//======================================================
BOPTools_Parallel::Perform (myRunParallel, aVBPC);
//======================================================
-
+ if (UserBreak(aPS))
+ {
+ return;
+ }
// pcurves are built, and now update edges
BRep_Builder aBB;
TopoDS_Edge E;
for (i = 0; i < aVBPC.Length(); i++) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const BOPAlgo_BPC& aBPC=aVBPC(i);
if (aBPC.IsToUpdate()) {
Standard_Real aTolE = BRep_Tool::Tolerance(aBPC.GetEdge());
//function : ProcessDE
//purpose :
//=======================================================================
-void BOPAlgo_PaveFiller::ProcessDE()
+void BOPAlgo_PaveFiller::ProcessDE(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPSOuter(theRange, NULL, 1);
+
Standard_Integer nF, aNb, nE, nV, nVSD, aNbPB;
Handle(NCollection_BaseAllocator) aAllocator;
Handle(BOPDS_PaveBlock) aPBD;
//nV,nE,nF
//
if (aSIF.ShapeType() == TopAbs_FACE) {
- // 1. Find PaveBlocks that are go through nV for nF
+ // 1. Find PaveBlocks that go through nV for nF
FindPaveBlocks(nV, nF, aLPBOut);
aNbPB=aLPBOut.Extent();
if (aNbPB) {
aPBD->SetEdge(nEn);
}
}
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
}
}
}
// function: Perform
// purpose: Performs the removal of the requested faces from the input shape
//=======================================================================
-void BOPAlgo_RemoveFeatures::Perform()
+void BOPAlgo_RemoveFeatures::Perform(const Message_ProgressRange& /*theRange*/)
{
try
{
public: //! @name Performing the operation
//! Performs the operation
- Standard_EXPORT virtual void Perform() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Perform(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
public: //! @name Clearing the contents of the algorithm
//
CheckFiller();
}
+
+//=======================================================================
+// function: fillPIConstants
+// purpose:
+//=======================================================================
+void BOPAlgo_Section::fillPIConstants (const Standard_Real theWhole,
+ BOPAlgo_PISteps& theSteps) const
+{
+ // Fill in the constants:
+ if (myFillHistory)
+ {
+ // for FillHistroty, which takes about 10% of the whole operation
+ theSteps.SetStep(PIOperation_FillHistory, 10. * theWhole / 100.);
+ }
+
+ // and for PostTreat, which takes about 5% of the whole operation
+ theSteps.SetStep(PIOperation_PostTreat, 5. * theWhole / 100.);
+}
+
+//=======================================================================
+// function: fillPISteps
+// purpose:
+//=======================================================================
+void BOPAlgo_Section::fillPISteps (BOPAlgo_PISteps& theSteps) const
+{
+ // Compute the rest of the operations - all depend on the number of sub-shapes of certain type
+ NbShapes aNbShapes = getNbShapes();
+ theSteps.SetStep(PIOperation_TreatVertices, aNbShapes.NbVertices());
+ theSteps.SetStep(PIOperation_TreatEdges, aNbShapes.NbEdges());
+ theSteps.SetStep(PIOperation_BuildSection, aNbShapes.NbEdges() + aNbShapes.NbFaces());
+}
//=======================================================================
//function : PerformInternal1
//purpose :
//=======================================================================
void BOPAlgo_Section::PerformInternal1
- (const BOPAlgo_PaveFiller& theFiller)
+ (const BOPAlgo_PaveFiller& theFiller, const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPS(theRange, "Building result of SECTION operation", 100);
myPaveFiller=(BOPAlgo_PaveFiller*)&theFiller;
myDS=myPaveFiller->PDS();
myContext=myPaveFiller->Context();
return;
}
//
+ BOPAlgo_PISteps aSteps (PIOperation_Last);
+ analyzeProgress(100., aSteps);
// 3. Fill Images
// 3.1 Vertices
- FillImagesVertices();
+ FillImagesVertices(aPS.Next(aSteps.GetStep(PIOperation_TreatVertices)));
if (HasErrors()) {
return;
}
return;
}
// 3.2 Edges
- FillImagesEdges();
+ FillImagesEdges(aPS.Next(aSteps.GetStep(PIOperation_TreatEdges)));
if (HasErrors()) {
return;
}
return;
}
// 4. Section
- BuildSection();
- //
+ BuildSection(aPS.Next(aSteps.GetStep(PIOperation_BuildSection)));
if (HasErrors()) {
return;
}
// 5.History
- PrepareHistory();
- //
+ PrepareHistory(aPS.Next(aSteps.GetStep(PIOperation_FillHistory)));
if (HasErrors()) {
return;
}
// 6. Post-treatment
- PostTreat();
+ PostTreat(aPS.Next(aSteps.GetStep(PIOperation_PostTreat)));
}
//=======================================================================
//function : BuildSection
//purpose :
//=======================================================================
-void BOPAlgo_Section::BuildSection()
+void BOPAlgo_Section::BuildSection(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPS(theRange, "Building the result of Section operation", 1);
Standard_Integer i, aNbMS, aNbLE;
Standard_Integer j, nE, nV, aNb, aNbF, aNbPBSc;
TopoDS_Shape aRC, aRC1;
if (aSI.ShapeType()!=TopAbs_FACE) {
continue;
}
+ if (UserBreak(aPS))
+ {
+ return;
+ }
//
const BOPDS_FaceInfo& aFI=myDS->FaceInfo(i);
//
// 3.1 Set to treat => aLS
aIt.Initialize(aLSA);
for (; aIt.More(); aIt.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const TopoDS_Shape& aSA=aIt.Value();
//
aLS.Clear();
//
aNbMS=aMVE.Extent();
for (i=1; i<=aNbMS; ++i) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const TopoDS_Shape& aV=aMVE.FindKey(i);
const TopTools_ListOfShape& aLE=aMVE.FindFromIndex(i);
aNbLE=aLE.Extent();
Standard_EXPORT virtual void CheckData() Standard_OVERRIDE;
//! Combine the result of section operation
- Standard_EXPORT virtual void BuildSection();
+ Standard_EXPORT virtual void BuildSection(const Message_ProgressRange& theRange);
//! Performs calculations using prepared Filler object <thePF>
- Standard_EXPORT virtual void PerformInternal1(const BOPAlgo_PaveFiller& thePF) Standard_OVERRIDE;
+ Standard_EXPORT virtual void PerformInternal1(const BOPAlgo_PaveFiller& thePF, const Message_ProgressRange& theRange) Standard_OVERRIDE;
-private:
+protected:
+
+ //! List of operations to be supported by the Progress Indicator.
+ //! Override the whole enumeration here since the constant operations are also
+ //! going to be overridden.
+ enum BOPAlgo_PIOperation
+ {
+ PIOperation_TreatVertices = 0,
+ PIOperation_TreatEdges,
+ PIOperation_BuildSection,
+ PIOperation_FillHistory,
+ PIOperation_PostTreat,
+ PIOperation_Last
+ };
+
+ //! Filling steps for constant operations
+ Standard_EXPORT void fillPIConstants(const Standard_Real theWhole, BOPAlgo_PISteps& theSteps) const Standard_OVERRIDE;
+
+ //! Filling steps for all other operations
+ Standard_EXPORT void fillPISteps(BOPAlgo_PISteps& theSteps) const Standard_OVERRIDE;
};
return *myPCB;
}
//
+ void SetProgressRange(const Message_ProgressRange& theRange)
+ {
+ myProgressRange = theRange;
+ }
+ //
void Perform() {
+ Message_ProgressScope aPS(myProgressRange, NULL, 1);
+ if (!aPS.More())
+ {
+ return;
+ }
BOPAlgo_ShellSplitter::SplitBlock(*myPCB);
}
protected:
BOPTools_ConnexityBlock *myPCB;
+ Message_ProgressRange myProgressRange;
};
//=======================================================================
typedef NCollection_Vector<BOPAlgo_CBK> BOPAlgo_VectorOfCBK;
//function : Perform
//purpose :
//=======================================================================
-void BOPAlgo_ShellSplitter::Perform()
+void BOPAlgo_ShellSplitter::Perform(const Message_ProgressRange& theRange)
{
GetReport()->Clear();
+ Message_ProgressScope aPS(theRange, "Building shells", 1);
//
BOPTools_AlgoTools::MakeConnexityBlocks
(myStartShapes, TopAbs_EDGE, TopAbs_FACE, myLCB);
- //
- MakeShells();
+ if (UserBreak (aPS))
+ {
+ return;
+ }
+
+ MakeShells(aPS.Next());
}
//=======================================================================
//function : MakeShells
//purpose :
//=======================================================================
-void BOPAlgo_ShellSplitter::MakeShells()
+void BOPAlgo_ShellSplitter::MakeShells(const Message_ProgressRange& theRange)
{
Standard_Boolean bIsRegular;
Standard_Integer aNbVCBK, k;
TopTools_ListIteratorOfListOfShape aIt;
BOPAlgo_VectorOfCBK aVCBK;
//
+ Message_ProgressScope aPSOuter(theRange, NULL, 1);
myShells.Clear();
//
aItCB.Initialize(myLCB);
for (; aItCB.More(); aItCB.Next()) {
+ if (UserBreak (aPSOuter))
+ {
+ return;
+ }
BOPTools_ConnexityBlock& aCB=aItCB.ChangeValue();
bIsRegular=aCB.IsRegular();
if (bIsRegular) {
}
//
aNbVCBK=aVCBK.Length();
+ Message_ProgressScope aPSParallel(aPSOuter.Next(), NULL, aNbVCBK);
+ for (Standard_Integer iS = 0; iS < aNbVCBK; ++iS)
+ {
+ aVCBK.ChangeValue(iS).SetProgressRange(aPSParallel.Next());
+ }
//===================================================
BOPTools_Parallel::Perform (myRunParallel, aVCBK);
//===================================================
Standard_EXPORT const TopTools_ListOfShape& StartElements() const;
//! performs the algorithm
- Standard_EXPORT virtual void Perform() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Perform(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! returns the loops
Standard_EXPORT const TopTools_ListOfShape& Shells() const;
protected:
- Standard_EXPORT void MakeShells();
+ Standard_EXPORT void MakeShells(const Message_ProgressRange& theRange);
TopTools_ListOfShape myStartShapes;
//function : Perform
//purpose :
//=======================================================================
-void BOPAlgo_Splitter::Perform()
+void BOPAlgo_Splitter::Perform(const Message_ProgressRange& theRange)
{
GetReport()->Clear();
//
BOPAlgo_PaveFiller *pPF = new BOPAlgo_PaveFiller();
pPF->SetArguments(aLS);
pPF->SetRunParallel(myRunParallel);
- if (myProgressScope != NULL)
- {
- pPF->SetProgressIndicator(*myProgressScope);
- }
+
pPF->SetFuzzyValue(myFuzzyValue);
pPF->SetNonDestructive(myNonDestructive);
pPF->SetGlue(myGlue);
pPF->SetUseOBB(myUseOBB);
//
- pPF->Perform();
+ Message_ProgressScope aPS(theRange, "Performing Split operation", 10);
+ pPF->Perform(aPS.Next(9));
//
myEntryPoint = 1;
- PerformInternal(*pPF);
+ PerformInternal(*pPF, aPS.Next(1));
}
//=======================================================================
Standard_EXPORT BOPAlgo_Splitter(const Handle(NCollection_BaseAllocator)& theAllocator);
//! Performs the operation
- Standard_EXPORT virtual void Perform() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Perform(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
protected:
//class : BOPAlgo_FillIn3DParts
//purpose : Auxiliary class for faces classification in parallel mode
//=======================================================================
-class BOPAlgo_FillIn3DParts : public BOPAlgo_Algo
+class BOPAlgo_FillIn3DParts : public BOPAlgo_ParallelAlgo
{
public:
DEFINE_STANDARD_ALLOC
//=======================================================================
void BOPAlgo_FillIn3DParts::Perform()
{
- BOPAlgo_Algo::UserBreak();
+ Message_ProgressScope aPSOuter(myProgressRange, NULL, 2);
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
myInFaces.Clear();
MapEdgesAndFaces(aVShapeBox(aIVec(k)).Shape(), aMEFP, anAlloc);
}
+ aPSOuter.Next();
+
// Map of Edge-Face connection, necessary for solid classification.
// It will be filled when first classification is performed.
TopTools_IndexedDataMapOfShapeListOfShape aMEFDS(1, anAlloc);
// Fence map to avoid processing of the same faces twice
TopTools_MapOfShape aMFDone(1, anAlloc);
- for (k = 0; k < aNbFP; ++k)
+ Message_ProgressScope aPSLoop (aPSOuter.Next(), NULL, aNbFP);
+ for (k = 0; k < aNbFP; ++k, aPSLoop.Next())
{
+ if (UserBreak (aPSLoop))
+ {
+ return;
+ }
Standard_Integer nFP = aIVec(k);
const TopoDS_Face& aFP = (*(TopoDS_Face*)&aVShapeBox(nFP).Shape());
if (!aMFDone.Add(aFP))
Handle(IntTools_Context)& theContext,
TopTools_IndexedDataMapOfShapeListOfShape& theInParts,
const TopTools_DataMapOfShapeBox& theShapeBoxMap,
- const TopTools_DataMapOfShapeListOfShape& theSolidsIF)
+ const TopTools_DataMapOfShapeListOfShape& theSolidsIF,
+ const Message_ProgressRange& theRange)
{
Handle(NCollection_BaseAllocator) anAlloc = new NCollection_IncAllocator;
+ Message_ProgressScope aPSOuter(theRange, NULL, 10);
+
// Fill the vector of shape box with faces and its bounding boxes
BOPAlgo_VectorOfShapeBox aVSB(256, anAlloc);
TopTools_ListIteratorOfListOfShape aItLF(theFaces);
for (; aItLF.More(); aItLF.Next())
{
+ if (!aPSOuter.More())
+ {
+ return;
+ }
+
const TopoDS_Shape& aF = aItLF.Value();
// Append face to the vector of shape box
BOPAlgo_ShapeBox& aSB = aVSB.Appended();
aFIP.SetShapeBoxVector(aVSB);
}
+ // Close preparation task
+ aPSOuter.Next();
+ // Set progress range for each task to be run in parallel
+ Standard_Integer aNbS = aVFIP.Length();
+ Message_ProgressScope aPSParallel(aPSOuter.Next(9), "Classification of faces relatively solids", aNbS);
+ for (Standard_Integer iFS = 0; iFS < aNbS; ++iFS)
+ {
+ aVFIP.ChangeValue(iFS).SetProgressRange(aPSParallel.Next());
+ }
// Perform classification
//================================================================
BOPTools_Parallel::Perform (theRunParallel, aVFIP, theContext);
//================================================================
-
// Analyze the results and fill the resulting map
-
- Standard_Integer aNbS = aVFIP.Length();
for (Standard_Integer i = 0; i < aNbS; ++i)
{
BOPAlgo_FillIn3DParts& aFIP = aVFIP(i);
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <Standard_Integer.hxx>
+#include <Message_ProgressRange.hxx>
class BOPDS_PaveBlock;
class BOPDS_CommonBlock;
Handle(IntTools_Context)& theContext,
TopTools_IndexedDataMapOfShapeListOfShape& theInParts,
const TopTools_DataMapOfShapeBox& theShapeBoxMap = TopTools_DataMapOfShapeBox(),
- const TopTools_DataMapOfShapeListOfShape& theSolidsIF = TopTools_DataMapOfShapeListOfShape());
+ const TopTools_DataMapOfShapeListOfShape& theSolidsIF = TopTools_DataMapOfShapeListOfShape(),
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Classifies the given parts relatively the given solids and
//! fills the solids with the parts classified as INTERNAL.
//function : Perform
//purpose :
//=======================================================================
-void BOPAlgo_WireSplitter::Perform()
+void BOPAlgo_WireSplitter::Perform(const Message_ProgressRange& theRange)
{
GetReport()->Clear();
+ Message_ProgressScope aPS(theRange, "Building wires", 1);
//
CheckData();
if (HasErrors()) {
//
BOPTools_AlgoTools::MakeConnexityBlocks
(myWES->StartElements(), TopAbs_VERTEX, TopAbs_EDGE, myLCB);
+ if (UserBreak (aPS))
+ {
+ return;
+ }
- MakeWires();
+ MakeWires(aPS.Next());
}
/////////////////////////////////////////////////////////////////////////
const Handle(IntTools_Context)& Context()const {
return myContext;
}
+ //
+ void SetProgressRange(const Message_ProgressRange& theRange) {
+ myRange = theRange;
+ }
void Perform() {
+ Message_ProgressScope aPS (myRange, NULL, 1);
+ if (!aPS.More())
+ {
+ return;
+ }
BOPAlgo_WireSplitter::SplitBlock(myFace, myCB, myContext);
}
TopoDS_Face myFace;
BOPTools_ConnexityBlock myCB;
Handle(IntTools_Context) myContext;
+ Message_ProgressRange myRange;
};
typedef NCollection_Vector<BOPAlgo_WS_ConnexityBlock> BOPAlgo_VectorOfConnexityBlock;
//function : MakeWires
//purpose :
//=======================================================================
-void BOPAlgo_WireSplitter::MakeWires()
+void BOPAlgo_WireSplitter::MakeWires(const Message_ProgressRange& theRange)
{
Standard_Boolean bIsRegular;
Standard_Integer aNbVCB, k;
TopTools_ListIteratorOfListOfShape aIt;
BOPAlgo_VectorOfConnexityBlock aVCB;
//
+ Message_ProgressScope aPSOuter(theRange, NULL, 1);
+ //
const TopoDS_Face& aF=myWES->Face();
//
aItCB.Initialize(myLCB);
for (; aItCB.More(); aItCB.Next()) {
+ if (UserBreak (aPSOuter))
+ {
+ return;
+ }
+
BOPTools_ConnexityBlock& aCB=aItCB.ChangeValue();
bIsRegular=aCB.IsRegular();
if (bIsRegular) {
aWSCB.SetConnexityBlock(aCB);
}
}
+ aNbVCB=aVCB.Length();
+ Message_ProgressScope aPSParallel(aPSOuter.Next(), NULL, aNbVCB);
+ for (Standard_Integer iW = 0; iW < aNbVCB; ++iW)
+ {
+ aVCB.ChangeValue(iW).SetProgressRange(aPSParallel.Next());
+ }
//===================================================
BOPTools_Parallel::Perform (myRunParallel, aVCB, myContext);
//===================================================
- aNbVCB=aVCB.Length();
for (k=0; k<aNbVCB; ++k) {
const BOPAlgo_WS_ConnexityBlock& aCB=aVCB(k);
const TopTools_ListOfShape& aLW=aCB.ConnexityBlock().Loops();
//! Returns the context
Standard_EXPORT const Handle(IntTools_Context)& Context();
- Standard_EXPORT virtual void Perform() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Perform(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
static void MakeWire(TopTools_ListOfShape& theLE, TopoDS_Wire& theW);
Standard_EXPORT virtual void CheckData() Standard_OVERRIDE;
- Standard_EXPORT void MakeWires();
+ Standard_EXPORT void MakeWires(const Message_ProgressRange& theRange);
BOPAlgo_PWireEdgeSet myWES;
BOPTools_ListOfConnexityBlock myLCB;
#include <TopoDS_Shape.hxx>
#include <TopTools_ListOfShape.hxx>
+#include <Draw_ProgressIndicator.hxx>
+
#include <stdio.h>
#include <string.h>
pBuilder->SetUseOBB(BOPTest_Objects::UseOBB());
pBuilder->SetToFillHistory(BRepTest_Objects::IsHistoryNeeded());
//
- pBuilder->Build();
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
+ pBuilder->Build(aProgress->Start());
pBuilder->SimplifyResult(BOPTest_Objects::UnifyEdges(),
BOPTest_Objects::UnifyFaces(),
BOPTest_Objects::Angular());
aBuilder.SetUseOBB(BOPTest_Objects::UseOBB());
aBuilder.SetToFillHistory(BRepTest_Objects::IsHistoryNeeded());
//
- aBuilder.Build();
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
+ aBuilder.Build(aProgress->Start());
aBuilder.SimplifyResult(BOPTest_Objects::UnifyEdges(),
BOPTest_Objects::UnifyFaces(),
BOPTest_Objects::Angular());
aSplitter.SetToFillHistory(BRepTest_Objects::IsHistoryNeeded());
//
// performing operation
- aSplitter.Build();
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
+ aSplitter.Build(aProgress->Start());
aSplitter.SimplifyResult(BOPTest_Objects::UnifyEdges(),
BOPTest_Objects::UnifyFaces(),
BOPTest_Objects::Angular());
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Shape.hxx>
#include <TopTools_ListOfShape.hxx>
+#include <Draw_ProgressIndicator.hxx>
#include <stdio.h>
//
bRunParallel=BOPTest_Objects::RunParallel();
bNonDestructive = BOPTest_Objects::NonDestructive();
BOPAlgo_GlueEnum aGlue = BOPTest_Objects::Glue();
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
//
aLC.Append(aS1);
aLC.Append(aS2);
pPF->SetGlue(aGlue);
pPF->SetUseOBB(BOPTest_Objects::UseOBB());
//
- pPF->Perform();
+ pPF->Perform(aProgress->Start());
BOPTest::ReportAlerts(pPF->GetReport());
//
return 0;
}
//
bRunParallel=BOPTest_Objects::RunParallel();
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
//
const TopoDS_Shape& aS1=aLC.First();
const TopoDS_Shape& aS2=aLC.Last();
aBOP.SetCheckInverted(BOPTest_Objects::CheckInverted());
aBOP.SetToFillHistory(BRepTest_Objects::IsHistoryNeeded());
//
- aBOP.PerformWithFiller(*pPF);
+ aBOP.PerformWithFiller(*pPF, aProgress->Start());
BOPTest::ReportAlerts(aBOP.GetReport());
// Store the history of Boolean operation into the session
aBOP.SetCheckInverted(BOPTest_Objects::CheckInverted());
aBOP.SetToFillHistory(BRepTest_Objects::IsHistoryNeeded());
//
- aBOP.PerformWithFiller(*pPF);
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
+ aBOP.PerformWithFiller(*pPF, aProgress->Start());
BOPTest::ReportAlerts(aBOP.GetReport());
// Store the history of Section operation into the session
//
BRepAlgoAPI_Section aSec(aS1, aS2, Standard_False);
//
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
aSec.Approximation(bApp);
aSec.ComputePCurveOn1(bPC1);
aSec.ComputePCurveOn2(bPC2);
aSec.SetGlue(aGlue);
aSec.SetUseOBB(BOPTest_Objects::UseOBB());
//
- aSec.Build();
-
+ aSec.Build(aProgress->Start());
// Store the history of Section operation into the session
if (BRepTest_Objects::IsHistoryNeeded())
BRepTest_Objects::SetHistory(aSec.History());
const char** a,
const BOPAlgo_Operation aOp)
{
- Standard_Boolean bRunParallel, bNonDestructive;
TopoDS_Shape aS1, aS2;
TopTools_ListOfShape aLC;
- Standard_Real aTol;
//
if (n != 4) {
di << " use bx r s1 s2\n";
}
aLC.Append(aS1);
aLC.Append(aS2);
- //
- aTol=BOPTest_Objects::FuzzyValue();
- bRunParallel = BOPTest_Objects::RunParallel();
- bNonDestructive = BOPTest_Objects::NonDestructive();
- BOPAlgo_GlueEnum aGlue = BOPTest_Objects::Glue();
//
Handle(NCollection_BaseAllocator)aAL=
NCollection_BaseAllocator::CommonBaseAllocator();
//
- //---------------------------------------------------------------
- BOPAlgo_PaveFiller aPF(aAL);
- //
- aPF.SetArguments(aLC);
- aPF.SetFuzzyValue(aTol);
- aPF.SetRunParallel(bRunParallel);
- aPF.SetNonDestructive(bNonDestructive);
- aPF.SetGlue(aGlue);
- aPF.SetUseOBB(BOPTest_Objects::UseOBB());
- //
- aPF.Perform();
- BOPTest::ReportAlerts(aPF.GetReport());
- if (aPF.HasErrors()) {
- return 0;
- }
- //
- //---------------------------------------------------------------
BOPAlgo_BOP aBOP(aAL);
- //
aBOP.AddArgument(aS1);
aBOP.AddTool(aS2);
aBOP.SetOperation(aOp);
- aBOP.SetRunParallel(bRunParallel);
+ // set options
+ aBOP.SetGlue(BOPTest_Objects::Glue());
+ aBOP.SetFuzzyValue(BOPTest_Objects::FuzzyValue());
+ aBOP.SetNonDestructive(BOPTest_Objects::NonDestructive());
+ aBOP.SetRunParallel(BOPTest_Objects::RunParallel());
+ aBOP.SetUseOBB(BOPTest_Objects::UseOBB());
aBOP.SetCheckInverted(BOPTest_Objects::CheckInverted());
aBOP.SetToFillHistory(BRepTest_Objects::IsHistoryNeeded());
//
- aBOP.PerformWithFiller(aPF);
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
+ aBOP.Perform(aProgress->Start());
BOPTest::ReportAlerts(aBOP.GetReport());
// Store the history of Boolean operation into the session
if (BRepTest_Objects::IsHistoryNeeded())
- BRepTest_Objects::SetHistory(aPF.Arguments(), aBOP);
+ BRepTest_Objects::SetHistory(aBOP.PDS()->Arguments(), aBOP);
if (aBOP.HasErrors()) {
return 0;
aMV.SetUseOBB(BOPTest_Objects::UseOBB());
aMV.SetToFillHistory(BRepTest_Objects::IsHistoryNeeded());
//
- aMV.Perform();
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
+ aMV.Perform(aProgress->Start());
BOPTest::ReportAlerts(aMV.GetReport());
// Store the history of Volume Maker into the session
#include <BRepTest_Objects.hxx>
+#include <Draw_ProgressIndicator.hxx>
+
static Standard_Integer bcbuild (Draw_Interpretor&, Standard_Integer, const char**);
static Standard_Integer bcaddall (Draw_Interpretor&, Standard_Integer, const char**);
static Standard_Integer bcremoveall (Draw_Interpretor&, Standard_Integer, const char**);
aCBuilder.SetUseOBB(BOPTest_Objects::UseOBB());
aCBuilder.SetToFillHistory(BRepTest_Objects::IsHistoryNeeded());
//
- aCBuilder.PerformWithFiller(aPF);
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
+ aCBuilder.PerformWithFiller(aPF, aProgress->Start());
BOPTest::ReportAlerts(aCBuilder.GetReport());
-
// Store the history of the Cells Builder into the session
if (BRepTest_Objects::IsHistoryNeeded())
BRepTest_Objects::SetHistory(aCBuilder.Arguments(), aCBuilder);
#include <BRepBuilderAPI_Copy.hxx>
#include <DBRep.hxx>
#include <Draw.hxx>
+#include <Draw_ProgressIndicator.hxx>
#include <OSD_Timer.hxx>
#include <TCollection_AsciiString.hxx>
#include <TopExp_Explorer.hxx>
OSD_Timer aTimer;
aTimer.Start();
//
- aChecker.Perform();
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
+ aChecker.Perform(aProgress->Start());
//
aTimer.Stop();
//
}
}
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
// run checker
- aChecker.Perform();
-
+ aChecker.Perform(aProgress->Start());
// process result of checking
if(!aChecker.HasFaulty()) {
di << "Shape(s) seem(s) to be valid for BOP." << "\n";
#include <OSD_Timer.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS.hxx>
+#include <Draw_ProgressIndicator.hxx>
#include <stdio.h>
#include <string.h>
OSD_Timer aTimer;
aTimer.Start();
//
- aPF.Perform();
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
+ aPF.Perform(aProgress->Start());
BOPTest::ReportAlerts(aPF.GetReport());
if (aPF.HasErrors()) {
return 0;
aBuilder.SetCheckInverted(BOPTest_Objects::CheckInverted());
aBuilder.SetToFillHistory(BRepTest_Objects::IsHistoryNeeded());
//
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
//
OSD_Timer aTimer;
aTimer.Start();
//
- aBuilder.PerformWithFiller(aPF);
+ aBuilder.PerformWithFiller(aPF, aProgress->Start());
BOPTest::ReportAlerts(aBuilder.GetReport());
// Set history of GF operation into the session
pBuilder->SetCheckInverted(BOPTest_Objects::CheckInverted());
pBuilder->SetToFillHistory(BRepTest_Objects::IsHistoryNeeded());
//
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
+ //
OSD_Timer aTimer;
aTimer.Start();
//
- pBuilder->PerformWithFiller(aPF);
+ pBuilder->PerformWithFiller(aPF, aProgress->Start());
BOPTest::ReportAlerts(pBuilder->GetReport());
// Set history of Boolean operation into the session
aTimer.Start();
//
// perform the operation
- pSplitter->PerformWithFiller(aPF);
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
+ pSplitter->PerformWithFiller(aPF, aProgress->Start());
//
aTimer.Stop();
BOPTest::ReportAlerts(pSplitter->GetReport());
// Create new report for the operation
Handle(Message_Report) aReport = new Message_Report;
-
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
// Build specific operation
- pBuilder->BuildBOP(aLObjects, aLTools, anOp, aReport);
+ pBuilder->BuildBOP(aLObjects, aLTools, anOp, aProgress->Start(), aReport);
// Report alerts of the operation
BOPTest::ReportAlerts(aReport);
//function : Build
//purpose : compute the section
//=======================================================================
- void BRepAlgo_Section::Build()
+ void BRepAlgo_Section::Build(const Message_ProgressRange& /*theRange*/)
{
if (myS1Changed ||
myS2Changed ||
//! You may also have combined these computation
//! options: look at the example given above to illustrate
//! the use of the constructors.
- Standard_EXPORT void Build() Standard_OVERRIDE;
+ Standard_EXPORT void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Identifies the ancestor faces of the new
//! intersection edge E resulting from the last
using BOPAlgo_Options::DumpWarnings;
using BOPAlgo_Options::ClearWarnings;
using BOPAlgo_Options::GetReport;
- using BOPAlgo_Options::SetProgressIndicator;
using BOPAlgo_Options::SetUseOBB;
protected:
//function : Build
//purpose :
//=======================================================================
-void BRepAlgoAPI_BooleanOperation::Build()
+void BRepAlgoAPI_BooleanOperation::Build(const Message_ProgressRange& theRange)
{
// Set Not Done status by default
NotDone();
}
}
+ TCollection_AsciiString aPSName;
+ switch (myOperation)
+ {
+ case BOPAlgo_COMMON:
+ aPSName = "Performing COMMON operation";
+ break;
+ case BOPAlgo_FUSE:
+ aPSName = "Performing FUSE operation";
+ break;
+ case BOPAlgo_CUT:
+ case BOPAlgo_CUT21:
+ aPSName = "Performing CUT operation";
+ break;
+ case BOPAlgo_SECTION:
+ aPSName = "Performing SECTION operation";
+ break;
+ default:
+ return;
+ }
+
+ Message_ProgressScope aPS(theRange, aPSName, myIsIntersectionNeeded ? 100 : 30);
// If necessary perform intersection of the argument shapes
if (myIsIntersectionNeeded)
{
aLArgs.Append(it.Value());
// Perform intersection
- IntersectShapes(aLArgs);
+ IntersectShapes(aLArgs, aPS.Next(70));
if (HasErrors())
{
if (aDumpOper.IsDump())
}
// Build the result
- BuildResult();
+ BuildResult(aPS.Next(30));
+ if (HasErrors())
+ {
+ return;
+ }
if (aDumpOper.IsDump()) {
Standard_Boolean isDumpRes = myShape.IsNull() ||
public: //! @name Performing the operation
//! Performs the Boolean operation.
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
protected: //! @name Constructors
//function : Build
//purpose :
//=======================================================================
-void BRepAlgoAPI_BuilderAlgo::Build()
+void BRepAlgoAPI_BuilderAlgo::Build(const Message_ProgressRange& theRange)
{
// Setting not done status
NotDone();
// Destroy the tools if necessary
Clear();
+ Message_ProgressScope aPS(theRange, "Performing General Fuse operation", 100);
// If necessary perform intersection of the argument shapes
- IntersectShapes(myArguments);
+ IntersectShapes(myArguments, aPS.Next(70));
if (HasErrors())
return;
myBuilder = new BOPAlgo_Builder(myAllocator);
// Set arguments to builder
myBuilder->SetArguments(myArguments);
-
// Build the result basing on intersection results
- BuildResult();
+ BuildResult(aPS.Next(30));
}
//=======================================================================
//function : IntersectShapes
//purpose : Intersects the given shapes with the intersection tool
//=======================================================================
-void BRepAlgoAPI_BuilderAlgo::IntersectShapes(const TopTools_ListOfShape& theArgs)
+void BRepAlgoAPI_BuilderAlgo::IntersectShapes(const TopTools_ListOfShape& theArgs, const Message_ProgressRange& theRange)
{
if (!myIsIntersectionNeeded)
return;
myDSFiller->SetArguments(theArgs);
// Set options for intersection
myDSFiller->SetRunParallel(myRunParallel);
- if (myProgressScope != NULL)
- {
- myDSFiller->SetProgressIndicator(*myProgressScope);
- }
+
myDSFiller->SetFuzzyValue(myFuzzyValue);
myDSFiller->SetNonDestructive(myNonDestructive);
myDSFiller->SetGlue(myGlue);
// Set Face/Face intersection options to the intersection algorithm
SetAttributes();
// Perform intersection
- myDSFiller->Perform();
+ myDSFiller->Perform(theRange);
// Check for the errors during intersection
GetReport()->Merge(myDSFiller->GetReport());
}
//function : BuildResult
//purpose : Builds the result shape
//=======================================================================
-void BRepAlgoAPI_BuilderAlgo::BuildResult()
+void BRepAlgoAPI_BuilderAlgo::BuildResult(const Message_ProgressRange& theRange)
{
// Set options to the builder
myBuilder->SetRunParallel(myRunParallel);
- if (myProgressScope != NULL)
- {
- myBuilder->SetProgressIndicator(*myProgressScope);
- }
+
myBuilder->SetCheckInverted(myCheckInverted);
myBuilder->SetToFillHistory(myFillHistory);
// Perform building of the result with pre-calculated intersections
- myBuilder->PerformWithFiller(*myDSFiller);
+ myBuilder->PerformWithFiller(*myDSFiller, theRange);
// Merge the warnings of the Building part
GetReport()->Merge(myBuilder->GetReport());
// Check for the errors
public: //! @name Performing the operation
//! Performs the algorithm
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
public: //! @name Result simplification
protected: //! @name Protected methods for shapes intersection and building result
//! Intersects the given shapes with the intersection tool
- Standard_EXPORT void IntersectShapes(const TopTools_ListOfShape& theArgs);
+ Standard_EXPORT void IntersectShapes(const TopTools_ListOfShape& theArgs, const Message_ProgressRange& theRange);
//! Builds the resulting shape
- Standard_EXPORT void BuildResult();
+ Standard_EXPORT void BuildResult(const Message_ProgressRange& theRange = Message_ProgressRange());
protected: //! @name Clearing the contents of the algorithm
//=======================================================================
BRepAlgoAPI_Check::BRepAlgoAPI_Check(const TopoDS_Shape& theS,
const Standard_Boolean bTestSE,
- const Standard_Boolean bTestSI)
+ const Standard_Boolean bTestSI,
+ const Message_ProgressRange& theRange)
:
BOPAlgo_Options(),
myS1(theS),
myTestSI(bTestSI),
myOperation(BOPAlgo_UNKNOWN)
{
- Perform();
+ Perform(theRange);
}
//=======================================================================
const TopoDS_Shape& theS2,
const BOPAlgo_Operation theOp,
const Standard_Boolean bTestSE,
- const Standard_Boolean bTestSI)
+ const Standard_Boolean bTestSI,
+ const Message_ProgressRange& theRange)
:
BOPAlgo_Options(),
myS1(theS1),
myTestSI(bTestSI),
myOperation(theOp)
{
- Perform();
+ Perform(theRange);
}
//=======================================================================
//function : Perform
//purpose :
//=======================================================================
-void BRepAlgoAPI_Check::Perform()
+void BRepAlgoAPI_Check::Perform(const Message_ProgressRange& theRange)
{
// Check the incompatibility of shapes types, small edges and self-interference
BOPAlgo_ArgumentAnalyzer anAnalyzer;
anAnalyzer.SelfInterMode() = myTestSI;
// Set options from BOPAlgo_Options
anAnalyzer.SetRunParallel(myRunParallel);
- if (myProgressScope != NULL)
- {
- anAnalyzer.SetProgressIndicator(*myProgressScope);
- }
anAnalyzer.SetFuzzyValue(myFuzzyValue);
// Perform the check
- anAnalyzer.Perform();
+ Message_ProgressScope aPS(theRange, "Checking shapes", 1);
+ anAnalyzer.Perform(aPS.Next());
+ if (UserBreak(aPS))
+ {
+ return;
+ }
// Get the results
myFaultyShapes = anAnalyzer.GetCheckResult();
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
#include <TopoDS_Shape.hxx>
+#include <Message_ProgressRange.hxx>
//! The class Check provides a diagnostic tool for checking the validity
//! on small edges or not; by default it is set to TRUE;
//! @param bTestSI [in] - flag which specifies whether to check the shape
//! on self-interference or not; by default it is set to TRUE;
+ //! @param theRange [in] - parameter to use progress indicator
Standard_EXPORT BRepAlgoAPI_Check(const TopoDS_Shape& theS,
const Standard_Boolean bTestSE = Standard_True,
- const Standard_Boolean bTestSI = Standard_True);
+ const Standard_Boolean bTestSI = Standard_True,
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Constructor for checking the couple of shapes.
//! Additionally to the validity checks of each given shape,
//! on small edges or not; by default it is set to TRUE;
//! @param bTestSI [in] - flag which specifies whether to check the shape
//! on self-interference or not; by default it is set to TRUE;
+ //! @param theRange [in] - parameter to use progress indicator
Standard_EXPORT BRepAlgoAPI_Check(const TopoDS_Shape& theS1,
const TopoDS_Shape& theS2,
const BOPAlgo_Operation theOp = BOPAlgo_UNKNOWN,
const Standard_Boolean bTestSE = Standard_True,
- const Standard_Boolean bTestSI = Standard_True);
+ const Standard_Boolean bTestSI = Standard_True,
+ const Message_ProgressRange& theRange = Message_ProgressRange());
public: //! @name Initializing the algorithm
public: //! @name Performing the operation
//! Performs the check.
- Standard_EXPORT void Perform();
+ Standard_EXPORT void Perform(const Message_ProgressRange& theRange = Message_ProgressRange());
public: //! @name Getting the results.
//purpose :
//=======================================================================
BRepAlgoAPI_Common::BRepAlgoAPI_Common(const TopoDS_Shape& S1,
- const TopoDS_Shape& S2)
+ const TopoDS_Shape& S2,
+ const Message_ProgressRange& theRange)
: BRepAlgoAPI_BooleanOperation(S1, S2, BOPAlgo_COMMON)
{
- Build();
+ Build(theRange);
}
//=======================================================================
//function : BRepAlgoAPI_Common
//=======================================================================
BRepAlgoAPI_Common::BRepAlgoAPI_Common(const TopoDS_Shape& S1,
const TopoDS_Shape& S2,
- const BOPAlgo_PaveFiller& aDSF)
+ const BOPAlgo_PaveFiller& aDSF,
+ const Message_ProgressRange& theRange)
: BRepAlgoAPI_BooleanOperation(S1, S2, aDSF, BOPAlgo_COMMON)
{
- Build();
+ Build(theRange);
}
//! <S2> -tool
//! <anOperation> - the type of the operation
//! Obsolete
- Standard_EXPORT BRepAlgoAPI_Common(const TopoDS_Shape& S1, const TopoDS_Shape& S2);
+ Standard_EXPORT BRepAlgoAPI_Common(const TopoDS_Shape& S1,
+ const TopoDS_Shape& S2,
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Constructor with two shapes
//! <S1> -argument
//! <anOperation> - the type of the operation
//! <PF> - PaveFiller object that is carried out
//! Obsolete
- Standard_EXPORT BRepAlgoAPI_Common(const TopoDS_Shape& S1, const TopoDS_Shape& S2, const BOPAlgo_PaveFiller& PF);
+ Standard_EXPORT BRepAlgoAPI_Common(const TopoDS_Shape& S1,
+ const TopoDS_Shape& S2,
+ const BOPAlgo_PaveFiller& PF,
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//purpose :
//=======================================================================
BRepAlgoAPI_Cut::BRepAlgoAPI_Cut(const TopoDS_Shape& S1,
- const TopoDS_Shape& S2)
+ const TopoDS_Shape& S2,
+ const Message_ProgressRange& theRange)
:
BRepAlgoAPI_BooleanOperation(S1, S2, BOPAlgo_CUT)
{
- Build();
+ Build(theRange);
}
//=======================================================================
//function : BRepAlgoAPI_Cut
BRepAlgoAPI_Cut::BRepAlgoAPI_Cut(const TopoDS_Shape& S1,
const TopoDS_Shape& S2,
const BOPAlgo_PaveFiller& aDSF,
- const Standard_Boolean bFWD)
+ const Standard_Boolean bFWD,
+ const Message_ProgressRange& theRange)
:
BRepAlgoAPI_BooleanOperation(S1, S2, aDSF,
(bFWD) ? BOPAlgo_CUT : BOPAlgo_CUT21)
{
- Build();
+ Build(theRange);
}
//! <S2> -tool
//! <anOperation> - the type of the operation
//! Obsolete
- Standard_EXPORT BRepAlgoAPI_Cut(const TopoDS_Shape& S1, const TopoDS_Shape& S2);
+ Standard_EXPORT BRepAlgoAPI_Cut(const TopoDS_Shape& S1, const TopoDS_Shape& S2,
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Constructor with two shapes
//! <S1> -argument
//! <anOperation> - the type of the operation
//! <PF> - PaveFiller object that is carried out
//! Obsolete
- Standard_EXPORT BRepAlgoAPI_Cut(const TopoDS_Shape& S1, const TopoDS_Shape& S2, const BOPAlgo_PaveFiller& aDSF, const Standard_Boolean bFWD = Standard_True);
+ Standard_EXPORT BRepAlgoAPI_Cut(const TopoDS_Shape& S1, const TopoDS_Shape& S2, const BOPAlgo_PaveFiller& aDSF,
+ const Standard_Boolean bFWD = Standard_True,
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//function : Build
//purpose :
//=======================================================================
-void BRepAlgoAPI_Defeaturing::Build()
+void BRepAlgoAPI_Defeaturing::Build(const Message_ProgressRange& /*theRange*/)
{
// Set not done state for the operation
NotDone();
public: //! @name Performing the operation
//! Performs the operation
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
public: //! @name History Methods
//purpose :
//=======================================================================
BRepAlgoAPI_Fuse::BRepAlgoAPI_Fuse(const TopoDS_Shape& S1,
- const TopoDS_Shape& S2)
+ const TopoDS_Shape& S2,
+ const Message_ProgressRange& theRange)
:
BRepAlgoAPI_BooleanOperation(S1, S2, BOPAlgo_FUSE)
{
- Build();
+ Build(theRange);
}
//=======================================================================
//function : BRepAlgoAPI_Fuse
//=======================================================================
BRepAlgoAPI_Fuse::BRepAlgoAPI_Fuse(const TopoDS_Shape& S1,
const TopoDS_Shape& S2,
- const BOPAlgo_PaveFiller& aDSF)
+ const BOPAlgo_PaveFiller& aDSF,
+ const Message_ProgressRange& theRange)
:
BRepAlgoAPI_BooleanOperation(S1, S2, aDSF, BOPAlgo_FUSE)
{
- Build();
+ Build(theRange);
}
//! <S2> -tool
//! <anOperation> - the type of the operation
//! Obsolete
- Standard_EXPORT BRepAlgoAPI_Fuse(const TopoDS_Shape& S1, const TopoDS_Shape& S2);
+ Standard_EXPORT BRepAlgoAPI_Fuse(const TopoDS_Shape& S1, const TopoDS_Shape& S2,
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Constructor with two shapes
//! <S1> -argument
//! <anOperation> - the type of the operation
//! <PF> - PaveFiller object that is carried out
//! Obsolete
- Standard_EXPORT BRepAlgoAPI_Fuse(const TopoDS_Shape& S1, const TopoDS_Shape& S2, const BOPAlgo_PaveFiller& aDSF);
+ Standard_EXPORT BRepAlgoAPI_Fuse(const TopoDS_Shape& S1, const TopoDS_Shape& S2, const BOPAlgo_PaveFiller& aDSF,
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//function : Build
//purpose :
//=======================================================================
-void BRepAlgoAPI_Section::Build()
+void BRepAlgoAPI_Section::Build(const Message_ProgressRange& theRange)
{
- BRepAlgoAPI_BooleanOperation::Build();
+ BRepAlgoAPI_BooleanOperation::Build(theRange);
}
//=======================================================================
//function : HasAncestorFaceOn1
//! Performs the algorithm
//! Filling interference Data Structure (if it is necessary)
//! Building the result of the operation.
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! get the face of the first part giving section edge <E>.
// function: Build
// purpose:
//=======================================================================
-void BRepAlgoAPI_Splitter::Build()
+void BRepAlgoAPI_Splitter::Build(const Message_ProgressRange& theRange)
{
// Set Not Done status by default
NotDone();
}
// If necessary perform intersection of the argument shapes
+ Message_ProgressScope aPS(theRange, "Performing Split operation", myIsIntersectionNeeded ? 100 : 30);
if (myIsIntersectionNeeded)
{
// Combine Arguments and Tools for intersection into a single list
aLArgs.Append(it.Value());
// Perform intersection
- IntersectShapes(aLArgs);
+ IntersectShapes(aLArgs, aPS.Next(70));
if (HasErrors())
return;
}
((BOPAlgo_Splitter*)myBuilder)->SetTools(myTools);
// Build result shape basing on the intersection results
- BuildResult();
+ BuildResult(aPS.Next(30));
}
//! Performs the Split operation.
//! Performs the intersection of the argument shapes (both objects and tools)
//! and splits objects by the tools.
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
protected: //! @name Fields
//purpose :
//=======================================================================
-void BRepBuilderAPI_MakeShape::Build()
+void BRepBuilderAPI_MakeShape::Build(const Message_ProgressRange& /*theRange*/)
{
}
#include <TopTools_ListOfShape.hxx>
#include <BRepBuilderAPI_Command.hxx>
#include <Standard_Boolean.hxx>
+#include <Message_ProgressRange.hxx>
class StdFail_NotDone;
class TopoDS_Shape;
//! This is called by Shape(). It does nothing but
//! may be redefined.
- Standard_EXPORT virtual void Build();
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange());
//! Returns a shape built by the shape construction algorithm.
//! Raises exception StdFail_NotDone if the shape was not built.
//function : PerformResult
//purpose :
//=======================================================================
- void BRepFeat_Builder::PerformResult()
+ void BRepFeat_Builder::PerformResult(const Message_ProgressRange& theRange)
{
myOperation = myFuse ? BOPAlgo_FUSE : BOPAlgo_CUT;
- //
- if (!myShapes.IsEmpty()) {
- //
- Prepare();
- //
- RebuildFaces();
- //
- FillImagesContainers(TopAbs_SHELL);
- if (HasErrors()) {
- return;
- }
- //
- FillImagesSolids();
- if (HasErrors()) {
- return;
- }
- //
- CheckSolidImages();
- //
- BuildResult(TopAbs_SOLID);
- if (HasErrors()) {
- return;
- }
- //
- FillImagesCompounds();
- if (HasErrors()) {
- return;
- }
- //
- BuildResult(TopAbs_COMPOUND);
- if (HasErrors()) {
- return;
+ if (myShapes.IsEmpty())
+ {
+ BuildShape(theRange);
+ return;
+ }
+
+ Standard_Real aWhole = 100.;
+ Message_ProgressScope aPS(theRange, "BRepFeat_Builder", aWhole);
+ Standard_Real aBSPart = 15;
+ aWhole -= aBSPart;
+
+ // Compute PI steps
+ const Standard_Integer aSize = 4;
+ NCollection_Array1<Standard_Real> aSteps(0, aSize - 1);
+ {
+ for (Standard_Integer i = 0; i < aSize; ++i)
+ aSteps(i) = 0.;
+
+ NbShapes aNbShapes = getNbShapes();
+ Standard_Real aTreatFaces = 5 * aNbShapes.NbFaces();
+ Standard_Real aTreatShells = aNbShapes.NbShells();
+ Standard_Real aTreatSolids = 20 * aNbShapes.NbSolids();
+ Standard_Real aTreatCompounds = aNbShapes.NbCompounds();
+
+ Standard_Real aSum = aTreatFaces + aTreatShells + aTreatSolids + aTreatCompounds;
+ if (aSum > 0)
+ {
+ aSteps(0) = aTreatFaces * aWhole / aSum;
+ aSteps(1) = aTreatShells * aWhole / aSum;
+ aSteps(2) = aTreatSolids * aWhole / aSum;
+ aSteps(3) = aTreatCompounds * aWhole / aSum;
}
}
//
- BuildShape();
+ Prepare();
+ //
+ RebuildFaces();
+ aPS.Next(aSteps(0));
+ //
+ FillImagesContainers(TopAbs_SHELL, aPS.Next(aSteps(1)));
+ if (HasErrors()) {
+ return;
+ }
+ //
+ FillImagesSolids(aPS.Next(aSteps(2)));
+ if (HasErrors()) {
+ return;
+ }
+ //
+ CheckSolidImages();
+ //
+ BuildResult(TopAbs_SOLID);
+ if (HasErrors()) {
+ return;
+ }
+ //
+ FillImagesCompounds(aPS.Next(aSteps(3)));
+ if (HasErrors()) {
+ return;
+ }
+ //
+ BuildResult(TopAbs_COMPOUND);
+ if (HasErrors()) {
+ return;
+ }
+ //
+ BuildShape(aPS.Next(aBSPart));
}
//=======================================================================
//function : FillIn3DParts
//purpose :
//=======================================================================
- void BRepFeat_Builder::FillIn3DParts(TopTools_DataMapOfShapeShape& theDraftSolids)
+ void BRepFeat_Builder::FillIn3DParts(TopTools_DataMapOfShapeShape& theDraftSolids,
+ const Message_ProgressRange& theRange)
{
GetReport()->Clear();
- BOPAlgo_Builder::FillIn3DParts(theDraftSolids);
+ BOPAlgo_Builder::FillIn3DParts(theDraftSolids, theRange);
// Clear the IN parts of the solids from the removed faces
TopTools_DataMapOfShapeListOfShape::Iterator itM(myInParts);
//! Main function to build the result of the
//! local operation required.
- Standard_EXPORT void PerformResult();
+ Standard_EXPORT void PerformResult(const Message_ProgressRange& theRange = Message_ProgressRange());
//! Rebuilds faces in accordance with the kept parts of the tool.
Standard_EXPORT void RebuildFaces();
protected:
-
//! Prepares builder of local operation.
Standard_EXPORT virtual void Prepare() Standard_OVERRIDE;
//! Function is redefined to avoid the usage of removed faces.
- Standard_EXPORT virtual void FillIn3DParts (TopTools_DataMapOfShapeShape& theDraftSolids) Standard_OVERRIDE;
+ Standard_EXPORT virtual void FillIn3DParts (TopTools_DataMapOfShapeShape& theDraftSolids,
+ const Message_ProgressRange& theRange) Standard_OVERRIDE;
//! Avoid the check for open solids and always use the splits
//! of solids for building the result shape.
//function : Build
//purpose :
//=======================================================================
-void BRepFeat_Gluer::Build()
+void BRepFeat_Gluer::Build(const Message_ProgressRange& /*theRange*/)
{
myGluer.Perform();
if (myGluer.IsDone()) {
//! This is called by Shape(). It does nothing but
//! may be redefined.
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! returns the status of the Face after
//! the shape creation.
//function : Build
//purpose :
//=======================================================================
-void BRepFeat_SplitShape::Build ()
+void BRepFeat_SplitShape::Build (const Message_ProgressRange& /*theRange*/)
{
mySShape.Perform(myWOnShape);
if (mySShape.IsDone()) {
Standard_EXPORT const TopTools_ListOfShape& Right() const;
//! Builds the cut and the resulting faces and edges as well.
- Standard_EXPORT void Build() Standard_OVERRIDE;
+ Standard_EXPORT void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Returns true if the shape has been deleted.
Standard_EXPORT virtual Standard_Boolean IsDeleted (const TopoDS_Shape& S) Standard_OVERRIDE;
TopTools_ListOfShape aLO, aLT;
aLO.Append(Sol1);
aLT.Append(Sol2);
- aBuilder.BuildBOP(aLO, aLT, BOPAlgo_CUT);
+ aBuilder.BuildBOP(aLO, aLT, BOPAlgo_CUT, Message_ProgressRange());
if (!aBuilder.HasErrors())
{
TopoDS_Solid aCutMin;
aLO.Clear();
aLO.Append(aCutMin);
- aGluer.BuildBOP(aLO, State1, aLT, State2);
+ aGluer.BuildBOP(aLO, State1, aLT, State2, Message_ProgressRange());
if (!aGluer.HasErrors())
{
aLO.Append(Sol1);
aLT.Append(Sol2);
- aBuilder.BuildBOP(aLO, State1, aLT, State2);
+ aBuilder.BuildBOP(aLO, State1, aLT, State2, Message_ProgressRange());
if (aBuilder.HasErrors())
return Standard_False;
//purpose :
//=======================================================================
-void BRepFilletAPI_MakeChamfer::Build()
+void BRepFilletAPI_MakeChamfer::Build(const Message_ProgressRange& /*theRange*/)
{
myBuilder.Compute();
if (myBuilder.IsDone()){
//! intersection of 4 or more edges of the shape, or
//! - the intersection of the chamfer with a face which
//! limits the contour is not fully contained in this face.
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Reinitializes this algorithm, thus canceling the effects of the Build function.
//! This function allows modifications to be made to the
//purpose :
//=======================================================================
-void BRepFilletAPI_MakeFillet::Build()
+void BRepFilletAPI_MakeFillet::Build(const Message_ProgressRange& /*theRange*/)
{
myBuilder.Compute();
if(myBuilder.IsDone()) {
//! intersection of 4 or more edges of the shape, or
//! - the intersection of the fillet with a face which limits
//! the contour is not fully contained in this face.
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Reinitializes this algorithm, thus canceling the effects of the Build function.
//! This function allows modifications to be made to the
//purpose :
//=======================================================================
-void BRepFilletAPI_MakeFillet2d::Build()
+void BRepFilletAPI_MakeFillet2d::Build(const Message_ProgressRange& /*theRange*/)
{
// test if the operation is done
if (Status() == ChFi2d_IsDone) {
ChFi2d_ConstructionError Status() const;
//! Update the result and set the Done flag
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//purpose :
//=======================================================================
-void BRepOffsetAPI_DraftAngle::Build()
+void BRepOffsetAPI_DraftAngle::Build(const Message_ProgressRange& /*theRange*/)
{
Handle(Draft_Modification)::DownCast (myModification)->Perform();
if (!Handle(Draft_Modification)::DownCast (myModification)->IsDone()) {
Standard_EXPORT const TopTools_ListOfShape& ModifiedFaces() const;
//! Builds the resulting shape (redefined from MakeShape).
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
Standard_EXPORT void CorrectWires();
//function : Build
//purpose :
//=======================================================================
-void BRepOffsetAPI_MakeEvolved::Build()
+void BRepOffsetAPI_MakeEvolved::Build(const Message_ProgressRange& /*theRange*/)
{
if (myEvolved.IsDone())
{
Standard_EXPORT const BRepFill_Evolved& Evolved() const;
//! Builds the resulting shape (redefined from MakeShape).
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Returns the shapes created from a subshape
//! <SpineShape> of the spine and a subshape
//function : Build
//purpose : builds the resulting face
//======================================================================
-void BRepOffsetAPI_MakeFilling::Build()
+void BRepOffsetAPI_MakeFilling::Build(const Message_ProgressRange& /*theRange*/)
{
myFilling.Build();
myShape = myFilling.Face();
Standard_EXPORT Standard_Integer Add (const Standard_Real U, const Standard_Real V, const TopoDS_Face& Support, const GeomAbs_Shape Order);
//! Builds the resulting faces
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Tests whether computation of the filling plate has been completed.
Standard_EXPORT virtual Standard_Boolean IsDone() const Standard_OVERRIDE;
//purpose :
//=======================================================================
-void BRepOffsetAPI_MakeOffset::Build()
+void BRepOffsetAPI_MakeOffset::Build(const Message_ProgressRange& /*theRange*/)
{
Done();
}
Standard_EXPORT void Perform (const Standard_Real Offset, const Standard_Real Alt = 0.0);
//! Builds the resulting shape (redefined from MakeShape).
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! returns a list of the created shapes
//! from the shape <S>.
//function : Build
//purpose :
//=======================================================================
-void BRepOffsetAPI_MakeOffsetShape::Build()
+void BRepOffsetAPI_MakeOffsetShape::Build(const Message_ProgressRange& /*theRange*/)
{
}
Standard_EXPORT virtual const BRepOffset_MakeOffset& MakeOffset() const;
//! Does nothing.
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Returns the list of shapes generated from the shape <S>.
Standard_EXPORT virtual const TopTools_ListOfShape& Generated (const TopoDS_Shape& S) Standard_OVERRIDE;
//purpose :
//=======================================================================
-void BRepOffsetAPI_MakePipe::Build()
+void BRepOffsetAPI_MakePipe::Build(const Message_ProgressRange& /*theRange*/)
{
myShape = myPipe.Shape();
//Check for emptiness of result
Standard_EXPORT const BRepFill_Pipe& Pipe() const;
//! Builds the resulting shape (redefined from MakeShape).
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Returns the TopoDS Shape of the bottom of the prism.
Standard_EXPORT TopoDS_Shape FirstShape() Standard_OVERRIDE;
//function :Build()
//purpose :
//=======================================================================
- void BRepOffsetAPI_MakePipeShell::Build()
+ void BRepOffsetAPI_MakePipeShell::Build(const Message_ProgressRange& /*theRange*/)
{
Standard_Boolean Ok;
Ok = myPipe->Build();
Standard_EXPORT void Simulate (const Standard_Integer NumberOfSection, TopTools_ListOfShape& Result);
//! Builds the resulting shape (redefined from MakeShape).
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Transforms the sweeping Shell in Solid.
//! If a propfile is not closed returns False
//function : Build
//purpose :
//=======================================================================
-void BRepOffsetAPI_MakeThickSolid::Build()
+void BRepOffsetAPI_MakeThickSolid::Build(const Message_ProgressRange& /*theRange*/)
{
}
const Standard_Boolean RemoveIntEdges = Standard_False);
// Does nothing.
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Returns the list of shapes modified from the shape
//! <S>.
//purpose :
//=======================================================================
-void BRepOffsetAPI_MiddlePath::Build()
+void BRepOffsetAPI_MiddlePath::Build(const Message_ProgressRange& /*theRange*/)
{
TopTools_ListIteratorOfListOfShape itl;
//! a wire or a face
Standard_EXPORT BRepOffsetAPI_MiddlePath(const TopoDS_Shape& aShape, const TopoDS_Shape& StartShape, const TopoDS_Shape& EndShape);
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
myNormalProjector.Compute3d(With3d);
}
- void BRepOffsetAPI_NormalProjection::Build()
+ void BRepOffsetAPI_NormalProjection::Build(const Message_ProgressRange& /*theRange*/)
{
myNormalProjector.Build();
myShape = myNormalProjector.Projection();
//! Builds the result of the projection as a compound of
//! wires. Tries to build oriented wires.
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Returns true if the object was correctly built by the shape
//! construction algorithm.
//purpose :
//=======================================================================
-void BRepOffsetAPI_ThruSections::Build()
+void BRepOffsetAPI_ThruSections::Build(const Message_ProgressRange& /*theRange*/)
{
//Check set of section for right configuration of punctual sections
Standard_Integer i;
//! the optimization.
Standard_EXPORT void CriteriumWeight (Standard_Real& W1, Standard_Real& W2, Standard_Real& W3) const;
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Returns the TopoDS Shape of the bottom of the loft if solid
Standard_EXPORT const TopoDS_Shape& FirstShape() const;
//function : Build
//purpose :
//=======================================================================
-void BRepPreviewAPI_MakeBox::Build()
+void BRepPreviewAPI_MakeBox::Build(const Message_ProgressRange& /*theRange*/)
{
gp_Pnt anLocation = myWedge.Axes().Location();
BRepPreviewAPI_MakeBox() {}
//! Creates a preview depending on point values.
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
private:
//purpose :
//=======================================================================
-void BRepPrimAPI_MakeBox::Build()
+void BRepPrimAPI_MakeBox::Build(const Message_ProgressRange& /*theRange*/)
{
Solid();
}
Standard_EXPORT BRepPrim_Wedge& Wedge();
//! Stores the solid in myShape.
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Returns the constructed box as a shell.
Standard_EXPORT const TopoDS_Shell& Shell();
//purpose :
//=======================================================================
-void BRepPrimAPI_MakeOneAxis::Build()
+void BRepPrimAPI_MakeOneAxis::Build(const Message_ProgressRange& /*theRange*/)
{
BRep_Builder B;
B.MakeSolid(TopoDS::Solid(myShape));
Standard_EXPORT virtual Standard_Address OneAxis() = 0;
//! Stores the solid in myShape.
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Returns the lateral face of the rotational primitive.
Standard_EXPORT const TopoDS_Face& Face();
//purpose :
//=======================================================================
-void BRepPrimAPI_MakePrism::Build()
+void BRepPrimAPI_MakePrism::Build(const Message_ProgressRange& /*theRange*/)
{
myShape = myPrism.Shape();
Done();
Standard_EXPORT const BRepSweep_Prism& Prism() const;
//! Builds the resulting shape (redefined from MakeShape).
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Returns the TopoDS Shape of the bottom of the prism.
Standard_EXPORT TopoDS_Shape FirstShape() Standard_OVERRIDE;
//purpose :
//=======================================================================
-void BRepPrimAPI_MakeRevol::Build()
+void BRepPrimAPI_MakeRevol::Build(const Message_ProgressRange& /*theRange*/)
{
if (myIsBuild)
{
Standard_EXPORT const BRepSweep_Revol& Revol() const;
//! Builds the resulting shape (redefined from MakeShape).
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Returns the first shape of the revol (coinciding with
//! the generating shape).
//purpose :
//=======================================================================
-void BRepPrimAPI_MakeWedge::Build()
+void BRepPrimAPI_MakeWedge::Build(const Message_ProgressRange& /*theRange*/)
{
BRep_Builder B;
B.MakeSolid(TopoDS::Solid(myShape));
Standard_EXPORT BRepPrim_Wedge& Wedge();
//! Stores the solid in myShape.
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Returns the constructed box in the form of a shell.
Standard_EXPORT const TopoDS_Shell& Shell();
#include <TopAbs.hxx>
#include <DrawTrSurf.hxx>
#include <Message.hxx>
+#include <Draw_ProgressIndicator.hxx>
#include <stdio.h>
}
BOPAlgo_PaveFiller theDSFiller;
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
+ Message_ProgressScope aPS(aProgress->Start(), NULL, 10);
TopTools_ListOfShape aLS;
aLS.Append(S1);
aLS.Append(S2);
theDSFiller.SetArguments(aLS);
//
- theDSFiller.Perform();
+ theDSFiller.Perform(aPS.Next(8));
if (theDSFiller.HasErrors()) {
Message::SendFail() << "Check types of the arguments, please";
return 1;
}
BRepAlgoAPI_BooleanOperation* pBuilder=NULL;
-
if (fuse)
- pBuilder = new BRepAlgoAPI_Fuse( S1, S2, theDSFiller );
+ pBuilder = new BRepAlgoAPI_Fuse( S1, S2, theDSFiller, aPS.Next(2) );
else
- pBuilder = new BRepAlgoAPI_Cut ( S1, S2, theDSFiller );
+ pBuilder = new BRepAlgoAPI_Cut ( S1, S2, theDSFiller, Standard_True, aPS.Next(2));
Standard_Boolean anIsDone = pBuilder->IsDone();
if (!anIsDone)
// unless show is forced, show updated state only if at least 1% progress has been reached since the last update
Standard_Real aPosition = GetPosition();
- if ( ! force && aPosition < 1. && Abs (aPosition - myLastPosition) < myUpdateThreshold)
+ if ( ! force && (1. - aPosition) > Precision::Confusion() && Abs (aPosition - myLastPosition) < myUpdateThreshold)
return; // return if update interval has not elapsed
myLastPosition = aPosition;
//purpose :
//=======================================================================
- void ShapeConstruct_MakeTriangulation::Build()
+ void ShapeConstruct_MakeTriangulation::Build(const Message_ProgressRange& /*theRange*/)
{
if (myShape.IsNull()) {
// Triangulate polygonal wire
Standard_EXPORT ShapeConstruct_MakeTriangulation(const TopoDS_Wire& wire, const Standard_Real prec = 0.0);
- Standard_EXPORT virtual void Build() Standard_OVERRIDE;
+ Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
Standard_EXPORT virtual Standard_Boolean IsDone() const Standard_OVERRIDE;
--- /dev/null
+puts "============================================"
+puts "0021264: Modeling Algorithms - Progress indicator for Boolean operations"
+puts "============================================"
+puts ""
+
+proc isTracked { theOutput } {
+ if {![regexp "Progress" $theOutput]} {
+ puts "Error: progress is not tracked"
+ }
+}
+
+XProgress +t
+
+box b1 10 10 10
+box b2 5 5 5 10 10 10
+
+# check that progress is tracked for boolean operations
+
+# bop + operations
+
+set log [bop b1 b2]
+isTracked $log
+
+set log [bopfuse r]
+isTracked $log
+
+set log [bopcommon r]
+isTracked $log
+
+set log [bopcut r]
+isTracked $log
+
+set log [boptuc r]
+isTracked $log
+
+set log [bopsection r]
+isTracked $log
+
+
+# b[operation]
+
+set log [bfuse r b1 b2]
+isTracked $log
+
+set log [bcommon r b1 b2]
+isTracked $log
+
+set log [bcut r b1 b2]
+isTracked $log
+
+set log [btuc r b1 b2]
+isTracked $log
+
+set log [bsection r b1 b2]
+isTracked $log
+
+
+# bfillds + bbop
+
+bclearobjects
+bcleartools
+baddobjects b1
+baddtools b2
+
+set log [bfillds]
+isTracked $log
+
+set log [bbop r 0]
+isTracked $log
+
+set log [bbop r 1]
+isTracked $log
+
+set log [bbop r 2]
+isTracked $log
+
+set log [bbop r 3]
+isTracked $log
+
+set log [bbop r 4]
+isTracked $log
+
+set log [bbuild r]
+isTracked $log
+
+set log [bsplit r]
+isTracked $log
+
+
+# API
+
+set log [bapibop r 0]
+isTracked $log
+
+set log [bapibop r 1]
+isTracked $log
+
+set log [bapibop r 2]
+isTracked $log
+
+set log [bapibop r 3]
+isTracked $log
+
+set log [bapibop r 4]
+isTracked $log
+
+set log [bapibuild r]
+isTracked $log
+
+set log [bapisplit r]
+isTracked $log
+
+
+# bopcheck
+
+set log [bopcheck r]
+isTracked $log
projects / occt.git / commitdiff