#include <TopoDS_AlertWithShape.hxx>
+//! Boolean operation was stoped by user
+DEFINE_SIMPLE_ALERT(BOPAlgo_AlertBOPUserBreak)
+
//! Boolean operation of given type is not allowed on the given inputs
DEFINE_SIMPLE_ALERT(BOPAlgo_AlertBOPNotAllowed)
{
GetReport()->Clear(Message_Fail);
}
+
+NCollection_Array1<Standard_Real> BOPAlgo_Algo::AnalyzeProgress()
+{
+ return NCollection_Array1<Standard_Real>();
+}
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
+#include <Message_ProgressRange.hxx>
+#include <NCollection_Array1.hxx>
#include <BOPAlgo_Options.hxx>
DEFINE_STANDARD_ALLOC
- Standard_EXPORT virtual void Perform() = 0;
+ Standard_EXPORT virtual void Perform(const Message_ProgressRange& theRange = Message_ProgressRange()) = 0;
protected:
//! Checks the obtained result
Standard_EXPORT virtual void CheckResult();
+ //! Analyze progress steps
+ Standard_EXPORT virtual NCollection_Array1<Standard_Real> AnalyzeProgress();
+
};
#endif // _BOPAlgo_Algo_HeaderFile
// function: Perform
// purpose:
// ================================================================================
-void BOPAlgo_ArgumentAnalyzer::Perform()
+void BOPAlgo_ArgumentAnalyzer::Perform(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPS(theRange, "Analyze", 1);
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());
+ 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)
{
Standard_Integer ii;
//
+ Message_ProgressScope aPS(theRange, NULL, 2);
for(ii = 0; ii < 2; ii++) {
const TopoDS_Shape& aS = (ii == 0) ? myShape1 : myShape2;
if(aS.IsNull()) {
aChecker.SetNonDestructive(Standard_True);
aChecker.SetRunParallel(myRunParallel);
aChecker.SetFuzzyValue(myFuzzyValue);
- aChecker.SetProgressIndicator(*myProgressScope);
//
- aChecker.Perform();
+ aChecker.Perform(aPS.Next());
+ if (UserBreak(aPS))
+ {
+ return;
+ }
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, "BOPAlgo_BOP::Perform()", 10);
+
pPF->SetFuzzyValue(myFuzzyValue);
pPF->SetNonDestructive(myNonDestructive);
pPF->SetGlue(myGlue);
pPF->SetUseOBB(myUseOBB);
//
- pPF->Perform();
+ pPF->Perform(aPS.Next(9));
//
+ if (!aPS.More())
+ {
+ return;
+ }
myEntryPoint=1;
- PerformInternal(*pPF);
+ PerformInternal(*pPF, aPS.Next(1));
}
//=======================================================================
//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();
}
}
//
+ Message_ProgressScope aPS(theRange, "PerformInternal", 100);
// 3. Fill Images
// 3.1 Vertices
- FillImagesVertices();
+ FillImagesVertices(aPS.Next(5)); // 5
if (HasErrors()) {
return;
}
return;
}
// 3.2 Edges
- FillImagesEdges();
+ FillImagesEdges(aPS.Next(5)); // 10
if (HasErrors()) {
return;
}
}
//
// 3.3 Wires
- FillImagesContainers(TopAbs_WIRE);
+ FillImagesContainers(TopAbs_WIRE, aPS.Next(10)); // 20
if (HasErrors()) {
return;
}
}
//
// 3.4 Faces
- FillImagesFaces();
+ FillImagesFaces(aPS.Next(30)); // 50
if (HasErrors()) {
return;
}
-
+
BuildResult(TopAbs_FACE);
if (HasErrors()) {
return;
}
//
// 3.5 Shells
- FillImagesContainers(TopAbs_SHELL);
+ FillImagesContainers(TopAbs_SHELL, aPS.Next(10)); // 60
if (HasErrors()) {
return;
}
}
//
// 3.6 Solids
- FillImagesSolids();
+ FillImagesSolids(aPS.Next(5)); // 65
if (HasErrors()) {
return;
}
}
//
// 3.7 CompSolids
- FillImagesContainers(TopAbs_COMPSOLID);
+ FillImagesContainers(TopAbs_COMPSOLID, aPS.Next(10)); // 75
if (HasErrors()) {
return;
}
}
//
// 3.8 Compounds
- FillImagesCompounds();
+ FillImagesCompounds(aPS.Next(10)); // 85
if (HasErrors()) {
return;
}
}
//
// 4.BuildShape;
- BuildShape();
+ BuildShape(aPS.Next(15)); // 100
if (HasErrors()) {
return;
}
//function : BuildShape
//purpose :
//=======================================================================
-void BOPAlgo_BOP::BuildShape()
+void BOPAlgo_BOP::BuildShape(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPS(theRange, "BuildShape", 1);
if (myDims[0] == 3 && myDims[1] == 3)
{
// For the Boolean operation on solids we need to check first
TopTools_MapOfShape aMInpFence;
aItLS.Initialize(aLSC);
for (; aItLS.More(); aItLS.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const TopoDS_Shape& aSC = aItLS.Value();
aMInpFence.Add(aSC);
//
//
aIt.Initialize(aSC);
for (; aIt.More(); aIt.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const TopoDS_Shape& aS = aIt.Value();
if (myImages.IsBound(aS)) {
const TopTools_ListOfShape& aLSIm = myImages.Find(aS);
//
aItLCB.Initialize(aLCB);
for (; aItLCB.More(); aItLCB.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
BOPTools_AlgoTools::MakeContainer(aType, aRCB);
//
const TopoDS_Shape& aCB = aItLCB.Value();
aItLS.Initialize(aLSNonCont);
for (; aItLS.More(); aItLS.Next())
{
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const TopoDS_Shape& aS = aItLS.Value();
if (myImages.IsBound(aS))
{
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();
//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, "BOPAlgo_Builder::Perform()", 10);
pPF->SetFuzzyValue(myFuzzyValue);
pPF->SetNonDestructive(myNonDestructive);
pPF->SetGlue(myGlue);
pPF->SetUseOBB(myUseOBB);
//
- pPF->Perform();
+ pPF->Perform(aPS.Next(9));
//
+ if (HasErrors())
+ {
+ return;
+ }
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);
+ Message_ProgressScope aPS(theRange, NULL, 1);
+ PerformInternal(theFiller, aPS.Next());
}
//=======================================================================
//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&) {
//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, "PerformInternal", 100);
// 1. CheckData
CheckData();
if (HasErrors()) {
//
// 3. Fill Images
// 3.1 Vertice
- FillImagesVertices();
+ FillImagesVertices(aPS.Next(10)); // 10
if (HasErrors()) {
return;
}
return;
}
// 3.2 Edges
- FillImagesEdges();
+ FillImagesEdges(aPS.Next(10)); // 20
if (HasErrors()) {
return;
}
}
//
// 3.3 Wires
- FillImagesContainers(TopAbs_WIRE);
+ FillImagesContainers(TopAbs_WIRE, aPS.Next(10)); // 30
if (HasErrors()) {
return;
}
}
// 3.4 Faces
- FillImagesFaces();
+ FillImagesFaces(aPS.Next(30)); // 60
if (HasErrors()) {
return;
}
return;
}
// 3.5 Shells
- FillImagesContainers(TopAbs_SHELL);
+ FillImagesContainers(TopAbs_SHELL, aPS.Next(10)); // 70
if (HasErrors()) {
return;
}
return;
}
// 3.6 Solids
- FillImagesSolids();
+ FillImagesSolids(aPS.Next(10)); // 80
if (HasErrors()) {
return;
}
return;
}
// 3.7 CompSolids
- FillImagesContainers(TopAbs_COMPSOLID);
+ FillImagesContainers(TopAbs_COMPSOLID, aPS.Next(10)); // 90
if (HasErrors()) {
return;
}
}
// 3.8 Compounds
- FillImagesCompounds();
+ FillImagesCompounds(aPS.Next(10)); // 100
if (HasErrors()) {
return;
}
aBS.SetRunParallel(myRunParallel);
aBS.SetContext(myContext);
aBS.SetFuzzyValue(myFuzzyValue);
- if (myProgressScope != NULL)
- {
- aBS.SetProgressIndicator(*myProgressScope);
- }
aBS.Perform();
// Resulting solids
//! 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
//! 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.
//! 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.
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,
//function : Perform
//purpose :
//=======================================================================
-void BOPAlgo_BuilderFace::Perform()
+void BOPAlgo_BuilderFace::Perform(const Message_ProgressRange& theRange)
{
GetReport()->Clear();
//
+ Message_ProgressScope aPS(theRange, NULL, 1);
CheckData();
- if (HasErrors()) {
+ if (HasErrors() && UserBreak(aPS)) {
return;
}
//
- UserBreak();
- //
PerformShapesToAvoid();
- if (HasErrors()) {
+ if (HasErrors() && UserBreak(aPS)) {
return;
}
//
- UserBreak();
- //
PerformLoops();
- if (HasErrors()) {
+ if (HasErrors() && UserBreak(aPS)) {
return;
}
//
- UserBreak();
- //
PerformAreas();
- if (HasErrors()) {
+ if (HasErrors() && UserBreak(aPS)) {
return;
}
//
- UserBreak();
- //
PerformInternalShapes();
if (HasErrors()) {
return;
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;
//function : Perform
//purpose :
//=======================================================================
-void BOPAlgo_BuilderSolid::Perform()
+void BOPAlgo_BuilderSolid::Perform(const Message_ProgressRange& theRange)
{
GetReport()->Clear();
//
BRep_Builder aBB;
TopTools_ListIteratorOfListOfShape aIt;
//
+ Message_ProgressScope aPS(theRange, NULL, 1);
aBB.MakeCompound(aC);
aIt.Initialize(myShapes);
for(; aIt.More(); aIt.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const TopoDS_Shape& aF=aIt.Value();
aBB.Add(aC, aF);
}
//
- UserBreak();
+
//
PerformShapesToAvoid();
- if (HasErrors()) {
+ if (HasErrors() && UserBreak(aPS)) {
return;
}
//
- UserBreak();
- //
PerformLoops();
- if (HasErrors()) {
+ if (HasErrors() && UserBreak(aPS)) {
return;
}
//
- UserBreak();
- //
PerformAreas();
- if (HasErrors()) {
+ if (HasErrors() && UserBreak(aPS)) {
return;
}
//
- UserBreak();
- //
PerformInternalShapes();
if (HasErrors()) {
return;
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
//function : FillImagesVertices
//purpose :
//=======================================================================
-void BOPAlgo_Builder::FillImagesVertices()
+void BOPAlgo_Builder::FillImagesVertices(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPS(theRange, "FillImagesVertices", 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, "FillImagesEdges", aNbS);
+ for (i = 0; i < aNbS; ++i, aPS.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const BOPDS_ShapeInfo& aSI = myDS->ShapeInfo(i);
if (aSI.ShapeType() != TopAbs_EDGE) {
continue;
//
BOPDS_ListIteratorOfListOfPaveBlock aItPB(aLPB);
for (; aItPB.More(); aItPB.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const Handle(BOPDS_PaveBlock)& aPB = aItPB.Value();
Handle(BOPDS_PaveBlock) aPBR = myDS->RealPaveBlock(aPB);
//
// 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();
- for (i=0; i<aNbS; ++i) {
+ Message_ProgressScope aPS(theRange, "FillImagesContainers", aNbS);
+ for (i=0; i<aNbS; ++i, aPS.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const BOPDS_ShapeInfo& aSI=myDS->ShapeInfo(i);
if (aSI.ShapeType()==theType) {
const TopoDS_Shape& aC=aSI.Shape();
// 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, "FillImagesCompounds", aNbS);
+ for (i=0; i<aNbS; ++i, aPS.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const BOPDS_ShapeInfo& aSI=myDS->ShapeInfo(i);
if (aSI.ShapeType()==TopAbs_COMPOUND) {
const TopoDS_Shape& aC=aSI.Shape();
return myContext;
}
//
- virtual void Perform() {
- BOPAlgo_Algo::UserBreak();
+ virtual void Perform(const Message_ProgressRange& /*theRange*/ = Message_ProgressRange()) {
//
const TopoDS_Face& aFj=*((TopoDS_Face*)&myShape1);
const TopoDS_Face& aFk=*((TopoDS_Face*)&myShape2);
return myContext;
}
//
- virtual void Perform() {
+ virtual void Perform(const Message_ProgressRange& /*theRange*/ = Message_ProgressRange()) {
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)
{
+ Message_ProgressScope aPS(theRange, "FillImagesFaces", 1);
BuildSplitFaces();
+ if (UserBreak(aPS))
+ {
+ return;
+ }
FillSameDomainFaces();
+ if (UserBreak(aPS))
+ {
+ return;
+ }
FillInternalVertices();
}
//=======================================================================
aBF.SetFace(aF);
aBF.SetShapes(aLE);
aBF.SetRunParallel(myRunParallel);
- if (myProgressScope != NULL)
- {
- aBF.SetProgressIndicator(*myProgressScope);
- }
//
}// for (i=0; i<aNbS; ++i) {
//
aPSB.Shape1() = aF1;
aPSB.Shape2() = aF2;
aPSB.SetFuzzyValue(myFuzzyValue);
- if (myProgressScope != NULL)
- {
- aPSB.SetProgressIndicator(*myProgressScope);
- }
}
}
}
aVFI.SetVertex(aV);
aVFI.SetFace(aFIm);
aVFI.SetFuzzyValue(myFuzzyValue);
- if (myProgressScope != NULL)
- {
- aVFI.SetProgressIndicator(*myProgressScope);
- }
}
}
}
//function : FillImagesSolids
//purpose :
//=======================================================================
-void BOPAlgo_Builder::FillImagesSolids()
+void BOPAlgo_Builder::FillImagesSolids(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPS(theRange, "FillImagesSolid", 1);
Standard_Boolean bHasSolids;
Standard_Integer i, aNbS;
//
bHasSolids=Standard_False;
aNbS=myDS->NbSourceShapes();
for (i=0; i<aNbS; ++i) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const BOPDS_ShapeInfo& aSI=myDS->ShapeInfo(i);
if (aSI.ShapeType()==TopAbs_SOLID) {
bHasSolids=!bHasSolids;
TopTools_DataMapOfShapeShape aDraftSolids;
// Find all IN faces for all IN faces
FillIn3DParts(aDraftSolids);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
// Build split of the solids
BuildSplitSolids(aDraftSolids);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
// Fill solids with internal parts
FillInternalShapes();
}
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;
continue;
}
//
- UserBreak();
- //
const TopoDS_Shape& aS=aSI.Shape();
//
aMx.Clear();
//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, "BOPAlgo_CellsBuilder", 1);
+ BOPAlgo_Builder::PerformInternal1(theFiller, aPS.Next());
if (HasErrors()) {
return;
}
//! 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();
return myTolF;
}
//
- virtual void Perform() {
- BOPAlgo_Algo::UserBreak();
+ virtual void Perform(const Message_ProgressRange& theRange = Message_ProgressRange()) {
+ Message_ProgressScope aPS(theRange, NULL, 1);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
IntTools_FaceFace::Perform(myF, myF);
}
//
//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, NULL, 1);
// Perform intersection of sub shapes
- BOPAlgo_PaveFiller::Perform();
+ BOPAlgo_PaveFiller::Perform(aPS.Next());
+ if (UserBreak(aPS))
+ {
+ return;
+ }
//
CheckFaceSelfIntersection();
aFaceSelfIntersect.SetIndex(i);
aFaceSelfIntersect.SetFace(aF);
aFaceSelfIntersect.SetTolF(aTolF);
- //
- if (myProgressScope != NULL)
- {
- aFaceSelfIntersect.SetProgressIndicator(*myProgressScope);
- }
}
Standard_Integer aNbFace = aVFace.Length();
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();
//function : Perform
//purpose :
//=======================================================================
-void BOPAlgo_MakerVolume::Perform()
+void BOPAlgo_MakerVolume::Perform(const Message_ProgressRange& theRange)
{
GetReport()->Clear();
//
}
//
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, "MakerVolume", 10);
+ pPF->Perform(aPS.Next(9));
+ if (HasErrors())
+ {
+ return;
+ }
//
myEntryPoint = 1;
- PerformInternal(*pPF);
+ PerformInternal(*pPF, aPS.Next(1));
}
//=======================================================================
//purpose :
//=======================================================================
void BOPAlgo_MakerVolume::PerformInternal1
- (const BOPAlgo_PaveFiller& theFiller)
+ (const BOPAlgo_PaveFiller& theFiller, const Message_ProgressRange& theRange)
{
myPaveFiller = (BOPAlgo_PaveFiller*)&theFiller;
myDS = myPaveFiller->PDS();
// 3. Fill Images
// 3.1. Vertice
if (myIntersect) {
- FillImagesVertices();
+ Message_ProgressScope aPS(theRange, "PerformInternal", 100);
+ FillImagesVertices(aPS.Next(15)); // 15
if (HasErrors()) {
return;
}
// 3.2. Edges
- FillImagesEdges();
+ FillImagesEdges(aPS.Next(15)); // 30
if (HasErrors()) {
return;
}
// 3.3. Wires
- FillImagesContainers(TopAbs_WIRE);
+ FillImagesContainers(TopAbs_WIRE, aPS.Next(20)); // 50
if (HasErrors()) {
return;
}
// 3.4. Faces
- FillImagesFaces();
+ FillImagesFaces(aPS.Next(50)); // 100
if (HasErrors()) {
return;
}
}
+ else
+ {
+ Message_ProgressScope aPS(theRange, NULL, 1);
+ }
//
// 4. Collect faces
CollectFaces();
//=======================================================================
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;
//
//=======================================================================
void BOPAlgo_MakerVolume::BuildSolids(TopTools_ListOfShape& theLSR)
{
- UserBreak();
//
BOPAlgo_BuilderSolid aBS;
//
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
}
//! 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();
#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_EXPORT Standard_Boolean BOPAlgo_Options::UserBreak(const Message_ProgressScope& aPS)
{
- myProgressScope = &theScope;
-}
-
-//=======================================================================
-//function : UserBreak
-//purpose :
-//=======================================================================
-void BOPAlgo_Options::UserBreak() const
-{
- if (!myProgressScope) {
- return;
+ if (aPS.UserBreak())
+ {
+ AddError(new BOPAlgo_AlertBOPUserBreak);
+ return Standard_True;
}
- if (myProgressScope->UserBreak()) {
- throw Standard_NotImplemented("BOPAlgo_Options::UserBreak(), method is not implemented");
+ else
+ {
+ 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;
+ //! Return true if the break signal and add error to myReport
+ Standard_EXPORT Standard_Boolean UserBreak(const Message_ProgressScope& aPS);
protected:
Handle(Message_Report) myReport;
Standard_Boolean myRunParallel;
Standard_Real myFuzzyValue;
- const Message_ProgressScope* myProgressScope;
Standard_Boolean myUseOBB;
};
// function: Init
// purpose:
//=======================================================================
-void BOPAlgo_PaveFiller::Init()
+void BOPAlgo_PaveFiller::Init(const Message_ProgressRange& theRange)
{
+
if (!myArguments.Extent()) {
+ Message_ProgressScope aPS(theRange, "Init", 1);
AddError (new BOPAlgo_AlertTooFewArguments);
return;
}
//
+ Message_ProgressScope aPS(theRange, "Init", myArguments.Size());
TopTools_ListIteratorOfListOfShape aIt(myArguments);
- for (; aIt.More(); aIt.Next()) {
+ for (; aIt.More(); aIt.Next(), aPS.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
if (aIt.Value().IsNull()) {
AddError (new BOPAlgo_AlertNullInputShapes);
return;
// 4 NonDestructive flag
SetNonDestructive();
}
+
+NCollection_Array1<Standard_Real> BOPAlgo_PaveFiller::AnalyzeProgress()
+{
+ Standard_Integer aSize = 13;
+ NCollection_Array1<Standard_Real> aSteps(0, aSize - 1);
+ for (Standard_Integer i = 0; i < aSize; i++)
+ {
+ aSteps(i) = 0;
+ }
+
+ Standard_Integer aPart = 85;
+
+ myIterator->Initialize(TopAbs_VERTEX, TopAbs_VERTEX);
+ Standard_Real aPerformVVSize = myIterator->ExpectedLength();
+
+ myIterator->Initialize(TopAbs_VERTEX, TopAbs_EDGE);
+ Standard_Real aPerformVESize = myIterator->ExpectedLength();
+
+ myIterator->Initialize(TopAbs_EDGE, TopAbs_EDGE);
+ Standard_Real aPerformEESize = myIterator->ExpectedLength();
+
+ myIterator->Initialize(TopAbs_VERTEX, TopAbs_FACE);
+ Standard_Real aPerformVFSize = myIterator->ExpectedLength();
+
+ myIterator->Initialize(TopAbs_EDGE, TopAbs_FACE);
+ Standard_Real aPerformEFSize = myIterator->ExpectedLength();
+
+ myIterator->Initialize(TopAbs_FACE, TopAbs_FACE);
+ Standard_Real aPerformFFSize = myIterator->ExpectedLength();
+
+ Standard_Real aSum = 1.5*aPerformVVSize + 1.5*aPerformVESize + aPerformEESize + 1.5*aPerformVFSize + 2.5*aPerformEFSize + 30*aPerformFFSize;
+
+ if (!myNonDestructive)
+ {
+ aPart -= 5;
+ aSteps(0) = 5;
+ }
+ aSteps(7) = 5;
+ if (myIsPrimary)
+ {
+ aPart -= 5;
+ aSteps(8) = 5;
+ }
+ aSteps(10) = 5;
+ if (myGlue == BOPAlgo_GlueOff)
+ {
+ aSteps(11) = 5;
+ aPart -= 5;
+ }
+ if (!myAvoidBuildPCurve)
+ {
+ aSteps(12) = 5;
+ aPart -= 5;
+ }
+
+ if (aSum == 0)
+ {
+ Standard_Integer nbNotNull = 0;
+ for (Standard_Integer i = 0; i < aSize; i++)
+ {
+ if (aSteps(i) != 0)
+ {
+ nbNotNull++;
+ }
+ }
+ for (Standard_Integer i = 0; i < aSize; i++)
+ {
+ if (aSteps(i) != 0)
+ {
+ aSteps(i) = (95 / nbNotNull);
+ }
+ }
+ return aSteps;
+ }
+ aSteps(1) = aPart * aPerformVVSize / aSum;
+ aSteps(2) = (aPart * aPerformVESize / aSum);
+ aSteps(3) = (aPart * aPerformEESize / aSum);
+ aSteps(4) = (aPart * aPerformVFSize / aSum);
+ aSteps(5) = (aPart * 2.5*aPerformEFSize / aSum);
+ aSteps(6) = (0.5*(aSteps(1) + aSteps(2) + aSteps(4)));
+ aSteps(9) = (aPart * 30 * aPerformFFSize / aSum);
+ return aSteps;
+}
+
//=======================================================================
// 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&) {
// function: PerformInternal
// purpose:
//=======================================================================
-void BOPAlgo_PaveFiller::PerformInternal()
+void BOPAlgo_PaveFiller::PerformInternal(const Message_ProgressRange& theRange)
{
- Init();
+ Message_ProgressScope aPS(theRange, "Pave filler perform", 100);
+
+ Init(aPS.Next(5)); // 1 - const = 2
if (HasErrors()) {
return;
}
+ NCollection_Array1<Standard_Real> aSteps = AnalyzeProgress();
+ Standard_Real a = 0;
+ for (int i = 0; i < aSteps.Size(); i++)
+ {
+ a += aSteps[i];
+ }
//
- Prepare();
+ Prepare(aPS.Next(aSteps[0])); // 2 - const = 3
if (HasErrors()) {
return;
}
// 00
- PerformVV();
+ PerformVV(aPS.Next(aSteps[1])); // 3 - myIterator->Initialize(TopAbs_VERTEX, TopAbs_VERTEX);
if (HasErrors()) {
return;
}
// 01
- PerformVE();
+ PerformVE(aPS.Next(aSteps[2])); // 4 - myIterator->Initialize(TopAbs_VERTEX, TopAbs_EDGE);
if (HasErrors()) {
return;
}
//
UpdatePaveBlocksWithSDVertices();
// 11
- PerformEE();
+ PerformEE(aPS.Next(aSteps[3])); // 5 - myIterator->Initialize(TopAbs_EDGE, TopAbs_EDGE);
if (HasErrors()) {
return;
}
UpdatePaveBlocksWithSDVertices();
// 02
- PerformVF();
+ PerformVF(aPS.Next(aSteps[4])); // 6 - vertex-face
if (HasErrors()) {
return;
}
UpdatePaveBlocksWithSDVertices();
// 12
- PerformEF();
+ PerformEF(aPS.Next(aSteps[5])); // 7 - edge-face
if (HasErrors()) {
return;
}
+
UpdatePaveBlocksWithSDVertices();
UpdateInterfsWithSDVertices();
// Repeat Intersection with increased vertices
- RepeatIntersection();
+ RepeatIntersection(aPS.Next(aSteps[6])); // 8 - vf+ve+vv
if (HasErrors())
return;
-
// Force intersection of edges after increase
// of the tolerance values of their vertices
- ForceInterfEE();
+ ForceInterfEE(aPS.Next(aSteps[7])); // 9 - EE const = 2
+ if (HasErrors())
+ {
+ return;
+ }
// Force Edge/Face intersection after increase
// of the tolerance values of their vertices
- ForceInterfEF();
+ ForceInterfEF(aPS.Next(aSteps[8])); // 10 - EF const = 3
+ if (HasErrors())
+ {
+ return;
+ }
//
// 22
- PerformFF();
+ PerformFF(aPS.Next(aSteps[9])); // 11 - FF
if (HasErrors()) {
return;
}
//
myDS->RefineFaceInfoIn();
//
- MakeSplitEdges();
+ MakeSplitEdges(aPS.Next(aSteps[10])); // 12 - const = 2
if (HasErrors()) {
return;
}
//
UpdatePaveBlocksWithSDVertices();
//
- MakeBlocks();
+ MakeBlocks(aPS.Next(aSteps[11])); // 13 - const = 2
if (HasErrors()) {
return;
}
//
RemoveMicroEdges();
//
- MakePCurves();
+ MakePCurves(aPS.Next(aSteps[12])); // 14 - const = 2
if (HasErrors()) {
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)
{
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const BOPDS_ShapeInfo& aSI = myDS->ShapeInfo(i);
if (aSI.ShapeType() != TopAbs_VERTEX)
continue;
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;
//! 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 NCollection_Array1<Standard_Real> AnalyzeProgress() Standard_OVERRIDE;
+
+ 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);
//! 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,
//! 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
// 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;
NCollection_List<TColStd_ListOfInteger> aMBlocks(aAllocator);
//
// 1. Map V/LV
+ Message_ProgressScope aPS(theRange, "PerformVV", 1);
for (; myIterator->More(); myIterator->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);
}
const Handle(BOPDS_PaveBlock)& PaveBlock() const {
return myPB;
}
+ void SetRange(const Message_ProgressRange& theRange)
+ {
+ myRange = theRange;
+ }
//
- virtual void Perform() {
- BOPAlgo_Algo::UserBreak();
+ virtual void Perform(const Message_ProgressRange& /*theRange*/ = Message_ProgressRange()) {
+ Message_ProgressScope aPS(myRange, NULL, 1);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
try
{
OCC_CATCH_SIGNALS
TopoDS_Edge myE;
Handle(IntTools_Context) myContext;
Handle(BOPDS_PaveBlock) myPB;
+private:
+ Message_ProgressRange myRange;
};
//=======================================================================
typedef NCollection_Vector<BOPAlgo_VertexEdge> BOPAlgo_VectorOfVertexEdge;
// function: PerformVE
// purpose:
//=======================================================================
-void BOPAlgo_PaveFiller::PerformVE()
+void BOPAlgo_PaveFiller::PerformVE(const Message_ProgressRange& theRange)
{
FillShrunkData(TopAbs_VERTEX, TopAbs_EDGE);
//
return;
}
//
+ Message_ProgressScope aPS(theRange, NULL, 1);
// 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, "IntersectVE", 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), "Intersect vertex-edge", aNbVE);
+ for (i = 0; i < aVVE.Length(); i++)
+ {
+ BOPAlgo_VertexEdge& aVESolver = aVVE.ChangeValue(i);
+ aVESolver.SetRange(aPS.Next());
+ }
// Perform intersection
//=============================================================
BOPTools_Parallel::Perform (myRunParallel, aVVE, myContext);
//=============================================================
+ if (HasErrors())
+ {
+ return;
+ }
//
// Keep the modified edges for further update
TColStd_MapOfInteger aMEdges;
//
// Analyze intersections
- aNbVE = aVVE.Length();
- for (i = 0; i < aNbVE; ++i) {
+ Message_ProgressScope aPS2(aPSOuter.Next(1), "Analyze intersections", aNbVE);
+ for (i = 0; i < aNbVE; ++i, aPS2.Next()) {
+ if (UserBreak(aPS2))
+ {
+ return;
+ }
const BOPAlgo_VertexEdge& aVESolver = aVVE(i);
if (aVESolver.Flag() != 0) {
if (aVESolver.HasErrors())
BOPDS_ListOfPaveBlock::Iterator itPB (aLPB);
for (; itPB.More(); itPB.Next())
{
+ if (UserBreak(aPS2))
+ {
+ return;
+ }
aPB = itPB.Value();
Standard_Real aT1, aT2;
aPB->Range (aT1, aT2);
const TColStd_ListOfInteger& aLI = aDMVSD.Find(aPair);
TColStd_ListIteratorOfListOfInteger aItLI(aLI);
for (; aItLI.More(); aItLI.Next()) {
+ if (UserBreak(aPS2))
+ {
+ return;
+ }
const Standard_Integer nVOld = aItLI.Value();
// 3. Create interference V/E
BOPDS_InterfVE& aVE = aVEs.Appended();
IntTools_EdgeEdge::SetFuzzyValue(theFuzz);
}
//
- virtual void Perform() {
- BOPAlgo_Algo::UserBreak();
+ void SetRange(const Message_ProgressRange& theRange)
+ {
+ myRange = theRange;
+ }
+ //
+ virtual void Perform(const Message_ProgressRange& /*theRange*/ = Message_ProgressRange()) {
+ Message_ProgressScope aPS(myRange, NULL, 1);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
TopoDS_Edge anE1 = myEdge1, anE2 = myEdge2;
Standard_Boolean hasTrsf = false;
try
Handle(BOPDS_PaveBlock) myPB2;
Bnd_Box myBox1;
Bnd_Box myBox2;
+private:
+ Message_ProgressRange myRange;
};
//
//=======================================================================
// function: PerformEE
// purpose:
//=======================================================================
-void BOPAlgo_PaveFiller::PerformEE()
+void BOPAlgo_PaveFiller::PerformEE(const Message_ProgressRange& theRange)
{
FillShrunkData(TopAbs_EDGE, TopAbs_EDGE);
//
BOPDS_VectorOfInterfEE& aEEs=myDS->InterfEE();
aEEs.SetIncrement(iSize);
//
+ Message_ProgressScope aPSOuter(theRange, "PerformEE", 10);
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();
//
aIt2.Initialize(aLPB2);
for (; aIt2.More(); aIt2.Next()) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
Bnd_Box aBB2;
//
Handle(BOPDS_PaveBlock)& aPB2=aIt2.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 aPS1(aPSOuter.Next(8), "Edge-edge perform", aNbEdgeEdge);
+ for (k = 0; k < aNbEdgeEdge; k++)
+ {
+ BOPAlgo_EdgeEdge& anEdgeEdge = aVEdgeEdge.ChangeValue(k);
+ anEdgeEdge.SetRange(aPS1.Next());
+ }
//======================================================
BOPTools_Parallel::Perform (myRunParallel, aVEdgeEdge);
//======================================================
+ if (HasErrors())
+ {
+ return;
+ }
//
- for (k = 0; k < aNbEdgeEdge; ++k) {
+ Message_ProgressScope aPS2(aPSOuter.Next(1), "Post-treatment", aNbEdgeEdge);
+ for (k = 0; k < aNbEdgeEdge; ++k, aPS2.Next()) {
+ if (UserBreak(aPS2))
+ {
+ return;
+ }
Bnd_Box aBB1, aBB2;
//
BOPAlgo_EdgeEdge& anEdgeEdge=aVEdgeEdge(k);
}
//
for (i=1; i<=aNbCPrts; ++i) {
+ if (UserBreak(aPS2))
+ {
+ 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(1));
+ 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, 1);
Standard_Integer i, aNb = aImages.Extent();
for (i = 1; i <= aNb; ++i) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const TopoDS_Vertex& aV = TopoDS::Vertex(aImages.FindKey(i));
const TopTools_ListOfShape& aLVSD = aImages.FindFromIndex(i);
//
//
TopTools_ListIteratorOfListOfShape aItLS(aLVSD);
for (; aItLS.More(); aItLS.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const TopoDS_Shape& aVx = aItLS.Value();
BOPDS_CoupleOfPaveBlocks &aCPB = theMVCPB.ChangeFromKey(aVx);
aCPB.SetIndex(iV);
// 3. Map PaveBlock/ListOfVertices to add to this PaveBlock ->aMPBLI
BOPDS_IndexedDataMapOfPaveBlockListOfInteger aMPBLI(100, theAllocator);
for (i = 1; i <= aNbV; ++i) {
+ 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, "ForceInterfEE", 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 (UserBreak(aPSOuter))
+ {
+ return;
+ }
const BOPDS_ShapeInfo& aSI = myDS->ShapeInfo(i);
if (aSI.ShapeType() == TopAbs_VERTEX)
{
myDS->InitPaveBlocksForVertex(i);
}
}
-
// Fill the connection map from bounding vertices to pave blocks
// having those bounding vertices
NCollection_IndexedDataMap<BOPDS_Pair,
for (Standard_Integer i = 0; i < aNbS; ++i)
{
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const BOPDS_ShapeInfo& aSI = myDS->ShapeInfo(i);
if (aSI.ShapeType() != TopAbs_EDGE)
// Not an edge
BOPDS_ListIteratorOfListOfPaveBlock aItLPB(aLPB);
for (; aItLPB.More(); aItLPB.Next())
{
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const Handle(BOPDS_PaveBlock)& aPB = aItLPB.Value();
const Handle(BOPDS_PaveBlock)& aPBR = myDS->RealPaveBlock(aPB);
if (!aMPBFence.Add(aPBR))
for (Standard_Integer i = 1; i <= aNbPB; ++i)
{
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const BOPDS_ListOfPaveBlock& aLPB = aPBMap(i);
if (aLPB.Extent() < 2)
continue;
BOPDS_ListIteratorOfListOfPaveBlock aItLPB1(aLPB);
for (; aItLPB1.More(); aItLPB1.Next())
{
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const Handle(BOPDS_PaveBlock)& aPB1 = aItLPB1.Value();
const Handle(BOPDS_CommonBlock)& aCB1 = myDS->CommonBlock(aPB1);
const Standard_Integer nE1 = aPB1->OriginalEdge();
BOPDS_ListIteratorOfListOfPaveBlock aItLPB2 = aItLPB1;
for (aItLPB2.Next(); aItLPB2.More(); aItLPB2.Next())
{
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const Handle(BOPDS_PaveBlock)& aPB2 = aItLPB2.Value();
const Handle(BOPDS_CommonBlock)& aCB2 = myDS->CommonBlock(aPB2);
const Standard_Integer nE2 = aPB2->OriginalEdge();
{
anEdgeEdge.SetFuzzyValue(myFuzzyValue);
}
- if (myProgressScope != NULL)
- {
- anEdgeEdge.SetProgressIndicator(*myProgressScope);
- }
}
}
}
aMPBFence.Clear();
anAlloc->Reset();
+ Message_ProgressScope aPS(aPSOuter.Next(9), "Intersection edge-edge", aNbPairs);
+ for (Standard_Integer i = 0; i < aNbPairs; i++)
+ {
+ BOPAlgo_EdgeEdge& anEdgeEdge = aVEdgeEdge.ChangeValue(i);
+ anEdgeEdge.SetRange(aPS.Next());
+ }
+
// Perform intersection of the found pairs
BOPTools_Parallel::Perform (myRunParallel, aVEdgeEdge);
-
+ if (HasErrors())
+ {
+ 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)
+ Message_ProgressScope aPS1(aPSOuter.Next(1), "Analyze the results of intersection", aNbPairs);
+ for (Standard_Integer i = 0; i < aNbPairs; ++i, aPS1.Next())
{
+ if (UserBreak(aPS1))
+ {
+ return;
+ }
BOPAlgo_EdgeEdge& anEdgeEdge = aVEdgeEdge(i);
if (!anEdgeEdge.IsDone() || anEdgeEdge.HasErrors())
{
return myContext;
}
//
- virtual void Perform() {
- BOPAlgo_Algo::UserBreak();
+ void SetRange(const Message_ProgressRange& theRange)
+ {
+ myRange = theRange;
+ }
+ //
+ virtual void Perform(const Message_ProgressRange& /*theRange*/ = Message_ProgressRange()) {
+ Message_ProgressScope aPS(myRange, NULL, 1);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
try
{
OCC_CATCH_SIGNALS
TopoDS_Vertex myV;
TopoDS_Face myF;
Handle(IntTools_Context) myContext;
+private:
+ Message_ProgressRange myRange;
};
//=======================================================================
typedef NCollection_Vector<BOPAlgo_VertexFace> BOPAlgo_VectorOfVertexFace;
// 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();
// 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;
-
+ Message_ProgressScope aPSOuter(theRange, "PerformVF", 10);
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), "Vertex-face perform", aNbVF);
+ for (k = 0; k < aNbVF; k++)
+ {
+ BOPAlgo_VertexFace& aVertexFace = aVVF.ChangeValue(k);
+ aVertexFace.SetRange(aPS.Next());
+ }
//================================================================
BOPTools_Parallel::Perform (myRunParallel, aVVF, myContext);
//================================================================
+ if (HasErrors())
+ {
+ return;
+ }
//
- for (k=0; k < aNbVF; ++k) {
+ Message_ProgressScope aPS2(aPSOuter.Next(1), "Post treatment", aNbVF);
+ for (k=0; k < aNbVF; ++k, aPS2.Next()) {
+ if (UserBreak(aPS2))
+ {
+ return;
+ }
const BOPAlgo_VertexFace& aVertexFace=aVVF(k);
//
iFlag=aVertexFace.Flag();
TColStd_MapIteratorOfMapOfInteger itMV(aMV);
for (; itMV.More(); itMV.Next())
{
+ if (UserBreak(aPS2))
+ {
+ return;
+ }
nV = itMV.Value();
// 1
BOPDS_InterfVF& aVF = aVFs.Appended();
myBox2 = theBox2;
}
//
- virtual void Perform() {
- BOPAlgo_Algo::UserBreak();
+ void SetProgress (const Message_ProgressRange& theRange)
+ {
+ myRange = theRange;
+ }
+ //
+ virtual void Perform(const Message_ProgressRange& /*theRange*/ = Message_ProgressRange()) {
+ Message_ProgressScope aPS(myRange, NULL, 1);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
TopoDS_Face aFace = myFace;
TopoDS_Edge anEdge = myEdge;
Standard_Boolean hasTrsf = false;
Handle(BOPDS_PaveBlock) myPB;
Bnd_Box myBox1;
Bnd_Box myBox2;
+
+private:
+ Message_ProgressRange myRange;
};
//
//=======================================================================
//function : PerformEF
//purpose :
//=======================================================================
-void BOPAlgo_PaveFiller::PerformEF()
+void BOPAlgo_PaveFiller::PerformEF(const Message_ProgressRange& theRange)
{
FillShrunkData(TopAbs_EDGE, TopAbs_FACE);
//
if (!iSize) {
return;
}
+ Message_ProgressScope aPSOuter(theRange, "PerformEF", 10);
//
Standard_Integer nE, nF;
//
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 aPS1(aPSOuter.Next(8), "Edge-face perform", aNbEdgeFace);
+ for (Standard_Integer index = 0; index < aNbEdgeFace; index++)
+ {
+ BOPAlgo_EdgeFace& aEdgeFace = aVEdgeFace.ChangeValue(index);
+ aEdgeFace.SetProgress(aPS1.Next());
+ }
//=================================================================
BOPTools_Parallel::Perform (myRunParallel, aVEdgeFace, myContext);
//=================================================================
+ if (HasErrors())
+ {
+ return;
+ }
//
- for (k=0; k < aNbEdgeFace; ++k) {
+ Message_ProgressScope aPS2(aPSOuter.Next(1), "Post-treatment", aNbEdgeFace);
+ for (k=0; k < aNbEdgeFace; ++k, aPS2.Next()) {
+ if (UserBreak(aPS2))
+ {
+ 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(aPS2))
+ {
+ 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)
{
if (!myIsPrimary)
return;
// Collect all pave blocks
BOPDS_IndexedMapOfPaveBlock aMPB;
const Standard_Integer aNbS = myDS->NbSourceShapes();
+ Message_ProgressScope aPS(theRange, NULL, 1);
for (Standard_Integer nE = 0; nE < aNbS; ++nE)
{
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const BOPDS_ShapeInfo& aSI = myDS->ShapeInfo(nE);
if (aSI.ShapeType() != TopAbs_EDGE)
// Not an edge
BOPDS_ListIteratorOfListOfPaveBlock aItLPB(aLPB);
for (; aItLPB.More(); aItLPB.Next())
{
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const Handle(BOPDS_PaveBlock)& aPB = aItLPB.Value();
const Handle(BOPDS_PaveBlock)& aPBR = myDS->RealPaveBlock(aPB);
aMPB.Add(aPBR);
}
// 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)
{
if (theMPB.IsEmpty())
return;
-
+ Message_ProgressScope aPSOuter(theRange, "ForceInterfEF", 10);
// Fill the tree with bounding boxes of the pave blocks
BOPTools_BoxTree aBBTree;
Standard_Integer aNbPB = theMPB.Extent();
for (Standard_Integer iPB = 1; iPB <= aNbPB; ++iPB)
{
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
Handle(BOPDS_PaveBlock) aPB = theMPB(iPB);
if (!aPB->HasShrunkData() || !myDS->IsValidShrunkData(aPB))
{
const Standard_Integer aNbS = myDS->NbSourceShapes();
for (Standard_Integer nF = 0; nF < aNbS; ++nF)
{
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const BOPDS_ShapeInfo& aSI = myDS->ShapeInfo(nF);
if (aSI.ShapeType() != TopAbs_FACE)
// Not a face
const Standard_Integer aNb = pMPBF[iM]->Extent();
for (Standard_Integer iPB = 1; iPB <= aNb; ++iPB)
{
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const Handle(BOPDS_PaveBlock)& aPB = pMPBF[iM]->FindKey(iPB);
aMVF.Add(aPB->Pave1().Index());
aMVF.Add(aPB->Pave2().Index());
TColStd_ListOfInteger::Iterator itLIPB(aLIPB);
for (; itLIPB.More(); itLIPB.Next())
{
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
const Handle(BOPDS_PaveBlock)& aPB = aPBMap(itLIPB.Value());
if (pMPBF[0]->Contains(aPB) ||
pMPBF[1]->Contains(aPB) ||
aEdgeFace.SetFuzzyValue(myFuzzyValue + aTolAdd);
aEdgeFace.UseQuickCoincidenceCheck(Standard_True);
aEdgeFace.SetRange(IntTools_Range(aPB->Pave1().Parameter(), aPB->Pave2().Parameter()));
- if (myProgressScope != NULL)
- {
- aEdgeFace.SetProgressIndicator(*myProgressScope);
- }
}
}
}
aPBMap.Clear();
anAlloc->Reset();
+ Message_ProgressScope aPS(aPSOuter.Next(9), "Force intersection edge-face", aNbEFs);
+ for (Standard_Integer i = 0; i < aNbEFs; i++)
+ {
+ BOPAlgo_EdgeFace& aEdgeFace = aVEdgeFace.ChangeValue(i);
+ aEdgeFace.SetProgress(aPS.Next());
+ }
// Perform intersection of the found pairs
BOPTools_Parallel::Perform (myRunParallel, aVEdgeFace, myContext);
+ if (HasErrors())
+ {
+ 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)
+ Message_ProgressScope aPS1(aPSOuter.Next(1), "Analyze the results of force intersection", aNbEFs);
+ for (Standard_Integer i = 0; i < aNbEFs; ++i, aPS1.Next())
{
+ if (UserBreak(aPS1))
+ {
+ return;
+ }
BOPAlgo_EdgeFace& anEdgeFace = aVEdgeFace(i);
if (!anEdgeFace.IsDone() || anEdgeFace.HasErrors())
{
IntTools_FaceFace::SetFuzzyValue(theFuzz);
}
//
+ void SetProgress(const Message_ProgressRange& theRange)
+ {
+ myRange = theRange;
+ }
+ //
const gp_Trsf& Trsf() const { return myTrsf; }
//
- virtual void Perform() {
- BOPAlgo_Algo::UserBreak();
+ virtual void Perform(const Message_ProgressRange& /*theRange*/ = Message_ProgressRange()) {
+ Message_ProgressScope aPS(myRange, NULL, 1);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
try
{
OCC_CATCH_SIGNALS
myTrsf = aTrsf.Inverted();
}
- IntTools_FaceFace::Perform (aF1, aF2);
+ IntTools_FaceFace::Perform (aF1, aF2, aPS.Next());
}
catch (Standard_Failure const&)
{
Bnd_Box myBox1;
Bnd_Box myBox2;
gp_Trsf myTrsf;
+
+ private:
+ Message_ProgressRange myRange;
};
//
//=======================================================================
//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();
BOPAlgo_VectorOfFaceFace aVFaceFace;
Standard_Integer nF1, nF2;
//
+ Message_ProgressScope aPSOuter(theRange, "PerformFF", 10);
for (; myIterator->More(); myIterator->Next()) {
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
myIterator->Value(nF1, nF2);
aMIFence.Add (nF1);
// 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 aPS1(aPSOuter.Next(9), "Face-face perform", aNbFaceFace);
+ for (k = 0; k < aVFaceFace.Size(); k++)
+ {
+ BOPAlgo_FaceFace& aFaceFace = aVFaceFace.ChangeValue(k);
+ aFaceFace.SetProgress(aPS1.Next());
+ }
//======================================================
// Perform intersection
BOPTools_Parallel::Perform (myRunParallel, aVFaceFace);
+ if (HasErrors())
+ {
+ return;
+ }
//======================================================
// Treatment of the results
- Standard_Integer k, aNbFaceFace = aVFaceFace.Length();
- for (k = 0; k < aNbFaceFace; ++k) {
+
+ Message_ProgressScope aPS2(aPSOuter.Next(1), "Treatment of the results", aNbFaceFace);
+ for (k = 0; k < aNbFaceFace; ++k, aPS2.Next()) {
+ if (UserBreak(aPS2))
+ {
+ 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(aPS2))
+ {
+ return;
+ }
Bnd_Box aBox;
const IntTools_Curve& aIC = aCvsX(i);
Standard_Boolean bIsValid = IntTools_Tools::CheckCurve(aIC, aBox);
// Points
BOPDS_VectorOfPoint& aVNP = aFF.ChangePoints();
for (Standard_Integer i = 1; i <= aNbPoints; ++i) {
+ if (UserBreak(aPS2))
+ {
+ return;
+ }
const IntTools_PntOn2Faces& aPi = aPntsX(i);
const gp_Pnt& aP = aPi.P1().Pnt();
//
//function : MakeBlocks
//purpose :
//=======================================================================
-void BOPAlgo_PaveFiller::MakeBlocks()
+void BOPAlgo_PaveFiller::MakeBlocks(const Message_ProgressRange& theRange)
{
if (myGlue != BOPAlgo_GlueOff) {
return;
// Map of PaveBlocks with the faces to which it has to be added
BOPAlgo_DataMapOfPaveBlockListOfInteger aPBFacesMap;
//
+ Message_ProgressScope aPS(theRange, NULL, 1);
for (i=0; i<aNbFF; ++i) {
- //
- UserBreak();
+ if (UserBreak(aPS))
+ {
+ return;
+ }
//
BOPDS_InterfFF& aFF=aFFs(i);
aFF.Indices(nF1, nF2);
//
// 1. Treat Points
for (j=0; j<aNbP; ++j) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
TopoDS_Vertex aV;
BOPDS_CoupleOfPaveBlocks aCPB;
//
GetStickVertices(nF1, nF2, aMVStick, aMVEF, aMI);
//
for (j = 0; j < aNbC; ++j) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
BOPDS_Curve& aNC = aVC.ChangeValue(j);
// DEBt
aNC.InitPaveBlock1();
FilterPavesOnCurves(aVC, aMVTol);
for (j = 0; j<aNbC; ++j) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
BOPDS_Curve& aNC=aVC.ChangeValue(j);
const IntTools_Curve& aIC=aNC.Curve();
//
//
// 3. Make section edges
for (j=0; j<aNbC; ++j) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
BOPDS_Curve& aNC=aVC.ChangeValue(j);
const IntTools_Curve& aIC=aNC.Curve();
Standard_Real aTolR3D = Max(aNC.Tolerance(), aNC.TangentialTolerance());
//
aItLPB.Initialize(aLPB);
for (; aItLPB.More(); aItLPB.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
Handle(BOPDS_PaveBlock)& aPB=aItLPB.ChangeValue();
aPB->Indices(nV1, nV2);
aPB->Range (aT1, aT2);
//and forget about SD groups of such vertices
aItMV.Initialize(aMVTol);
for (; aItMV.More(); aItMV.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
nV1 = aItMV.Key();
Standard_Real aTol = aItMV.Value();
//
//
// 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(aPS.Next());
//
//-----------------------------------------------------scope t
aMVStick.Clear();
}
//
// 2 Fuse shapes
- if (myProgressScope != NULL)
- {
- aPF.SetProgressIndicator(*myProgressScope);
- }
aPF.SetRunParallel(myRunParallel);
aPF.SetArguments(aLS);
aPF.Perform();
//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)
{
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const BOPDS_VectorOfCurve& aVNC = aFFs(i).Curves();
const Standard_Integer aNbC = aVNC.Length();
for (Standard_Integer j = 0; j < aNbC; ++j)
{
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const BOPDS_ListOfPaveBlock& aLPBC = aVNC(j).PaveBlocks();
BOPDS_ListIteratorOfListOfPaveBlock aItPB(aLPBC);
for (; aItPB.More(); aItPB.Next())
}
}
// Perform intersection of collected pave blocks
- ForceInterfEF(aMPBScAll, Standard_False);
+ ForceInterfEF(aMPBScAll, aPS.Next(), Standard_False);
}
//=======================================================================
myContext = aContext;
}
//
- virtual void Perform () {
- BOPAlgo_Algo::UserBreak();
+ void SetRange(const Message_ProgressRange& theRange)
+ {
+ myRange = theRange;
+ }
+ //
+ virtual void Perform (const Message_ProgressRange& /*theRange*/ = Message_ProgressRange()) {
+ Message_ProgressScope aPS(myRange, NULL, 1);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
myTol = BOPAlgo_Tools::ComputeToleranceOfCB(myCB, myDS, myContext);
BOPTools_AlgoTools::MakeSplitEdge(myE,
myV1, myT1,
//
BOPDS_PDS myDS;
Handle(IntTools_Context) myContext;
+private:
+ Message_ProgressRange myRange;
};
//
//=======================================================================
return myContext;
}
//
- virtual void Perform() {
+ void SetRange(const Message_ProgressRange& theRange)
+ {
+ myRange = theRange;
+ }
+ //
+ virtual void Perform(const Message_ProgressRange& /*theRange*/ = Message_ProgressRange()) {
+ Message_ProgressScope aPS(myRange, NULL, 1);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
try
{
OCC_CATCH_SIGNALS
Standard_Real myNewTol;
//
Handle(IntTools_Context) myContext;
+ private:
+ Message_ProgressRange myRange;
};
//
//=======================================================================
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();
//
aNbPBP=aPBP.Length();
//
+ Message_ProgressScope aPSOuter(theRange, NULL, 1);
for (i = 0; i < aNbPBP; ++i)
{
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
BOPDS_ListOfPaveBlock& aLPB = aPBP(i);
//
aItPB.Initialize(aLPB);
BOPDS_ListIteratorOfListOfPaveBlock it(aCB->PaveBlocks());
for (; it.More(); it.Next())
{
+ if (UserBreak(aPSOuter))
+ {
+ return;
+ }
nE = it.Value()->OriginalEdge();
if (myDS->PaveBlocks(nE).Extent() == 1)
break;
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(), "MakeSplitEdges", aNbVBSE);
+ for (k = 0; k < aNbVBSE; k++)
+ {
+ BOPAlgo_SplitEdge& aBSE = aVBSE.ChangeValue(k);
+ aBSE.SetRange(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)
{
if (myAvoidBuildPCurve ||
(!mySectionAttribute.PCurveOnS1() && !mySectionAttribute.PCurveOnS2()))
//
// 1. Process Common Blocks
const BOPDS_VectorOfFaceInfo& aFIP=myDS->FaceInfoPool();
+ Message_ProgressScope aPS(theRange, "MakePCurves", aVMPC.Length());
//
aNbFI=aFIP.Length();
for (i=0; i<aNbFI; ++i) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const BOPDS_FaceInfo& aFI=aFIP(i);
nF1=aFI.Index();
//
const BOPDS_IndexedMapOfPaveBlock& aMPBIn=aFI.PaveBlocksIn();
aNbPBIn = aMPBIn.Extent();
for (j = 1; j <= aNbPBIn; ++j) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const Handle(BOPDS_PaveBlock)& aPB = aMPBIn(j);
nE=aPB->Edge();
const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&myDS->Shape(nE)));
BOPAlgo_MPC& aMPC=aVMPC.Appended();
aMPC.SetEdge(aE);
aMPC.SetFace(aF1F);
- if (myProgressScope != NULL)
- {
- aMPC.SetProgressIndicator(*myProgressScope);
- }
}
//
// On
const BOPDS_IndexedMapOfPaveBlock& aMPBOn=aFI.PaveBlocksOn();
aNbPBOn = aMPBOn.Extent();
for (j = 1; j <= aNbPBOn; ++j) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const Handle(BOPDS_PaveBlock)& aPB = aMPBOn(j);
nE=aPB->Edge();
const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&myDS->Shape(nE)));
aMPC.SetEdge(aE);
aMPC.SetFace(aF1F);
- if (myProgressScope != NULL)
- {
- aMPC.SetProgressIndicator(*myProgressScope);
- }
}
}// for (i=0; i<aNbFI; ++i) {
//
BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
aNbFF=aFFs.Length();
for (i=0; i<aNbFF; ++i) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const BOPDS_InterfFF& aFF=aFFs(i);
const BOPDS_VectorOfCurve& aVNC = aFF.Curves();
aNbC = aVNC.Length();
//
for (k=0; k<aNbC; ++k)
{
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const BOPDS_Curve& aNC=aVNC(k);
const BOPDS_ListOfPaveBlock& aLPB=aNC.PaveBlocks();
aItLPB.Initialize(aLPB);
for(; aItLPB.More(); aItLPB.Next())
{
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const Handle(BOPDS_PaveBlock)& aPB=aItLPB.Value();
nE=aPB->Edge();
const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&myDS->Shape(nE)));
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 ) {
//
+ for (i = 0; i < aVMPC.Length(); i++)
+ {
+ BOPAlgo_MPC& aMPC = aVMPC.ChangeValue(i);
+ aMPC.SetRange(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(aPS))
+ {
+ 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
}
}
//
+ Message_ProgressScope aPS(theRange, "Prepare", 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(aPS))
+ {
+ return;
+ }
const BOPAlgo_BPC& aBPC=aVBPC(i);
if (aBPC.IsToUpdate()) {
Standard_Real aTolE = BRep_Tool::Tolerance(aBPC.GetEdge());
// 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
//purpose :
//=======================================================================
void BOPAlgo_Section::PerformInternal1
- (const BOPAlgo_PaveFiller& theFiller)
+ (const BOPAlgo_PaveFiller& theFiller, const Message_ProgressRange& theRange)
{
myPaveFiller=(BOPAlgo_PaveFiller*)&theFiller;
myDS=myPaveFiller->PDS();
return;
}
//
+ Message_ProgressScope aPS(theRange, "PerformInternal", 100);
// 3. Fill Images
// 3.1 Vertices
- FillImagesVertices();
+ FillImagesVertices(aPS.Next(30)); // 30
if (HasErrors()) {
return;
}
return;
}
// 3.2 Edges
- FillImagesEdges();
+ FillImagesEdges(aPS.Next(35)); // 65
if (HasErrors()) {
return;
}
return;
}
// 4. Section
- BuildSection();
+ BuildSection(aPS.Next(35)); // 100
//
if (HasErrors()) {
return;
//function : BuildSection
//purpose :
//=======================================================================
-void BOPAlgo_Section::BuildSection()
+void BOPAlgo_Section::BuildSection(const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPS(theRange, "BuildSection", 1);
Standard_Integer i, aNbMS, aNbLE;
Standard_Integer j, nE, nV, aNb, aNbF, aNbPBSc;
TopoDS_Shape aRC, aRC1;
// 1. aRC1
aNb=myDS->NbSourceShapes();
for (i=0; i<aNb; ++i) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const BOPDS_ShapeInfo& aSI=myDS->ShapeInfo(i);
if (aSI.ShapeType()!=TopAbs_FACE) {
continue;
const TColStd_MapOfInteger& aMVSc=aFI.VerticesSc();
aItMI.Initialize(aMVSc);
for(; aItMI.More(); aItMI.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
nV=aItMI.Key();
const TopoDS_Shape& aV=myDS->Shape(nV);
aBB.Add(aRC1, aV);
const TColStd_MapOfInteger& aMI=aFI.VerticesIn();
aItMI.Initialize(aMI);
for(; aItMI.More(); aItMI.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
nV=aItMI.Key();
if (nV<0) {
continue;
//
aNbPBSc=aMPBSc.Extent();
for (j=1; j<=aNbPBSc; ++j) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const Handle(BOPDS_PaveBlock)& aPB=aMPBSc(j);
nE=aPB->Edge();
const TopoDS_Shape& aE=myDS->Shape(nE);
//
aNb=aPBP.Size();
for (i=0; i<aNb; ++i) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const BOPDS_ListOfPaveBlock& aLPB=aPBP(i);
aItPB.Initialize(aLPB);
for (; aItPB.More(); aItPB.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const Handle(BOPDS_PaveBlock)& aPB=aItPB.Value();
Handle(BOPDS_CommonBlock) aCB=myDS->CommonBlock(aPB);
if (!aCB.IsNull()) {
// 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();
const TopTools_ListOfShape& aLSIm=myImages.Find(aS);
aItIm.Initialize(aLSIm);
for (; aItIm.More(); aItIm.Next()) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const TopoDS_Shape& aSIm=aItIm.Value();
TopExp::MapShapes(aSIm, TopAbs_VERTEX, aMS);
TopExp::MapShapes(aSIm, TopAbs_EDGE , aMS);
//
aNbMS=aMS.Extent();
for (i=1; i<=aNbMS; ++i) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const TopoDS_Shape& aS=aMS(i);
if (aMSI.Contains(aS)) {
Standard_Integer& iCnt=aMSI.ChangeFromKey(aS);
//
aNbMS=aMSI.Extent();
for (i=1; i<=aNbMS; ++i) {
+ if (UserBreak(aPS))
+ {
+ return;
+ }
const TopoDS_Shape& aV=aMSI.FindKey(i);
const Standard_Integer& iCnt=aMSI.FindFromIndex(i);
if (iCnt>1) {
//
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:
//function : Perform
//purpose :
//=======================================================================
-void BOPAlgo_ShellSplitter::Perform()
+void BOPAlgo_ShellSplitter::Perform(const Message_ProgressRange& /*theRange*/)
{
GetReport()->Clear();
//
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;
//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, "BOPAlgo_Splitter", 10);
+ pPF->Perform(aPS.Next(9));
+ if (HasErrors())
+ {
+ return;
+ }
//
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:
}
//! Performs the classification
- virtual void Perform();
+ virtual void Perform(const Message_ProgressRange& theRange = Message_ProgressRange());
//! Returns the faces classified as IN for solid
const TopTools_ListOfShape& InFaces() const
//function : BOPAlgo_FillIn3DParts::Perform
//purpose :
//=======================================================================
-void BOPAlgo_FillIn3DParts::Perform()
+void BOPAlgo_FillIn3DParts::Perform(const Message_ProgressRange& theRange)
{
- BOPAlgo_Algo::UserBreak();
+ Message_ProgressScope aPS(theRange, NULL, 1);
+ if (UserBreak(aPS))
+ {
+ return;
+ }
myInFaces.Clear();
//function : Perform
//purpose :
//=======================================================================
-void BOPAlgo_WireSplitter::Perform()
+void BOPAlgo_WireSplitter::Perform(const Message_ProgressRange& /*theRange*/)
{
GetReport()->Clear();
//
//! 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);
#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());
aPF.SetGlue(aGlue);
aPF.SetUseOBB(BOPTest_Objects::UseOBB());
//
- aPF.Perform();
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
+ Message_ProgressScope aPS(aProgress->Start(), "BOP", 10);
+ aPF.Perform(aPS.Next(9));
BOPTest::ReportAlerts(aPF.GetReport());
if (aPF.HasErrors()) {
return 0;
aBOP.SetCheckInverted(BOPTest_Objects::CheckInverted());
aBOP.SetToFillHistory(BRepTest_Objects::IsHistoryNeeded());
//
- aBOP.PerformWithFiller(aPF);
+ aBOP.PerformWithFiller(aPF, aPS.Next(1));
BOPTest::ReportAlerts(aBOP.GetReport());
// Store the history of Boolean operation into the session
aFF.SetList(aListOfPnts);
aFF.SetFuzzyValue (BOPTest_Objects::FuzzyValue());
//
- aFF.Perform (aF1, aF2);
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
+ aFF.Perform (aF1, aF2, aProgress->Start());
//
anIsDone=aFF.IsDone();
if (!anIsDone) {
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;
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());
//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();
}
}
+ Message_ProgressScope aPS(theRange, NULL, myIsIntersectionNeeded ? 10 : 1);
// If necessary perform intersection of the argument shapes
if (myIsIntersectionNeeded)
{
aLArgs.Append(it.Value());
// Perform intersection
- IntersectShapes(aLArgs);
+ IntersectShapes(aLArgs, aPS.Next(9));
if (HasErrors())
{
if (aDumpOper.IsDump())
}
// Build the result
- BuildResult();
+ BuildResult(aPS.Next(1));
+ 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, NULL, 2);
// If necessary perform intersection of the argument shapes
- IntersectShapes(myArguments);
+ IntersectShapes(myArguments, aPS.Next());
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());
}
//=======================================================================
//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);
myDSFiller->SetUseOBB(myUseOBB);
// Set Face/Face intersection options to the intersection algorithm
SetAttributes();
+ Message_ProgressScope aPS(theRange, NULL, 1);
// Perform intersection
- myDSFiller->Perform();
+ myDSFiller->Perform(aPS.Next());
// 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);
+ Message_ProgressScope aPS(theRange, NULL, 1);
+ myBuilder->PerformWithFiller(*myDSFiller, aPS.Next());
// 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, NULL, 1);
+ anAnalyzer.Perform(aPS.Next());
+ if (HasErrors())
+ {
+ 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 progrs 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 progrs 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_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();
+ Message_ProgressScope aPS(theRange, "Cut", 1);
+ Build(aPS.Next());
}
//=======================================================================
//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();
+ Message_ProgressScope aPS(theRange, "Cut", 1);
+ Build(aPS.Next());
}
//! <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();
+ Message_ProgressScope aPS(theRange, "Fuse", 1);
+ Build(aPS.Next());
}
//=======================================================================
//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();
+ Message_ProgressScope aPS(theRange, "Fuse", 1);
+ Build(aPS.Next());
}
//! <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();
+ Message_ProgressScope aPS(theRange, NULL, 1);
+ BRepAlgoAPI_BooleanOperation::Build(aPS.Next());
}
//=======================================================================
//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, NULL, myIsIntersectionNeeded ? 10 : 1);
if (myIsIntersectionNeeded)
{
// Combine Arguments and Tools for intersection into a single list
aLArgs.Append(it.Value());
// Perform intersection
- IntersectShapes(aLArgs);
+ IntersectShapes(aLArgs, aPS.Next(9));
if (HasErrors())
return;
}
((BOPAlgo_Splitter*)myBuilder)->SetTools(myTools);
// Build result shape basing on the intersection results
- BuildResult();
+ BuildResult(aPS.Next(1));
}
//! 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;
//
+ Message_ProgressScope aPSOuter(theRange, NULL, 2);
if (!myShapes.IsEmpty()) {
+ Message_ProgressScope aPS(aPSOuter.Next(), "BRepFeat_Builder", 100);
//
Prepare();
//
RebuildFaces();
//
- FillImagesContainers(TopAbs_SHELL);
+ FillImagesContainers(TopAbs_SHELL, aPS.Next(30));
if (HasErrors()) {
return;
}
//
- FillImagesSolids();
+ FillImagesSolids(aPS.Next(30));
if (HasErrors()) {
return;
}
return;
}
//
- FillImagesCompounds();
+ FillImagesCompounds(aPS.Next(40));
if (HasErrors()) {
return;
}
}
}
//
- BuildShape();
+ BuildShape(aPSOuter.Next());
}
//=======================================================================
//! 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();
//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;
//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)
//purpose : intersect surfaces of the faces
//=======================================================================
void IntTools_FaceFace::Perform(const TopoDS_Face& aF1,
- const TopoDS_Face& aF2)
+ const TopoDS_Face& aF2,
+ const Message_ProgressRange& theRange)
{
+ Message_ProgressScope aPS(theRange, NULL, 1);
if (myContext.IsNull()) {
myContext=new IntTools_Context;
}
#include <IntSurf_ListOfPntOn2S.hxx>
#include <IntTools_SequenceOfCurves.hxx>
#include <IntTools_SequenceOfPntOn2Faces.hxx>
+#include <Message_ProgressRange.hxx>
#include <TopoDS_Face.hxx>
class IntTools_Context;
//! Intersects underliing surfaces of F1 and F2
//! Use sum of tolerance of F1 and F2 as intersection
//! criteria
- Standard_EXPORT void Perform (const TopoDS_Face& F1, const TopoDS_Face& F2);
+ Standard_EXPORT void Perform (const TopoDS_Face& F1, const TopoDS_Face& F2, const Message_ProgressRange& theRange = Message_ProgressRange());
//! Returns True if the intersection was successful
//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;
projects / occt-copy.git / commitdiff