OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-05 18:16:23 +03:00
Code Packages Releases Activity

0025614: Provide API access to the new fuctionalities of Boolean Components

Browse Source 
I. New features:
1.1. class BOPAlgo_PaveFiller
method:
void BOPAlgo_PaveFiller::SetArguments(const TopTools_ListOfShape& theLS)
has been added to provide the setting argumemts  through
TopTools_ListOfShape

1.2. class BOPAlgo_Builder
method:
void BOPAlgo_Builder::SetArguments(const TopTools_ListOfShape& theLS)
has been added to provide the setting argumemts  through
TopTools_ListOfShape

1.3. class BOPAlgo_BOP
method:
void BOPAlgo_BOP::SetTools(const TopTools_ListOfShape& theLS)
has been added to provide the setting tools through
TopTools_ListOfShape

1.4. class BRepAlgoAPI_BuilderAlgo
construcror:
BRepAlgoAPI_BuilderAlgo::BRepAlgoAPI_BuilderAlgo
  (const BOPAlgo_PaveFiller& aPF)
has been added to provide the construction
of the object using BOPAlgo_PaveFiller object

method:
void BRepAlgoAPI_BuilderAlgo::SetArguments
 (const TopTools_ListOfShape& theLS)
has been added to provide the setting argumemts

method:
const TopTools_ListOfShape& BRepAlgoAPI_BuilderAlgo::Arguments()const
has been added to provide access to the argumemts

1.5. class BRepAlgoAPI_BooleanOperation
method:
void BRepAlgoAPI_BooleanOperation::SetTools
  (const TopTools_ListOfShape& theLS)
has been added to provide the setting tools

method:
const TopTools_ListOfShape& BRepAlgoAPI_BooleanOperation::Tools()const
has been added to provide access to the tools

1.6. class BRepAlgoAPI_Common
construcror:
BRepAlgoAPI_Common::BRepAlgoAPI_Common
(const BOPAlgo_PaveFiller& aPF)
has been added to provide the construction
of the object using BOPAlgo_PaveFiller object

1.7. class BRepAlgoAPI_Cut
construcror:
BRepAlgoAPI_Cut::BRepAlgoAPI_Cut
(const BOPAlgo_PaveFiller& aPF)
has been added to provide the construction
of the object using BOPAlgo_PaveFiller object

1.8. class BRepAlgoAPI_Fuse
construcror:
BRepAlgoAPI_Fuse::BRepAlgoAPI_Fuse
(const BOPAlgo_PaveFiller& aPF)
has been added to provide the construction
of the object using BOPAlgo_PaveFiller object

1.9. class BRepAlgoAPI_Section
construcror:
BRepAlgoAPI_Section::BRepAlgoAPI_Section
(const BOPAlgo_PaveFiller& aPF)
has been added to provide the construction
of the object using BOPAlgo_PaveFiller object

1.10. class BOPTest
method:
void BOPTest::APICommands(Draw_Interpretor& theCommands)
has been added to provide tcl commands to launch the algorithms
implemented in BRepAlgoAPI package using DRAWEXE application.

Commands:
 >bapibuild r
   performs General Fuse algorithm.
     r -the result of the operation

 >bapibop r type
   performs Boolean Operation agorithm
      r -the result of the operation
      type -type of the operation:
        0-common
        1-fuse
        2-cut
        3-cut21
        4-section

method:
void BOPTest::OptionCommands(Draw_Interpretor& theCommands)
has been added to provide tcl commands to set/get the options that is
necessary for the algorithms implemented in BRepAlgoAPI package.

Commands:
 >boptions
   dump the state of current options

  >brunparallel [0/1]
   1 -sets the parallel mode of the computations
   0 -sets the sequential mode of the computations

  >bfuzzyvalue value
    sets the fuzzy value

-------------------------------------------------------------------------------------------------------------
II. Changes:
II.1. class BRepAlgoAPI_BuilderAlgo
methods:
const TopTools_ListOfShape& BRepAlgoAPI_BuilderAlgo::Generated
  (const TopoDS_Shape& aS)
const TopTools_ListOfShape& BRepAlgoAPI_BuilderAlgo::Modified
  (const TopoDS_Shape& aS)
Standard_Boolean BRepAlgoAPI_BuilderAlgo::IsDeleted
  (const TopoDS_Shape& aS)
Standard_Boolean BRepAlgoAPI_BuilderAlgo::HasModified() const
Standard_Boolean BRepAlgoAPI_BuilderAlgo::HasGenerated() const
Standard_Boolean BRepAlgoAPI_BuilderAlgo::HasDeleted() const
has been redefined to provide access to the history

II.1. class BOPTest
method:
void BOPTest::APICommands(Draw_Interpretor& theCommands)
has been added to provide tcl commands to launch the algorithms
implemented in BRepAlgoAPI package using DRAWEXE application.

method:
void BOPTest::OptionCommands(Draw_Interpretor& theCommands)
has been added to provide tcl commands to set/get the options that is
necessary for the algorithms implemented in BRepAlgoAPI package.

II.2. class BRepAlgoAPI
method:
void BRepAlgoAPI::DumpOper(const Standard_CString theFilePath,
                           const TopoDS_Shape& theShape1,
                           const TopoDS_Shape& theShape2,
                           const TopoDS_Shape& theResult,
                           BOPAlgo_Operation theOperation,
                           Standard_Boolean isNonValidArgs)
has been removed. The contents has been shifted into the file:
BRepAlgoAPI_BooleanOperation.cxx

II.3. classes QANewModTopOpe_Glue, QANewModTopOpe_Intersection
the modifications have been done to provide the consistency with the
modifications in BRepAlgoAPI package [I].
-------------------------------------------------------------------------------------------------------------
III. Modified entities:
packages:
BOPAlgo
BRepAlgoAPI
BOPTest
QANewModTopOpe

Test cases for issue CR25614
This commit is contained in:
pkv 2014-12-25 17:55:02 +03:00 committed by bugmaster
parent 6219c44ce7
commit 49b0c452e2
44 changed files with 2160 additions and 1030 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/BOPAlgo/BOPAlgo_BOP.cdl
View File

@ -51,6 +51,14 @@ is
---Purpose: Adds Tool argument of the operation
is virtual;
SetTools (me:out;
theShapes: ListOfShape from TopTools)
is virtual;
SetTools (me:out;
theShapes: ListOfShape from BOPCol)
is virtual;
SetOperation(me:out;
theOperation: Operation from BOPAlgo);

31
src/BOPAlgo/BOPAlgo_BOP.cxx
View File

@ -43,6 +43,7 @@
#include <BOPTools_Set.hxx>
#include <BOPTools_SetMapHasher.hxx>
#include <NCollection_DataMap.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
typedef NCollection_DataMap
<BOPTools_Set,
@ -129,6 +130,36 @@ void BOPAlgo_BOP::AddTool(const TopoDS_Shape& theShape)
}
}
//=======================================================================
//function : SetTools
//purpose :
//=======================================================================
void BOPAlgo_BOP::SetTools(const TopTools_ListOfShape& theShapes)
{
TopTools_ListIteratorOfListOfShape aIt;
//
myTools.Clear();
aIt.Initialize(theShapes);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS = aIt.Value();
AddTool(aS);
}
}
//=======================================================================
//function : SetTools
//purpose :
//=======================================================================
void BOPAlgo_BOP::SetTools(const BOPCol_ListOfShape& theShapes)
{
BOPCol_ListIteratorOfListOfShape aIt;
//
myTools.Clear();
aIt.Initialize(theShapes);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS = aIt.Value();
AddTool(aS);
}
}
//=======================================================================
//function : CheckData
//purpose :
//=======================================================================

5
src/BOPAlgo/BOPAlgo_Builder.cdl
View File

@ -63,7 +63,10 @@ is
is virtual;
SetArguments(me:out;
theShapes: ListOfShape from BOPCol)
theLS:ListOfShape from TopTools);
SetArguments (me:out;
theLS: ListOfShape from BOPCol)
is virtual;
Arguments(me)

19
src/BOPAlgo/BOPAlgo_Builder.cxx
View File

@ -26,6 +26,7 @@
#include <BRep_Builder.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
//=======================================================================
//function :
@ -106,10 +107,28 @@ void BOPAlgo_Builder::AddArgument(const TopoDS_Shape& theShape)
//function : SetArguments
//purpose :
//=======================================================================
void BOPAlgo_Builder::SetArguments(const TopTools_ListOfShape& theShapes)
{
TopTools_ListIteratorOfListOfShape aIt;
//
myArguments.Clear();
//
aIt.Initialize(theShapes);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS = aIt.Value();
AddArgument(aS);
}
}
//=======================================================================
//function : SetArguments
//purpose :
//=======================================================================
void BOPAlgo_Builder::SetArguments(const BOPCol_ListOfShape& theShapes)
{
BOPCol_ListIteratorOfListOfShape aIt;
//
myArguments.Clear();
//
aIt.Initialize(theShapes);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS = aIt.Value();

11
src/BOPAlgo/BOPAlgo_PaveFiller.cdl
View File

@ -26,6 +26,8 @@ uses
Face from TopoDS,
Edge from TopoDS,
ListOfShape from TopTools,
BaseAllocator from BOPCol,
ListOfShape from BOPCol,
MapOfInteger from BOPCol,
@ -81,10 +83,15 @@ is
returns PIterator from BOPDS;
---C++:return const &
SetArguments(me:out;
theLS:ListOfShape from BOPCol);
SetArguments(me:out;
theLS:ListOfShape from TopTools);
Arguments(me)
returns ListOfShape from BOPCol;
---C++: return const &
---C++: alias "Standard_EXPORT void SetArguments(const BOPCol_ListOfShape& theLS);"
Context(me:out)
returns Context from IntTools;
@ -127,7 +134,6 @@ is
PerformFF(me:out)
is virtual protected;
--modified by NIZNHY-PKV Fri Sep 12 07:05:37 2014f
PerformVZ(me:out)
is virtual protected;
--Purpose: Computes Vertex/Solid interferences
@ -142,7 +148,6 @@ is
PerformZZ(me:out)
is virtual protected;
--Purpose: Computes Solid/Solid interferences
--modified by NIZNHY-PKV Fri Sep 12 07:05:45 2014t
TreatVerticesEE(me:out)
is protected;

16
src/BOPAlgo/BOPAlgo_PaveFiller.cxx
View File

@ -25,6 +25,7 @@
#include <IntTools_Context.hxx>
#include <BOPDS_DS.hxx>
#include <BOPDS_Iterator.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
//=======================================================================
@ -112,6 +113,21 @@ void BOPAlgo_PaveFiller::SetSectionAttribute
//function : SetArguments
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::SetArguments(const TopTools_ListOfShape& theLS)
{
TopTools_ListIteratorOfListOfShape aItLS;
//
myArguments.Clear();
aItLS.Initialize(theLS);
for (; aItLS.More(); aItLS.Next()) {
const TopoDS_Shape& aS=aItLS.Value();
myArguments.Append(aS);
}
}
//=======================================================================
//function : SetArguments
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::SetArguments(const BOPCol_ListOfShape& theLS)
{
myArguments=theLS;

2
src/BOPTest/BOPTest.cdl
View File

@ -39,6 +39,8 @@ is
LowCommands (aDI:out Interpretor from Draw);
ObjCommands (aDI:out Interpretor from Draw);
PartitionCommands (aDI:out Interpretor from Draw);
APICommands (aDI:out Interpretor from Draw);
OptionCommands (aDI:out Interpretor from Draw);
Factory (aDI:out Interpretor from Draw);
end BOPTest;

8
src/BOPTest/BOPTest.cxx
View File

@ -20,9 +20,7 @@
#include <GeometryTest.hxx>
#include <BRepTest.hxx>
#include <MeshTest.hxx>
//#include <CorrectTest.hxx>
#include <HLRTest.hxx>
//#include <stdio.h>
//=======================================================================
//function : AllCommands
@ -40,6 +38,8 @@ void BOPTest::AllCommands(Draw_Interpretor& theCommands)
BOPTest::TolerCommands (theCommands);
BOPTest::ObjCommands (theCommands);
BOPTest::PartitionCommands (theCommands);
BOPTest::APICommands (theCommands);
BOPTest::OptionCommands (theCommands);
}
//=======================================================================
//function : Factory
@ -57,10 +57,6 @@ void BOPTest::AllCommands(Draw_Interpretor& theCommands)
GeometryTest::AllCommands(theCommands);
BRepTest::AllCommands(theCommands);
MeshTest::Commands(theCommands);
//CorrectTest::CorrectCommands(theCommands);
HLRTest::Commands(theCommands);
BOPTest::AllCommands(theCommands);
//printf(" BOP Plugin is loaded\n");
}
//#include <Draw_PluginMacro.hxx>
//DPLUGIN(BOPTest)

217
src/BOPTest/BOPTest_APICommands.cxx Normal file
View File

@ -0,0 +1,217 @@
// Created by: Peter KURNEV
// Copyright (c) 2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BOPTest.ixx>
#include <stdio.h>
#include <string.h>
#include <DBRep.hxx>
#include <Draw.hxx>
#include <TopoDS_Shape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPTest_Objects.hxx>
#include <BOPAlgo_PaveFiller.hxx>
#include <BRepAlgoAPI_BooleanOperation.hxx>
#include <BRepAlgoAPI_BuilderAlgo.hxx>
#include <BRepAlgoAPI_Common.hxx>
#include <BRepAlgoAPI_Fuse.hxx>
#include <BRepAlgoAPI_Cut.hxx>
#include <BRepAlgoAPI_Section.hxx>
static
void ConvertList(const BOPCol_ListOfShape& aLSB,
TopTools_ListOfShape& aLS);
static Standard_Integer bapibuild(Draw_Interpretor&, Standard_Integer, const char**);
static Standard_Integer bapibop (Draw_Interpretor&, Standard_Integer, const char**);
//=======================================================================
//function : APICommands
//purpose :
//=======================================================================
void BOPTest::APICommands(Draw_Interpretor& theCommands)
{
static Standard_Boolean done = Standard_False;
if (done) return;
done = Standard_True;
// Chapter's name
const char* g = "Partition commands";
// Commands
theCommands.Add("bapibuild", "use bapibuild r" , __FILE__, bapibuild, g);
theCommands.Add("bapibop", "use bapibop r type" , __FILE__, bapibop, g);
}
//=======================================================================
//function : bapibop
//purpose :
//=======================================================================
Standard_Integer bapibop(Draw_Interpretor& di,
Standard_Integer n,
const char** a)
{
if (n<3) {
di << " use bapibop r type\n";
return 0;
}
//
char buf[128];
Standard_Boolean bRunParallel;
Standard_Integer iErr, iOp;
Standard_Real aFuzzyValue;
BRepAlgoAPI_Common aCommon;
BRepAlgoAPI_Fuse aFuse;
BRepAlgoAPI_Cut aCut;
BRepAlgoAPI_Section aSection;
BRepAlgoAPI_BooleanOperation *pBuilder;
BOPAlgo_Operation aOp;
//
pBuilder=NULL;
iOp=atoi(a[2]);
if (iOp<0 || iOp>4) {
printf(" invalid operation type\n");
return 0;
}
aOp=(BOPAlgo_Operation)iOp;
//
switch (aOp) {
case BOPAlgo_COMMON:
pBuilder=&aCommon;
break;
//
case BOPAlgo_FUSE:
pBuilder=&aFuse;
break;
//
case BOPAlgo_CUT:
case BOPAlgo_CUT21:
pBuilder=&aCut;
break;
//
case BOPAlgo_SECTION:
pBuilder=&aSection;
break;
//
default:
break;
}
//
BOPCol_ListOfShape& aLSB=BOPTest_Objects::Shapes();
BOPCol_ListOfShape& aLTB=BOPTest_Objects::Tools();
//
TopTools_ListOfShape aLS, aLT;
ConvertList(aLSB, aLS);
ConvertList(aLTB, aLT);
//
bRunParallel=BOPTest_Objects::RunParallel();
aFuzzyValue=BOPTest_Objects::FuzzyValue();
//
if (aOp!=BOPAlgo_CUT21) {
pBuilder->SetArguments(aLS);
pBuilder->SetTools(aLT);
}
else {
pBuilder->SetArguments(aLT);
pBuilder->SetTools(aLS);
}
//
pBuilder->SetRunParallel(bRunParallel);
pBuilder->SetFuzzyValue(aFuzzyValue);
//
pBuilder->Build();
iErr=pBuilder->ErrorStatus();
if (iErr) {
Sprintf(buf, " error: %d\n", iErr);
di << buf;
return 0;
}
//
const TopoDS_Shape& aR=pBuilder->Shape();
if (aR.IsNull()) {
di << " null shape\n";
return 0;
}
//
DBRep::Set(a[1], aR);
return 0;
}
//=======================================================================
//function : bapibuild
//purpose :
//=======================================================================
Standard_Integer bapibuild(Draw_Interpretor& di,
Standard_Integer n,
const char** a)
{
if (n<2) {
di << " use bapibuild r\n";
return 0;
}
//
char buf[128];
Standard_Boolean bRunParallel;
Standard_Integer iErr;
Standard_Real aFuzzyValue;
BRepAlgoAPI_BuilderAlgo aBuilder;
//
BOPCol_ListOfShape& aLSB=BOPTest_Objects::Shapes();
//
TopTools_ListOfShape aLS, aLT;
ConvertList(aLSB, aLS);
//
bRunParallel=BOPTest_Objects::RunParallel();
aFuzzyValue=BOPTest_Objects::FuzzyValue();
//
aBuilder.SetArguments(aLS);
aBuilder.SetRunParallel(bRunParallel);
aBuilder.SetFuzzyValue(aFuzzyValue);
//
aBuilder.Build();
iErr=aBuilder.ErrorStatus();
if (iErr) {
Sprintf(buf, " error: %d\n", iErr);
di << buf;
return 0;
}
//
const TopoDS_Shape& aR=aBuilder.Shape();
if (aR.IsNull()) {
di << " null shape\n";
return 0;
}
//
DBRep::Set(a[1], aR);
return 0;
}
//=======================================================================
//function : ConvertLists
//purpose :
//=======================================================================
void ConvertList(const BOPCol_ListOfShape& aLSB,
TopTools_ListOfShape& aLS)
{
BOPCol_ListIteratorOfListOfShape aItB;
//
aLS.Clear();
aItB.Initialize(aLSB);
for (; aItB.More(); aItB.Next()) {
const TopoDS_Shape& aS=aItB.Value();
aLS.Append(aS);
}
}

181
src/BOPTest/BOPTest_BOPCommands.cxx
View File

@ -17,7 +17,12 @@
#include <stdio.h>
#include <TCollection_AsciiString.hxx>
#include <DBRep.hxx>
#include <DrawTrSurf.hxx>
#include <Draw_Color.hxx>
#include <Draw.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <NCollection_IncAllocator.hxx>
@ -28,26 +33,27 @@
//
#include <BRep_Builder.hxx>
#include <IntTools_FaceFace.hxx>
#include <IntTools_Curve.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPDS_DS.hxx>
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPAlgo_Operation.hxx>
#include <BOPAlgo_BOP.hxx>
#include <BOPAlgo_MakerVolume.hxx>
#include <BOPDS_DS.hxx>
#include <BOPTest_DrawableShape.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPAlgo_Section.hxx>
#include <TCollection_AsciiString.hxx>
#include <IntTools_FaceFace.hxx>
#include <IntTools_Curve.hxx>
#include <DrawTrSurf.hxx>
#include <Draw_Color.hxx>
#include <Draw.hxx>
#include <BRepAlgoAPI_BooleanOperation.hxx>
#include <BRepAlgoAPI_Common.hxx>
#include <BRepAlgoAPI_Fuse.hxx>
#include <BRepAlgoAPI_Cut.hxx>
#include <BRepAlgoAPI_Section.hxx>
#include <BOPAlgo_Section.hxx>
#include <BOPTest_DrawableShape.hxx>
#include <BOPTest_Objects.hxx>
//
static BOPAlgo_PaveFiller* pPF=NULL;
@ -126,6 +132,7 @@ static Standard_Integer mkvolume (Draw_Interpretor&, Standard_Integer, const c
Standard_Integer bop(Draw_Interpretor& di, Standard_Integer n, const char** a)
{
char buf[32];
Standard_Boolean bRunParallel;
Standard_Integer iErr;
Standard_Real aTol;
TopoDS_Shape aS1, aS2;
@ -133,7 +140,7 @@ Standard_Integer bop (Draw_Interpretor& di, Standard_Integer n, const char** a)
//
if (n < 3 || n > 4) {
di << " use bop Shape1 Shape2 [tol]\n";
return 1;
return 0;
}
//
aS1=DBRep::Get(a[1]);
@ -141,14 +148,16 @@ Standard_Integer bop (Draw_Interpretor& di, Standard_Integer n, const char** a)
//
if (aS1.IsNull() || aS2.IsNull()) {
di << " null shapes are not allowed \n";
return 1;
return 0;
}
//
aTol = 0.;
aTol=BOPTest_Objects::FuzzyValue();
if (n == 4) {
aTol = Draw::Atof(a[3]);
}
//
bRunParallel=BOPTest_Objects::RunParallel();
//
aLC.Append(aS1);
aLC.Append(aS2);
//
@ -161,6 +170,7 @@ Standard_Integer bop (Draw_Interpretor& di, Standard_Integer n, const char** a)
//
pPF->SetArguments(aLC);
pPF->SetFuzzyValue(aTol);
pPF->SetRunParallel(bRunParallel);
//
pPF->Perform();
iErr=pPF->ErrorStatus();
@ -229,6 +239,7 @@ Standard_Integer bopsmt(Draw_Interpretor& di,
}
//
char buf[64];
Standard_Boolean bRunParallel;
Standard_Integer aNb, iErr;
BOPAlgo_BOP aBOP;
//
@ -240,12 +251,15 @@ Standard_Integer bopsmt(Draw_Interpretor& di,
return 0;
}
//
bRunParallel=BOPTest_Objects::RunParallel();
//
const TopoDS_Shape& aS1=aLC.First();
const TopoDS_Shape& aS2=aLC.Last();
//
aBOP.AddArgument(aS1);
aBOP.AddTool(aS2);
aBOP.SetOperation(aOp);
aBOP.SetRunParallel (bRunParallel);
//
aBOP.PerformWithFiller(*pPF);
iErr=aBOP.ErrorStatus();
@ -286,6 +300,7 @@ Standard_Integer bopsection(Draw_Interpretor& di, Standard_Integer n, const char
}
//
char buf[64];
Standard_Boolean bRunParallel;
Standard_Integer aNb, iErr;
BOPAlgo_Section aBOP;
//
@ -297,11 +312,14 @@ Standard_Integer bopsection(Draw_Interpretor& di, Standard_Integer n, const char
return 0;
}
//
bRunParallel=BOPTest_Objects::RunParallel();
//
const TopoDS_Shape& aS1=aLC.First();
const TopoDS_Shape& aS2=aLC.Last();
//
aBOP.AddArgument(aS1);
aBOP.AddArgument(aS2);
aBOP.SetRunParallel (bRunParallel);
//
aBOP.PerformWithFiller(*pPF);
iErr=aBOP.ErrorStatus();
@ -363,7 +381,7 @@ Standard_Integer bsection(Draw_Interpretor& di,
const char* usage = " Usage: bsection Result s1 s2 [-n2d/-n2d1/-n2d2] [-na] [tol]\n";
if (n < 4) {
di << usage;
return 1;
return 0;
}
//
TopoDS_Shape aS1 = DBRep::Get(a[2]);
@ -371,17 +389,19 @@ Standard_Integer bsection(Draw_Interpretor& di,
//
if (aS1.IsNull() || aS2.IsNull()) {
di << " Null shapes are not allowed \n";
return 1;
return 0;
}
//
Standard_Boolean bApp, bPC1, bPC2;
Standard_Integer i;
char buf[80];
Standard_Boolean bRunParallel, bApp, bPC1, bPC2;
Standard_Integer i, iErr;
Standard_Real aTol;
//
bApp = Standard_True;
bPC1 = Standard_True;
bPC2 = Standard_True;
aTol = 0.;
aTol = BOPTest_Objects::FuzzyValue();
bRunParallel = BOPTest_Objects::RunParallel();
//
for (i = 4; i < n; ++i) {
if (!strcmp(a[i], "-n2d")) {
@ -402,14 +422,13 @@ Standard_Integer bsection(Draw_Interpretor& di,
}
}
//
Standard_Integer iErr;
char buf[80];
//
BRepAlgoAPI_Section aSec(aS1, aS2, Standard_False);
//
aSec.Approximation(bApp);
aSec.ComputePCurveOn1(bPC1);
aSec.ComputePCurveOn2(bPC2);
aSec.SetFuzzyValue(aTol);
aSec.SetRunParallel(bRunParallel);
//
aSec.Build();
iErr=aSec.ErrorStatus();
@ -427,7 +446,6 @@ Standard_Integer bsection(Draw_Interpretor& di,
DBRep::Set(a[1], aR);
return 0;
}
//=======================================================================
//function : bsmt
//purpose :
@ -438,6 +456,7 @@ Standard_Integer bsmt (Draw_Interpretor& di,
const BOPAlgo_Operation aOp)
{
char buf[32];
Standard_Boolean bRunParallel;
Standard_Integer iErr;
TopoDS_Shape aS1, aS2;
BOPCol_ListOfShape aLC;
@ -445,7 +464,7 @@ Standard_Integer bsmt (Draw_Interpretor& di,
//
if (n < 4 || n > 5) {
di << " use bx r s1 s2 [tol]\n";
return 1;
return 0;
}
//
aS1=DBRep::Get(a[2]);
@ -453,22 +472,26 @@ Standard_Integer bsmt (Draw_Interpretor& di,
//
if (aS1.IsNull() || aS2.IsNull()) {
di << " null shapes are not allowed \n";
return 1;
return 0;
}
aLC.Append(aS1);
aLC.Append(aS2);
//
aTol = 0.;
aTol=BOPTest_Objects::FuzzyValue();
if (n == 5) {
aTol = Draw::Atof(a[4]);
}
//
aLC.Append(aS1);
aLC.Append(aS2);
bRunParallel = BOPTest_Objects::RunParallel();
//
Handle(NCollection_BaseAllocator)aAL=new NCollection_IncAllocator;
//
//---------------------------------------------------------------
BOPAlgo_PaveFiller aPF(aAL);
//
aPF.SetArguments(aLC);
aPF.SetFuzzyValue(aTol);
aPF.SetRunParallel(bRunParallel);
//
aPF.Perform();
iErr=aPF.ErrorStatus();
@ -478,36 +501,31 @@ Standard_Integer bsmt (Draw_Interpretor& di,
return 0;
}
//
BRepAlgoAPI_BooleanOperation* pBuilder=NULL;
//---------------------------------------------------------------
BOPAlgo_BOP aBOP(aAL);
//
if (aOp==BOPAlgo_COMMON) {
pBuilder=new BRepAlgoAPI_Common(aS1, aS2, aPF);
}
else if (aOp==BOPAlgo_FUSE) {
pBuilder=new BRepAlgoAPI_Fuse(aS1, aS2, aPF);
}
else if (aOp==BOPAlgo_CUT) {
pBuilder=new BRepAlgoAPI_Cut (aS1, aS2, aPF);
}
else if (aOp==BOPAlgo_CUT21) {
pBuilder=new BRepAlgoAPI_Cut(aS1, aS2, aPF, Standard_False);
}
aBOP.AddArgument(aS1);
aBOP.AddTool(aS2);
aBOP.SetOperation(aOp);
aBOP.SetRunParallel(bRunParallel);
//
iErr = pBuilder->ErrorStatus();
if (!pBuilder->IsDone()) {
aBOP.PerformWithFiller(aPF);
//
iErr=aBOP.ErrorStatus();
if (iErr) {
Sprintf(buf, " ErrorStatus : %d\n", iErr);
di << buf;
return 0;
}
const TopoDS_Shape& aR=pBuilder->Shape();
const TopoDS_Shape& aR=aBOP.Shape();
if (aR.IsNull()) {
di << " null shape\n";
return 0;
}
//
DBRep::Set(a[1], aR);
return 0;
}
//=======================================================================
//function : bopnews
//purpose :
@ -579,7 +597,6 @@ Standard_Integer bopnews (Draw_Interpretor& di,
//
return 0;
}
//=======================================================================
//function : bopcurves
//purpose :
@ -617,7 +634,8 @@ Standard_Integer bopcurves (Draw_Interpretor& di,
const TopoDS_Face& aF1=*(TopoDS_Face*)(&S1);
const TopoDS_Face& aF2=*(TopoDS_Face*)(&S2);
Standard_Boolean aToApproxC3d, aToApproxC2dOnS1, aToApproxC2dOnS2, anIsDone, bMake2dCurves;
Standard_Boolean aToApproxC3d, aToApproxC2dOnS1,
aToApproxC2dOnS2, anIsDone, bMake2dCurves;
Standard_Integer i, aNbCurves;
Standard_Real anAppTol, aTolR;
TCollection_AsciiString aNm("c_");
@ -666,8 +684,7 @@ Standard_Integer bopcurves (Draw_Interpretor& di,
di << " has no 3d curve\n";
return 1;
}
else
{
else {
di << aNbCurves << " curve(s) found.\n";
}
@ -707,7 +724,8 @@ Standard_Integer bopcurves (Draw_Interpretor& di,
di << "(" << nameC2d2 << ") ";
di << " \n Null first 2d curve of the curve #" << i << "\n";
continue;
} else {
}
else {
TCollection_AsciiString pc1N("c2d1_"), pc1Nx;
pc1Nx = pc1N + anIndx;
Standard_CString nameC2d1 = pc1Nx.ToCString();
@ -719,7 +737,8 @@ Standard_Integer bopcurves (Draw_Interpretor& di,
if (aPC2.IsNull()) {
di << ") \n Null second 2d curve of the curve #" << i << "\n";
continue;
} else {
}
else {
TCollection_AsciiString pc2N("c2d2_"), pc2Nx;
pc2Nx = pc2N + anIndx;
Standard_CString nameC2d2 = pc2Nx.ToCString();
@ -734,36 +753,6 @@ Standard_Integer bopcurves (Draw_Interpretor& di,
return 0;
}
//=======================================================================
//function : bparallelmode
//purpose :
//=======================================================================
Standard_Integer bparallelmode(Draw_Interpretor& di, Standard_Integer n, const char** a)
{
if (n == 2)
{
Standard_Boolean isParallelOn = Draw::Atoi (a[1]) == 1;
if (isParallelOn == 1)
{
BOPAlgo_Algo::SetParallelMode(Standard_True);
di << "Parallel mode for boolean operations has been enabled";
}
else
{
BOPAlgo_Algo::SetParallelMode(Standard_False);
di << "Parallel mode for boolean operations has been disabled";
}
}
else
{
di << "Parallel mode state for boolean operations: "
<< (BOPAlgo_Algo::GetParallelMode()? "enabled" : "disabled");
}
return 0;
}
//=======================================================================
//function : mkvolume
//purpose :
@ -789,9 +778,9 @@ Standard_Integer mkvolume(Draw_Interpretor& di, Standard_Integer n, const char**
TopoDS_Shape aS;
BOPCol_ListOfShape aLS;
//
aTol = 0.;
aTol = BOPTest_Objects::FuzzyValue();
bToIntersect = Standard_True;
bRunParallel = Standard_True;
bRunParallel = BOPTest_Objects::RunParallel();
bCompounds = Standard_False;
//
for (i = 2; i < n; ++i) {
@ -858,3 +847,31 @@ Standard_Integer mkvolume(Draw_Interpretor& di, Standard_Integer n, const char**
//
return 0;
}
//=======================================================================
//function : bparallelmode
//purpose :
//=======================================================================
Standard_Integer bparallelmode(Draw_Interpretor& di, Standard_Integer n, const char** a)
{
if (n == 2)
{
Standard_Boolean isParallelOn = Draw::Atoi (a[1]) == 1;
if (isParallelOn == 1)
{
BOPAlgo_Algo::SetParallelMode(Standard_True);
di << "Parallel mode for boolean operations has been enabled";
}
else
{
BOPAlgo_Algo::SetParallelMode(Standard_False);
di << "Parallel mode for boolean operations has been disabled";
}
}
else
{
di << "Parallel mode state for boolean operations: "
<< (BOPAlgo_Algo::GetParallelMode()? "enabled" : "disabled");
}
return 0;
}

12
src/BOPTest/BOPTest_Objects.cdl
View File

@ -64,6 +64,18 @@ is
SetBuilderDefault(myclass);
SetRunParallel(myclass;
theFlag: Boolean from Standard);
RunParallel(myclass)
returns Boolean from Standard;
SetFuzzyValue(myclass;
theValue: Real from Standard);
FuzzyValue(myclass)
returns Real from Standard;
--fields
end Objects;

71
src/BOPTest/BOPTest_Objects.cxx
View File

@ -45,6 +45,8 @@ class BOPTest_Session {
myBuilderDefault=new BOPAlgo_Builder(pA2);
//
myBuilder=myBuilderDefault;
myRunParallel=Standard_False;
myFuzzyValue=0.;
};
//
// Clear
@ -84,11 +86,40 @@ class BOPTest_Session {
myBuilder=myBuilderDefault;
};
//
BOPCol_ListOfShape& Shapes() {
return myShapes;
}
//
BOPCol_ListOfShape& Tools() {
return myTools;
}
//
void SetRunParallel(const Standard_Boolean bFlag) {
myRunParallel=bFlag;
};
//
Standard_Boolean RunParallel()const {
return myRunParallel;
};
//
void SetFuzzyValue(const Standard_Real aValue) {
myFuzzyValue=aValue;
};
//
Standard_Real FuzzyValue()const {
return myFuzzyValue;
};
//
protected:
//
BOPAlgo_PaveFiller* myPaveFiller;
BOPAlgo_Builder* myBuilder;
BOPAlgo_Builder* myBuilderDefault;
//
BOPCol_ListOfShape myShapes;
BOPCol_ListOfShape myTools;
Standard_Boolean myRunParallel;
Standard_Real myFuzzyValue;
};
//
//=======================================================================
@ -120,8 +151,6 @@ void BOPTest_Objects::Init()
void BOPTest_Objects::Clear()
{
GetSession().Clear();
//
//clear objects and tools
Shapes().Clear();
Tools().Clear();
}
@ -192,8 +221,7 @@ BOPAlgo_Section& BOPTest_Objects::Section()
//=======================================================================
BOPCol_ListOfShape& BOPTest_Objects::Shapes()
{
static BOPCol_ListOfShape s_Shapes;
return s_Shapes;
return GetSession().Shapes();
}
//=======================================================================
//function : Tools
@ -201,8 +229,39 @@ BOPCol_ListOfShape& BOPTest_Objects::Shapes()
//=======================================================================
BOPCol_ListOfShape& BOPTest_Objects::Tools()
{
static BOPCol_ListOfShape s_Tools;
return s_Tools;
return GetSession().Tools();
}
//=======================================================================
//function : SetRunParallel
//purpose :
//=======================================================================
void BOPTest_Objects::SetRunParallel(const Standard_Boolean bFlag)
{
GetSession().SetRunParallel(bFlag);
}
//=======================================================================
//function : RunParallel
//purpose :
//=======================================================================
Standard_Boolean BOPTest_Objects::RunParallel()
{
return GetSession().RunParallel();
}
//=======================================================================
//function : SetFuzzyValue
//purpose :
//=======================================================================
void BOPTest_Objects::SetFuzzyValue(const Standard_Real aValue)
{
GetSession().SetFuzzyValue(aValue);
}
//=======================================================================
//function : FuzzyValue
//purpose :
//=======================================================================
Standard_Real BOPTest_Objects::FuzzyValue()
{
return GetSession().FuzzyValue();
}
//=======================================================================
//function : Allocator1

123
src/BOPTest/BOPTest_OptionCommands.cxx Normal file
View File

@ -0,0 +1,123 @@
// Created by: Peter KURNEV
// Copyright (c) 2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BOPTest.ixx>
#include <stdio.h>
#include <string.h>
#include <DBRep.hxx>
#include <Draw.hxx>
#include <BOPTest_Objects.hxx>
static Standard_Integer boptions (Draw_Interpretor&, Standard_Integer, const char**);
static Standard_Integer brunparallel (Draw_Interpretor&, Standard_Integer, const char**);
static Standard_Integer bfuzzyvalue (Draw_Interpretor&, Standard_Integer, const char**);
//=======================================================================
//function : OptionCommands
//purpose :
//=======================================================================
void BOPTest::OptionCommands(Draw_Interpretor& theCommands)
{
static Standard_Boolean done = Standard_False;
if (done) return;
done = Standard_True;
// Chapter's name
const char* g = "Partition commands";
// Commands
theCommands.Add("boptions", "use boptions" , __FILE__, boptions, g);
theCommands.Add("brunparallel", "use brunparallel [0/1]" , __FILE__, brunparallel, g);
theCommands.Add("bfuzzyvalue", "use bfuzzyvalue value" , __FILE__, bfuzzyvalue, g);
}
//=======================================================================
//function : boptions
//purpose :
//=======================================================================
Standard_Integer boptions(Draw_Interpretor& di,
Standard_Integer n,
const char** )
{
if (n!=1) {
di << " use boptions\n";
return 0;
}
//
char buf[128];
Standard_Boolean bRunParallel;
Standard_Real aFuzzyValue;
//
bRunParallel=BOPTest_Objects::RunParallel();
aFuzzyValue=BOPTest_Objects::FuzzyValue();
Sprintf(buf, " RunParallel: %d\n", bRunParallel);
di << buf;
Sprintf(buf, " FuzzyValue : %lf\n", aFuzzyValue);
di << buf;
//
return 0;
}
//=======================================================================
//function : bfuzzyvalue
//purpose :
//=======================================================================
Standard_Integer bfuzzyvalue(Draw_Interpretor& di,
Standard_Integer n,
const char** a)
{
if (n!=2) {
di << " use bfuzzyvalue value\n";
return 0;
}
//
Standard_Real aFuzzyValue;
//
aFuzzyValue=Draw::Atof(a[1]);
if (aFuzzyValue<0.) {
di << " Wrong value.\n";
return 0;
}
//
BOPTest_Objects::SetFuzzyValue(aFuzzyValue);
//
return 0;
}
//=======================================================================
//function : brunparallel
//purpose :
//=======================================================================
Standard_Integer brunparallel(Draw_Interpretor& di,
Standard_Integer n,
const char** a)
{
if (n!=2) {
di << " use brunparallel [0/1]\n";
return 0;
}
//
Standard_Integer iX;
Standard_Boolean bRunParallel;
//
iX=Draw::Atoi(a[1]);
if (iX<0 || iX>1) {
di << " Wrong value.\n";
return 0;
}
//
bRunParallel=(Standard_Boolean)(iX);
BOPTest_Objects::SetRunParallel(bRunParallel);
//
return 0;
}

11
src/BOPTest/BOPTest_PartitionCommands.cxx
View File

@ -59,7 +59,6 @@ void BOPTest::PartitionCommands(Draw_Interpretor& theCommands)
theCommands.Add("bbop" , "use bbop r op [-s -t]" , __FILE__, bbop, g);
theCommands.Add("bclear" , "use bclear" , __FILE__, bclear, g);
}
//=======================================================================
//function : bclear
//purpose :
@ -105,8 +104,10 @@ Standard_Integer bfillds(Draw_Interpretor& di,
}
//
bShowTime = Standard_False;
bRunParallel = Standard_True;
aTol = 0.;
//
bRunParallel=BOPTest_Objects::RunParallel();
aTol=BOPTest_Objects::FuzzyValue();
//
for (i=1; i<n; ++i) {
if (!strcmp(a[i], "-s")) {
bRunParallel=Standard_False;
@ -207,7 +208,7 @@ Standard_Integer bbuild(Draw_Interpretor& di,
}
//
bShowTime=Standard_False;
bRunParallel=Standard_True;
bRunParallel=BOPTest_Objects::RunParallel();
for (i=2; i<n; ++i) {
if (!strcmp(a[i], "-s")) {
bRunParallel=Standard_False;
@ -282,7 +283,7 @@ Standard_Integer bbop(Draw_Interpretor& di,
aOp=(BOPAlgo_Operation)iOp;
//
bShowTime=Standard_False;
bRunParallel=Standard_True;
bRunParallel=BOPTest_Objects::RunParallel();
for (i=3; i<n; ++i) {
if (!strcmp(a[i], "-s")) {
bRunParallel=Standard_False;

3
src/BOPTest/FILES
View File

@ -4,4 +4,5 @@ BOPTest_LowCommands.cxx
BOPTest_CheckCommands.cxx
BOPTest_TolerCommands.cxx
BOPTest_ObjCommands.cxx
BOPTest_Chronometer.hxx
BOPTest_APICommands.cxx
BOPTest_OptionCommands.cxx

69
src/BRepAlgoAPI/BRepAlgoAPI.cdl
View File

@ -16,44 +16,6 @@
package BRepAlgoAPI
uses
TopTools,
TopoDS,
gp,
Geom,
Geom2d,
Message,
BOPCol,
BOPAlgo,
BOPDS,
BRepBuilderAPI
is
deferred class BooleanOperation;
class Fuse;
class Common;
class Cut;
class Section;
class Check;
---Purpose: Check shapes on validity for boolean
--- operation.
deferred class Algo;
deferred class BuilderAlgo;
DumpOper( theFilePath : CString from Standard;
theShape1 : Shape from TopoDS;
theShape2 : Shape from TopoDS;
theResult : Shape from TopoDS;
theOperation : Operation from BOPAlgo;
isNonValidArgs : Boolean from Standard );
---Purpose: Dump arguments and result of boolean operation in the file specified by path.
---Level: Public
end BRepAlgoAPI;
---Purpose: The BRepAlgoAPI package provides a full range of
-- services to perform Boolean Operations on arguments (shapes
-- that are defined in the BRep data structures). The
@ -119,3 +81,34 @@ end BRepAlgoAPI;
-- each other. The same condition is true for SHELLs or FACEs,
-- WIREs or EDGEs.
-- It does not support Boolean Operations for COMPSOLID type of shape.
uses
TopTools,
TopoDS,
gp,
Geom,
Geom2d,
Message,
BOPCol,
BOPAlgo,
BOPDS,
BRepBuilderAPI
is
deferred class BooleanOperation;
class Fuse;
class Common;
class Cut;
class Section;
class Check;
---Purpose: Check shapes on validity for boolean
--- operation.
deferred class Algo;
class BuilderAlgo;
end BRepAlgoAPI;

105
src/BRepAlgoAPI/BRepAlgoAPI.cxx
View File

@ -1,105 +0,0 @@
// Created on: 2012-12-25
// Created by: KULIKOVA Galina
// Copyright (c) 2012-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BRepAlgoAPI.ixx>
#include <stdio.h>
#include <TCollection_AsciiString.hxx>
#include <BRepTools.hxx>
#include <OSD_File.hxx>
//=======================================================================
//function : dumpOper
//purpose :
//=======================================================================
void BRepAlgoAPI::DumpOper(const Standard_CString theFilePath,
const TopoDS_Shape& theShape1,
const TopoDS_Shape& theShape2,
const TopoDS_Shape& theResult,
BOPAlgo_Operation theOperation,
Standard_Boolean isNonValidArgs)
{
TCollection_AsciiString aPath(theFilePath);
aPath += "/";
Standard_Integer aNumOper = 1;
Standard_Boolean isExist = Standard_True;
TCollection_AsciiString aFileName;
while(isExist)
{
aFileName = aPath + "BO_" + TCollection_AsciiString(aNumOper) +".tcl";
OSD_File aScript(aFileName);
isExist = aScript.Exists();
if(isExist)
aNumOper++;
}
FILE* afile = fopen(aFileName.ToCString(), "w+");
if(!afile)
return;
if(isNonValidArgs)
fprintf(afile,"%s\n","# Arguments are invalid");
TCollection_AsciiString aName1;
TCollection_AsciiString aName2;
TCollection_AsciiString aNameRes;
if(!theShape1.IsNull())
{
aName1 = aPath +
"Arg1_" + TCollection_AsciiString(aNumOper) + ".brep";
BRepTools::Write(theShape1, aName1.ToCString());
}
else
fprintf(afile,"%s\n","# First argument is Null ");
if(!theShape2.IsNull())
{
aName2 = aPath +
"Arg2_"+ TCollection_AsciiString(aNumOper) + ".brep";
BRepTools::Write(theShape2, aName2.ToCString());
}
else
fprintf(afile,"%s\n","# Second argument is Null ");
if(!theResult.IsNull())
{
aNameRes = aPath +
"Result_"+ TCollection_AsciiString(aNumOper) + ".brep";
BRepTools::Write(theResult, aNameRes.ToCString());
}
else
fprintf(afile,"%s\n","# Result is Null ");
fprintf(afile, "%s %s %s\n","restore", aName1.ToCString(), "arg1");
fprintf(afile, "%s %s %s\n","restore", aName2.ToCString(), "arg2");;
TCollection_AsciiString aBopString;
switch (theOperation)
{
case BOPAlgo_COMMON : aBopString += "bcommon Res "; break;
case BOPAlgo_FUSE : aBopString += "bfuse Res "; break;
case BOPAlgo_CUT :
case BOPAlgo_CUT21 : aBopString += "bcut Res "; break;
case BOPAlgo_SECTION : aBopString += "bsection Res "; break;
default : break;
};
aBopString += ("arg1 arg2");
if(theOperation == BOPAlgo_CUT21)
aBopString += " 1";
fprintf(afile, "%s\n",aBopString.ToCString());
fclose(afile);
}

11
src/BRepAlgoAPI/BRepAlgoAPI_Algo.cdl
View File

@ -27,15 +27,23 @@ is
Initialize
returns Algo from BRepAlgoAPI;
---C++: alias "Standard_EXPORT virtual ~BRepAlgoAPI_Algo();"
---Purpose: Empty constructor
Initialize (theAllocator: BaseAllocator from BOPCol)
returns Algo from BRepAlgoAPI;
---Purpose: Empty constructor
ErrorStatus (me)
returns Integer from Standard;
---Purpose: Returns error status of the algorithm
-- ==0 - no errors occured
-- !=0 - is in the event of various error conditions
WarningStatus (me)
returns Integer from Standard;
---Purpose: Returns warning status of the algorithm
-- ==0 - no warning occured
-- !=0 - is in the event of various warning conditions
Allocator(me)
returns BaseAllocator from BOPCol;
@ -65,6 +73,9 @@ is
is redefined;
---C++: return const &
Clear(me:out)
is virtual protected;
fields
myAllocator : BaseAllocator from BOPCol is protected;
myErrorStatus : Integer from Standard is protected;

8
src/BRepAlgoAPI/BRepAlgoAPI_Algo.cxx
View File

@ -120,7 +120,13 @@ const TopoDS_Shape& BRepAlgoAPI_Algo::Shape() const
{
return myShape;
}
//=======================================================================
//function : Clear
//purpose :
//=======================================================================
void BRepAlgoAPI_Algo::Clear()
{
}
// myErrorStatus
//
// 1 - object is just initialized

106
src/BRepAlgoAPI/BRepAlgoAPI_BooleanOperation.cdl
View File

@ -17,83 +17,95 @@
deferred class BooleanOperation from BRepAlgoAPI
inherits BuilderAlgo from BRepAlgoAPI
---Purpose: The abstract class BooleanOperation is the root
---Purpose:
-- The abstract class BooleanOperation is the root
-- class of Boolean Operations (see Overview).
-- Boolean Operations algorithm is divided onto two parts.
-- - The first one is computing interference between arguments.
-- - The second one is building the result of operation.
-- The BooleanOperation class provides execution of both parts
-- of the Boolean Operations algorithm. The second part
-- (building the result) depends on given type of the Boolean
-- Operation (see Constructor).
-- The class BooleanOperation provides API level of both parts
uses
Shape from TopoDS,
DataMapOfShapeShape from TopTools,
ListOfShape from TopTools,
--
Operation from BOPAlgo,
PaveFiller from BOPAlgo
is
Initialize
returns BooleanOperation from BRepAlgoAPI;
---Purpose: Empty constructor
Initialize (PF :PaveFiller from BOPAlgo)
returns BooleanOperation from BRepAlgoAPI;
---Purpose: Empty constructor
-- <PF> - PaveFiller object that is carried out
Initialize (S1 :Shape from TopoDS;
S2 :Shape from TopoDS;
anOperation:Operation from BOPAlgo);
---Purpose: Prepares the operations for S1 and S2.
---Purpose: Constructor with two arguments
-- <S1>, <S2> -arguments
-- <anOperation> - the type of the operation
-- Obsolete
Initialize (S1 :Shape from TopoDS;
S2 :Shape from TopoDS;
aPF :PaveFiller from BOPAlgo;
PF :PaveFiller from BOPAlgo;
anOperation:Operation from BOPAlgo);
---Purpose: Prepares the operations for S1 and S2.
SetShape1(me:out;
S:Shape from TopoDS);
SetShape2(me:out;
S:Shape from TopoDS);
---Purpose: Constructor with two arguments
-- <S1>, <S2> -arguments
-- <anOperation> - the type of the operation
-- <PF> - PaveFiller object that is carried out
-- Obsolete
Shape1(me)
returns Shape from TopoDS
is static;
---Purpose: Returns the first shape involved in this Boolean operation.
---Purpose: Returns the first argument involved in this Boolean operation.
-- Obsolete
---C++: return const &
---C++: alias "Standard_EXPORT virtual ~BRepAlgoAPI_BooleanOperation();"
Shape2(me)
returns Shape from TopoDS
is static;
---Purpose: Returns the second shape involved in this Boolean operation.
---Purpose: Returns the second argument involved in this Boolean operation.
-- Obsolete
---C++: return const &
SetTools(me:out;
theLS: ListOfShape from TopTools);
---Purpose: Sets the tools
Tools(me)
returns ListOfShape from TopTools;
---C++: return const &
---Purpose: Gets the tools
SetOperation (me:out;
anOp: Operation from BOPAlgo);
---Purpose: Sets the type of Boolean operation to perform
--- It can be BOPAlgo_SECTION
--- BOPAlgo_COMMON
--- BOPAlgo_FUSE
--- BOPAlgo_CUT
--- BOPAlgo_CUT21
---
---Purpose: Sets the type of Boolean operation
Operation (me)
returns Operation from BOPAlgo;
---Purpose: Returns the type of Boolean Operation that has been performed.
---Purpose: Returns the type of Boolean Operation
---C++: alias "Standard_EXPORT virtual ~BRepAlgoAPI_BooleanOperation();"
Build (me:out)
is redefined virtual;
---Purpose: Provides the algorithm of Boolean Operations
-- - Filling interference Data Structure (if it is necessary)
-- - Building the result of the operation.
is redefined ;
---Purpose: Performs the algorithm
-- Filling interference Data Structure (if it is necessary)
-- Building the result of the operation.
BuilderCanWork(me)
returns Boolean from Standard;
---Purpose: Returns True if there was no errors occured
-- obsolete
FuseEdges(me)
returns Boolean from Standard;
@ -112,49 +124,51 @@ is
Modified (me: in out;
aS : Shape from TopoDS)
returns ListOfShape from TopTools
is redefined virtual;
is redefined;
---Purpose: Returns the list of shapes modified from the shape <S>.
---C++: return const &
IsDeleted (me: in out;
aS : Shape from TopoDS)
returns Boolean
is redefined virtual;
is redefined;
---Purpose: Returns true if the shape S has been deleted. The
-- result shape of the operation does not contain the shape S.
Generated (me: in out;
S : Shape from TopoDS)
returns ListOfShape from TopTools
is redefined virtual;
is redefined;
---Purpose: Returns the list of shapes generated from the shape <S>.
--- For use in BRepNaming.
---C++: return const &
HasModified (me)
returns Boolean from Standard
is virtual;
is redefined;
---Purpose: Returns true if there is at least one modified shape.
--- For use in BRepNaming.
HasGenerated (me)
returns Boolean from Standard
is virtual;
is redefined;
---Purpose: Returns true if there is at least one generated shape.
--- For use in BRepNaming.
HasDeleted (me)
returns Boolean from Standard
is virtual;
is redefined;
---Purpose: Returns true if there is at least one deleted shape.
--- For use in BRepNaming.
--
-- protected
-- protected methods
--
PrepareFiller(me:out)
returns Boolean from Standard
is protected;
Clear(me:out)
is redefined protected;
SetAttributes (me:out)
is virtual protected;
RefinedList (me: in out;
theL : ListOfShape from TopTools)
@ -164,18 +178,16 @@ is
--- For use in BRepNaming.
---C++: return const &
fields
myS1 : Shape from TopoDS is protected;
myS2 : Shape from TopoDS is protected;
myTools : ListOfShape from TopTools is protected;
myOperation: Operation from BOPAlgo is protected;
--
myEntryType: Integer from Standard is protected;
myBuilderCanWork : Boolean from Standard is protected;
-- for edge refiner
myFuseEdges : Boolean from Standard ;
myModifFaces : DataMapOfShapeShape from TopTools;
myEdgeMap : DataMapOfShapeShape from TopTools;
end BooleanOperation;

449
src/BRepAlgoAPI/BRepAlgoAPI_BooleanOperation.cxx
View File

@ -16,16 +16,24 @@
#include <BRepAlgoAPI_BooleanOperation.ixx>
///XXXXXXXXXX
#include <stdio.h>
#include <TCollection_AsciiString.hxx>
#include <BRepTools.hxx>
#include <OSD_File.hxx>
//XXXXXXXXXX
#include <TopExp.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopTools_DataMapOfIntegerListOfShape.hxx>
#include <TopTools_DataMapOfIntegerShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <BRepAlgoAPI_Check.hxx>
#include <BRepAlgoAPI.hxx>
#include <BRepLib_FuseEdges.hxx>
#include <BOPDS_PDS.hxx>
@ -39,6 +47,58 @@
#include <BOPAlgo_BOP.hxx>
#include <BOPAlgo_Section.hxx>
//XXXX
//=======================================================================
//class : BRepAlgoAPI_DumpOper
//purpose :
//=======================================================================
class BRepAlgoAPI_DumpOper {
public:
BRepAlgoAPI_DumpOper() :
myIsDump(Standard_False),
myIsDumpArgs(Standard_False),
myIsDumpRes(Standard_False) {
char *pathdump = getenv("CSF_DEBUG_BOP");
myIsDump=(pathdump!=NULL);
myPath=pathdump;
};
//
virtual ~BRepAlgoAPI_DumpOper() {
};
//
Standard_Boolean IsDump()const {
return myIsDump;
};
//
void SetIsDumpArgs(const Standard_Boolean bFlag) {
myIsDumpArgs=bFlag;
}
//
Standard_Boolean IsDumpArgs()const {
return myIsDumpArgs;
};
//
void SetIsDumpRes(const Standard_Boolean bFlag) {
myIsDumpRes=bFlag;
};
//
Standard_Boolean IsDumpRes()const {
return myIsDumpRes;
};
//
void Dump(
const TopoDS_Shape& theShape1,
const TopoDS_Shape& theShape2,
const TopoDS_Shape& theResult,
BOPAlgo_Operation theOperation);
//
protected:
Standard_Boolean myIsDump;
Standard_Boolean myIsDumpArgs;
Standard_Boolean myIsDumpRes;
Standard_CString myPath;
};
//XXXX
//=======================================================================
//function : BRepAlgoAPI_BooleanOperation
//purpose :
@ -47,10 +107,24 @@ BRepAlgoAPI_BooleanOperation::BRepAlgoAPI_BooleanOperation()
:
BRepAlgoAPI_BuilderAlgo(),
myOperation(BOPAlgo_UNKNOWN),
myEntryType(1),
myBuilderCanWork(Standard_False),
myFuseEdges(Standard_False)
{
myEntryType=1;
}
//=======================================================================
//function : BRepAlgoAPI_BooleanOperation
//purpose :
//=======================================================================
BRepAlgoAPI_BooleanOperation::BRepAlgoAPI_BooleanOperation
(const BOPAlgo_PaveFiller& aPF)
:
BRepAlgoAPI_BuilderAlgo(aPF),
myOperation(BOPAlgo_UNKNOWN),
myBuilderCanWork(Standard_False),
myFuseEdges(Standard_False)
{
myEntryType=0;
}
//=======================================================================
//function : BRepAlgoAPI_BooleanOperation
@ -62,13 +136,14 @@ BRepAlgoAPI_BooleanOperation::BRepAlgoAPI_BooleanOperation
const BOPAlgo_Operation anOp)
:
BRepAlgoAPI_BuilderAlgo(),
myS1(aS1),
myS2(aS2),
myOperation(anOp),
myEntryType(1),
myBuilderCanWork(Standard_False),
myFuseEdges(Standard_False)
{
myEntryType=1;
//
myArguments.Append(aS1);
myTools.Append(aS2);
}
//=======================================================================
//function : BRepAlgoAPI_BooleanOperation
@ -80,14 +155,16 @@ BRepAlgoAPI_BooleanOperation::BRepAlgoAPI_BooleanOperation
const BOPAlgo_PaveFiller& aPF,
const BOPAlgo_Operation anOp)
:
BRepAlgoAPI_BuilderAlgo(),
myS1(aS1),
myS2(aS2),
BRepAlgoAPI_BuilderAlgo(aPF),
myOperation(anOp),
myEntryType(0),
myBuilderCanWork(Standard_False),
myFuseEdges(Standard_False)
{
myEntryType=0;
//
myArguments.Append(aS1);
myTools.Append(aS2);
//
myDSFiller=(BOPAlgo_PaveFiller*)&aPF;
}
//=======================================================================
@ -96,19 +173,37 @@ BRepAlgoAPI_BooleanOperation::BRepAlgoAPI_BooleanOperation
//=======================================================================
BRepAlgoAPI_BooleanOperation::~BRepAlgoAPI_BooleanOperation()
{
if (myBuilder) {
delete myBuilder;
myBuilder=NULL;
Clear();
}
if (myDSFiller && myEntryType) {
delete myDSFiller;
myDSFiller=NULL;
}
//
//=======================================================================
//function : Clear
//purpose :
//=======================================================================
void BRepAlgoAPI_BooleanOperation::Clear()
{
BRepAlgoAPI_BuilderAlgo::Clear();
myModifFaces.Clear();
myEdgeMap.Clear();
}
//=======================================================================
//function : SetTools
//purpose :
//=======================================================================
void BRepAlgoAPI_BooleanOperation::SetTools
(const TopTools_ListOfShape& theLS)
{
myTools=theLS;
}
//=======================================================================
//function : Tools
//purpose :
//=======================================================================
const TopTools_ListOfShape& BRepAlgoAPI_BooleanOperation::Tools()const
{
return myTools;
}
//=======================================================================
//function : SetOperation
//purpose :
//=======================================================================
@ -126,28 +221,12 @@ BOPAlgo_Operation BRepAlgoAPI_BooleanOperation::Operation ()const
return myOperation;
}
//=======================================================================
//function : SetShape1
//purpose :
//=======================================================================
void BRepAlgoAPI_BooleanOperation::SetShape1(const TopoDS_Shape& aS)
{
myS1=aS;
}
//=======================================================================
//function : SetShape2
//purpose :
//=======================================================================
void BRepAlgoAPI_BooleanOperation::SetShape2(const TopoDS_Shape& aS)
{
myS2=aS;
}
//=======================================================================
//function : Shape1
//purpose :
//=======================================================================
const TopoDS_Shape& BRepAlgoAPI_BooleanOperation::Shape1() const
{
return myS1;
return myArguments.First();
}
//=======================================================================
//function : Shape2
@ -155,7 +234,7 @@ const TopoDS_Shape& BRepAlgoAPI_BooleanOperation::Shape1() const
//=======================================================================
const TopoDS_Shape& BRepAlgoAPI_BooleanOperation::Shape2() const
{
return myS2;
return myTools.First();
}
//=======================================================================
//function : BuilderCanWork
@ -174,154 +253,159 @@ Standard_Boolean BRepAlgoAPI_BooleanOperation::FuseEdges ()const
return myFuseEdges;
}
//=======================================================================
//function : PrepareFiller
//function : SetAttributes
//purpose :
//=======================================================================
Standard_Boolean BRepAlgoAPI_BooleanOperation::PrepareFiller()
void BRepAlgoAPI_BooleanOperation::SetAttributes()
{
Standard_Boolean bIsNewFiller=Standard_False;
myErrorStatus=1;
//
if (myS1.IsNull() || myS2.IsNull()) {
myErrorStatus=2;
return bIsNewFiller;
}
//
if (myOperation==BOPAlgo_UNKNOWN) {
myErrorStatus=6;
return bIsNewFiller;
}
//
if (myDSFiller==NULL) {
bIsNewFiller=!bIsNewFiller;
myDSFiller=new BOPAlgo_PaveFiller;
//
if (myDSFiller==NULL) {
myErrorStatus=4;
return bIsNewFiller;
}
//
BOPCol_ListOfShape aLS;
aLS.Append(myS1);
aLS.Append(myS2);
//
myDSFiller->SetArguments(aLS);
myDSFiller->SetRunParallel(myRunParallel);
myDSFiller->SetProgressIndicator(myProgressIndicator);
myDSFiller->SetFuzzyValue(myFuzzyValue);
}
return bIsNewFiller;
}
//=======================================================================
//function : Build
//function : Build2
//purpose :
//=======================================================================
void BRepAlgoAPI_BooleanOperation::Build()
{
Standard_Boolean bIsNewFiller;
Standard_Integer iErr;
//
//dump arguments and result of boolean operation in tcl script
char *pathdump = getenv("CSF_DEBUG_BOP");
Standard_Boolean isDump = (pathdump != NULL),
isDumpArgs = Standard_False,
isDumpRes = Standard_False;
Standard_CString aPath = pathdump;
Standard_Integer iErr, aNbArgs, aNbTools;
BRepAlgoAPI_DumpOper aDumpOper;
//
myBuilderCanWork=Standard_False;
myErrorStatus=0;
NotDone();
//
bIsNewFiller=PrepareFiller();
//
if (myErrorStatus!=1) {
// there was errors during the preparation
aNbArgs=myArguments.Extent();
aNbTools=myTools.Extent();
if (aNbArgs<1 && aNbTools<1) {
myErrorStatus=2;
return;
}
if (myOperation==BOPAlgo_UNKNOWN) {
myErrorStatus=6;
return;
}
//
if (bIsNewFiller) {
//Prepare the DS
//-----------------------------------------------
TopTools_ListOfShape aLS;
TopTools_ListIteratorOfListOfShape aIt;
//
aIt.Initialize(myArguments);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS = aIt.Value();
aLS.Append(aS);
}
aIt.Initialize(myTools);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS = aIt.Value();
aLS.Append(aS);
}
//-----------------------------------------------
//
if (myEntryType) {
if (myDSFiller) {
delete myDSFiller;
}
myDSFiller=new BOPAlgo_PaveFiller(myAllocator);
//
myDSFiller->SetArguments(aLS);
//
myDSFiller->SetRunParallel(myRunParallel);
myDSFiller->SetProgressIndicator(myProgressIndicator);
myDSFiller->SetFuzzyValue(myFuzzyValue);
//
SetAttributes();
//
myDSFiller->Perform();
iErr=myDSFiller->ErrorStatus();
if (iErr) {
myErrorStatus=100+iErr;
return;
}
}// if (myEntryType) {
//
if (myBuilder!=NULL) {
delete myBuilder;
myBuilder=NULL;
}
//
const TopoDS_Shape& aS1 = myS1;
const TopoDS_Shape& aS2 = myS2;
//
if (isDump) {
//XXXX
const TopoDS_Shape& aS1 = myArguments.First();
const TopoDS_Shape& aS2 = myTools.First();
if (aDumpOper.IsDump()) {
BRepAlgoAPI_Check aChekArgs(aS1, aS2, myOperation);
isDumpArgs = !aChekArgs.IsValid();
aDumpOper.SetIsDumpArgs(!aChekArgs.IsValid());
}
//XXXX
//
if (myBuilder) {
delete myBuilder;
}
//
myShape.Nullify();
//
if (myOperation==BOPAlgo_SECTION) {
myBuilder=new BOPAlgo_Section;
myBuilder->AddArgument(aS1);
myBuilder->AddArgument(aS2);
}
else {
BOPAlgo_BOP *pBOP;
//
pBOP=new BOPAlgo_BOP;
myBuilder=pBOP;
pBOP->AddArgument(aS1);
pBOP->AddTool(aS2);
if(myOperation==BOPAlgo_SECTION) {
myBuilder=new BOPAlgo_Section(myAllocator);
myBuilder->SetArguments(aLS);
}
else{
pBOP=new BOPAlgo_BOP(myAllocator);
pBOP->SetArguments(myArguments);
pBOP->SetTools(myTools);
pBOP->SetOperation(myOperation);
myBuilder=pBOP;
}
//
myBuilder->SetRunParallel(myRunParallel);
myBuilder->SetProgressIndicator(myProgressIndicator);
//
myBuilder->PerformWithFiller(*myDSFiller);
iErr = myBuilder->ErrorStatus();
if (!iErr) {
myErrorStatus=0;
myBuilderCanWork=Standard_True;
if (iErr) {
myErrorStatus=200+iErr;
return;
}
//
myShape=myBuilder->Shape();
//
if (isDump) {
BRepAlgoAPI_Check aCheckRes(myShape);
isDumpRes = !aCheckRes.IsValid();
if (isDumpArgs || isDumpRes) {
BRepAlgoAPI::DumpOper(aPath,
aS1,
aS2,
myShape,
myOperation,
isDumpArgs);
}
}
//
myBuilderCanWork=Standard_True;
Done();
//
//XXXX
if (aDumpOper.IsDump()) {
BRepAlgoAPI_Check aCheckRes(myShape);
aDumpOper.SetIsDumpRes(!aCheckRes.IsValid());
aDumpOper.Dump(aS1, aS2, myShape,myOperation);
}
else {
myErrorStatus=100+iErr;
NotDone();
//XXXX
}
}
//=======================================================================
//function : RefineEdges
//purpose :
//=======================================================================
void BRepAlgoAPI_BooleanOperation::RefineEdges ()
{
if(myFuseEdges) return; //Edges have been refined yet
if(myFuseEdges) {
return; //Edges have been refined
}
//
TopTools_IndexedMapOfShape mapOldEdges;
TopTools_ListOfShape aLS;
TopTools_ListIteratorOfListOfShape aIt;
//
aIt.Initialize(myArguments);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS = aIt.Value();
aLS.Append(aS);
}
aIt.Initialize(myTools);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS = aIt.Value();
aLS.Append(aS);
}
//
aIt.Initialize(aLS);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS = aIt.Value();
TopExp::MapShapes (aS, TopAbs_EDGE, mapOldEdges);
}
//----------------------------------------------
BRepLib_FuseEdges FE(myShape);
FE.SetConcatBSpl(Standard_True);
// avoid fusing old edges
TopTools_IndexedMapOfShape mapOldEdges;
TopExp::MapShapes (myS1, TopAbs_EDGE, mapOldEdges);
TopExp::MapShapes (myS2, TopAbs_EDGE, mapOldEdges);
FE.AvoidEdges (mapOldEdges);
//
// Get List of edges that have been fused
myFuseEdges = Standard_False;
myModifFaces.Clear();
@ -529,3 +613,90 @@ Standard_Boolean BRepAlgoAPI_BooleanOperation::HasDeleted() const
}
return myBuilder->HasDeleted();
}
//XXXX
//=======================================================================
//function : Dump
//purpose :
//=======================================================================
void BRepAlgoAPI_DumpOper::Dump (const TopoDS_Shape& theShape1,
const TopoDS_Shape& theShape2,
const TopoDS_Shape& theResult,
BOPAlgo_Operation theOperation)
{
if (!(myIsDumpArgs && myIsDumpRes)) {
return;
}
//
TCollection_AsciiString aPath(myPath);
aPath += "/";
Standard_Integer aNumOper = 1;
Standard_Boolean isExist = Standard_True;
TCollection_AsciiString aFileName;
while(isExist)
{
aFileName = aPath + "BO_" + TCollection_AsciiString(aNumOper) +".tcl";
OSD_File aScript(aFileName);
isExist = aScript.Exists();
if(isExist)
aNumOper++;
}
FILE* afile = fopen(aFileName.ToCString(), "w+");
if(!afile)
return;
if(myIsDumpArgs)
fprintf(afile,"%s\n","# Arguments are invalid");
TCollection_AsciiString aName1;
TCollection_AsciiString aName2;
TCollection_AsciiString aNameRes;
if(!theShape1.IsNull())
{
aName1 = aPath +
"Arg1_" + TCollection_AsciiString(aNumOper) + ".brep";
BRepTools::Write(theShape1, aName1.ToCString());
}
else
fprintf(afile,"%s\n","# First argument is Null ");
if(!theShape2.IsNull())
{
aName2 = aPath +
"Arg2_"+ TCollection_AsciiString(aNumOper) + ".brep";
BRepTools::Write(theShape2, aName2.ToCString());
}
else
fprintf(afile,"%s\n","# Second argument is Null ");
if(!theResult.IsNull())
{
aNameRes = aPath +
"Result_"+ TCollection_AsciiString(aNumOper) + ".brep";
BRepTools::Write(theResult, aNameRes.ToCString());
}
else
fprintf(afile,"%s\n","# Result is Null ");
fprintf(afile, "%s %s %s\n","restore", aName1.ToCString(), "arg1");
fprintf(afile, "%s %s %s\n","restore", aName2.ToCString(), "arg2");;
TCollection_AsciiString aBopString;
switch (theOperation)
{
case BOPAlgo_COMMON : aBopString += "bcommon Res "; break;
case BOPAlgo_FUSE : aBopString += "bfuse Res "; break;
case BOPAlgo_CUT :
case BOPAlgo_CUT21 : aBopString += "bcut Res "; break;
case BOPAlgo_SECTION : aBopString += "bsection Res "; break;
default : break;
};
aBopString += ("arg1 arg2");
if(theOperation == BOPAlgo_CUT21)
aBopString += " 1";
fprintf(afile, "%s\n",aBopString.ToCString());
fclose(afile);
}
//XXXX

80
src/BRepAlgoAPI/BRepAlgoAPI_BuilderAlgo.cdl
View File

@ -12,24 +12,31 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
deferred class BuilderAlgo from BRepAlgoAPI
class BuilderAlgo from BRepAlgoAPI
inherits Algo from BRepAlgoAPI
---Purpose: provides the root interface for algorithms
---Purpose:
-- The clsss contains API level of General Fuse algorithm
uses
BaseAllocator from BOPCol,
Shape from TopoDS,
ListOfShape from TopTools,
--
PPaveFiller from BOPAlgo,
PaveFiller from BOPAlgo,
PBuilder from BOPAlgo
--raises
is
Initialize
Create
returns BuilderAlgo from BRepAlgoAPI;
---Purpose: Empty constructor
---C++: alias "Standard_EXPORT virtual ~BRepAlgoAPI_BuilderAlgo();"
Initialize (theAllocator: BaseAllocator from BOPCol)
Create(thePF :PaveFiller from BOPAlgo)
returns BuilderAlgo from BRepAlgoAPI;
---Purpose: Empty constructor
SetFuzzyValue(me:out;
theFuzz : Real from Standard);
@ -39,9 +46,70 @@ is
returns Real from Standard;
---Purpose: Returns the additional tolerance
SetArguments(me:out;
theLS: ListOfShape from TopTools);
---Purpose: Sets the arguments
Arguments(me)
returns ListOfShape from TopTools;
---C++: return const &
---Purpose: Gets the arguments
Build (me:out)
is redefined virtual;
---Purpose: Performs the algorithm
--
-- H I S T O R Y
--
Modified (me: in out;
aS : Shape from TopoDS)
returns ListOfShape from TopTools
is redefined virtual;
---Purpose: Returns the list of shapes modified from the shape <S>.
---C++: return const &
IsDeleted (me: in out;
aS : Shape from TopoDS)
returns Boolean
is redefined virtual;
---Purpose: Returns true if the shape S has been deleted. The
-- result shape of the operation does not contain the shape S.
Generated (me: in out;
S : Shape from TopoDS)
returns ListOfShape from TopTools
is redefined virtual;
---Purpose: Returns the list of shapes generated from the shape <S>.
--- For use in BRepNaming.
---C++: return const &
HasModified (me)
returns Boolean from Standard
is virtual;
---Purpose: Returns true if there is at least one modified shape.
--- For use in BRepNaming.
HasGenerated (me)
returns Boolean from Standard
is virtual;
---Purpose: Returns true if there is at least one generated shape.
--- For use in BRepNaming.
HasDeleted (me)
returns Boolean from Standard
is virtual;
---Purpose: Returns true if there is at least one deleted shape.
--- For use in BRepNaming.
--
-- protected methods
--
Clear(me:out)
is redefined protected;
fields
myEntryType : Integer from Standard is protected;
myDSFiller : PPaveFiller from BOPAlgo is protected;
myBuilder : PBuilder from BOPAlgo is protected;
myFuzzyValue : Real from Standard is protected;
myArguments : ListOfShape from TopTools is protected;
end BuilderAlgo;

174
src/BRepAlgoAPI/BRepAlgoAPI_BuilderAlgo.cxx
View File

@ -14,7 +14,8 @@
#include <BRepAlgoAPI_BuilderAlgo.ixx>
#include <NCollection_BaseAllocator.hxx>
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPAlgo_Builder.hxx>
//=======================================================================
// function:
@ -23,6 +24,7 @@
BRepAlgoAPI_BuilderAlgo::BRepAlgoAPI_BuilderAlgo()
:
BRepAlgoAPI_Algo(),
myEntryType(1),
myDSFiller(NULL),
myBuilder(NULL),
myFuzzyValue(0.)
@ -32,20 +34,23 @@ BRepAlgoAPI_BuilderAlgo::BRepAlgoAPI_BuilderAlgo()
// purpose:
//=======================================================================
BRepAlgoAPI_BuilderAlgo::BRepAlgoAPI_BuilderAlgo
(const Handle(NCollection_BaseAllocator)& theAllocator)
(const BOPAlgo_PaveFiller& aPF)
:
BRepAlgoAPI_Algo(theAllocator),
myDSFiller(NULL),
BRepAlgoAPI_Algo(),
myEntryType(0),
myBuilder(NULL),
myFuzzyValue(0.)
{}
{
BOPAlgo_PaveFiller* pPF=(BOPAlgo_PaveFiller*)&aPF;
myDSFiller=pPF;
}
//=======================================================================
// function: ~
// purpose:
//=======================================================================
BRepAlgoAPI_BuilderAlgo::~BRepAlgoAPI_BuilderAlgo()
{
Clear();
}
//=======================================================================
//function : SetFuzzyValue
@ -65,3 +70,160 @@ Standard_Real BRepAlgoAPI_BuilderAlgo::FuzzyValue() const
{
return myFuzzyValue;
}
//=======================================================================
//function : Clear
//purpose :
//=======================================================================
void BRepAlgoAPI_BuilderAlgo::Clear()
{
if (myDSFiller && myEntryType) {
delete myDSFiller;
myDSFiller=NULL;
}
if (myBuilder) {
delete myBuilder;
myBuilder=NULL;
}
}
//=======================================================================
//function : SetArguments
//purpose :
//=======================================================================
void BRepAlgoAPI_BuilderAlgo::SetArguments
(const TopTools_ListOfShape& theLS)
{
myArguments=theLS;
}
//=======================================================================
//function : Arguments
//purpose :
//=======================================================================
const TopTools_ListOfShape& BRepAlgoAPI_BuilderAlgo::Arguments()const
{
return myArguments;
}
//=======================================================================
//function : Build
//purpose :
//=======================================================================
void BRepAlgoAPI_BuilderAlgo::Build()
{
Standard_Integer iErr;
//
NotDone();
myErrorStatus=0;
//
Clear();
//
if (myEntryType) {
if (myDSFiller) {
delete myDSFiller;
}
myDSFiller=new BOPAlgo_PaveFiller(myAllocator);
//
myDSFiller->SetArguments(myArguments);
//
myDSFiller->SetRunParallel(myRunParallel);
myDSFiller->SetProgressIndicator(myProgressIndicator);
myDSFiller->SetFuzzyValue(myFuzzyValue);
//
myDSFiller->Perform();
iErr=myDSFiller->ErrorStatus();
if (iErr) {
myErrorStatus=100+iErr;
}
}// if (myEntryType) {
//
if (myBuilder) {
delete myBuilder;
}
myBuilder=new BOPAlgo_Builder(myAllocator);
//
myBuilder->SetArguments(myArguments);
//
myBuilder->SetRunParallel(myRunParallel);
myBuilder->SetProgressIndicator(myProgressIndicator);
//
myBuilder->PerformWithFiller(*myDSFiller);
iErr=myBuilder->ErrorStatus();
if (iErr) {
myErrorStatus=200+iErr;
}
//
Done();
myShape=myBuilder->Shape();
}
//=======================================================================
//function : Generated
//purpose :
//=======================================================================
const TopTools_ListOfShape& BRepAlgoAPI_BuilderAlgo::Generated
(const TopoDS_Shape& aS)
{
if (myBuilder==NULL) {
myGenerated.Clear();
return myGenerated;
}
myGenerated = myBuilder->Generated(aS);
return myGenerated;
}
//=======================================================================
//function : Modified
//purpose :
//=======================================================================
const TopTools_ListOfShape& BRepAlgoAPI_BuilderAlgo::Modified
(const TopoDS_Shape& aS)
{
if (myBuilder==NULL) {
myGenerated.Clear();
return myGenerated;
}
myGenerated = myBuilder->Modified(aS);
return myGenerated;
}
//=======================================================================
//function : IsDeleted
//purpose :
//=======================================================================
Standard_Boolean BRepAlgoAPI_BuilderAlgo::IsDeleted
(const TopoDS_Shape& aS)
{
Standard_Boolean bDeleted = Standard_True;
if (myBuilder != NULL) {
bDeleted=myBuilder->IsDeleted(aS);
}
return bDeleted;
}
//=======================================================================
//function : HasModified
//purpose :
//=======================================================================
Standard_Boolean BRepAlgoAPI_BuilderAlgo::HasModified() const
{
if (myBuilder==NULL) {
return Standard_False;
}
return myBuilder->HasModified();
}
//=======================================================================
//function : HasGenerated
//purpose :
//=======================================================================
Standard_Boolean BRepAlgoAPI_BuilderAlgo::HasGenerated() const
{
if (myBuilder==NULL) {
return Standard_False;
}
return myBuilder->HasGenerated();
}
//=======================================================================
//function : HasDeleted
//purpose :
//=======================================================================
Standard_Boolean BRepAlgoAPI_BuilderAlgo::HasDeleted() const
{
if (myBuilder==NULL) {
return Standard_False;
}
return myBuilder->HasDeleted();
}

32
src/BRepAlgoAPI/BRepAlgoAPI_Common.cdl
View File

@ -17,12 +17,9 @@
class Common from BRepAlgoAPI
inherits BooleanOperation from BRepAlgoAPI
---Purpose: The class Common provides a
-- Boolean common operation on a pair of arguments (Boolean Intersection).
-- The class Common provides a framework for:
-- - Defining the construction of a common shape;
-- - Implementing the building algorithm
-- - Consulting the result.
---Purpose:
-- The class provides Boolean common operation
-- between arguments and tools (Boolean Intersection).
uses
Shape from TopoDS,
@ -34,14 +31,29 @@ is
---C++: alias "Standard_EXPORT virtual ~BRepAlgoAPI_Common();"
--- Purpose: Empty constructor
Create (PF: PaveFiller from BOPAlgo)
returns Common from BRepAlgoAPI;
--- Purpose: Empty constructor
-- <PF> - PaveFiller object that is carried out
Create (S1,S2 : Shape from TopoDS)
returns Common from BRepAlgoAPI;
---Purpose: Constructs a common part for shapes aS1 and aS2 .
---Purpose: Constructor with two shapes
-- <S1> -argument
-- <S2> -tool
-- <anOperation> - the type of the operation
-- Obsolete
Create (S1,S2 : Shape from TopoDS;
aDSF:PaveFiller from BOPAlgo)
Create (S1: Shape from TopoDS;
S2: Shape from TopoDS;
PF: PaveFiller from BOPAlgo)
returns Common from BRepAlgoAPI;
--- Purpose: Constructs a common part for shapes aS1 and aS2 using aDSFiller
---Purpose: Constructor with two shapes
-- <S1> -argument
-- <S2> -tool
-- <anOperation> - the type of the operation
-- <PF> - PaveFiller object that is carried out
-- Obsolete
end Common;

10
src/BRepAlgoAPI/BRepAlgoAPI_Common.cxx
View File

@ -29,6 +29,16 @@ BRepAlgoAPI_Common::BRepAlgoAPI_Common()
myOperation=BOPAlgo_COMMON;
}
//=======================================================================
//function : BRepAlgoAPI_Common
//purpose :
//=======================================================================
BRepAlgoAPI_Common::BRepAlgoAPI_Common(const BOPAlgo_PaveFiller& aPF)
:
BRepAlgoAPI_BooleanOperation(aPF)
{
myOperation=BOPAlgo_COMMON;
}
//=======================================================================
//function : ~BRepAlgoAPI_Common
//purpose :
//=======================================================================

31
src/BRepAlgoAPI/BRepAlgoAPI_Cut.cdl
View File

@ -16,12 +16,10 @@
class Cut from BRepAlgoAPI
inherits BooleanOperation from BRepAlgoAPI
---Purpose: The class Cut provides a Boolean
-- cut operation on a pair of arguments (Boolean Subtraction).
-- The class Cut provides a framework for:
-- - Defining the construction of a cut shape
-- - Implementing the building algorithm
-- - Consulting the result
---Purpose:
-- The class Cut provides Boolean cut operation
-- between arguments and tools (Boolean Subtraction).
uses
Shape from TopoDS,
@ -34,19 +32,28 @@ is
---C++: alias "Standard_EXPORT virtual ~BRepAlgoAPI_Cut();"
--- Purpose: Empty constructor
Create (PF: PaveFiller from BOPAlgo)
returns Cut from BRepAlgoAPI;
--- Purpose: Empty constructor
-- <PF> - PaveFiller object that is carried out
Create (S1,S2 : Shape from TopoDS)
returns Cut from BRepAlgoAPI;
---Purpose: Shape aS2 cuts shape aS1. The
-- resulting shape is a new shape produced by the cut operation.
---Purpose: Constructor with two shapes
-- <S1> -argument
-- <S2> -tool
-- <anOperation> - the type of the operation
-- Obsolete
Create (S1,S2 : Shape from TopoDS;
aDSF : PaveFiller from BOPAlgo;
bFWD : Boolean from Standard=Standard_True)
returns Cut from BRepAlgoAPI;
--- Purpose: Constructs a new shape cut from
-- shape aS1 by shape aS2 using aDSFiller (see
-- BRepAlgoAPI_BooleanOperation Constructor).
---Purpose: Constructor with two shapes
-- <S1> -argument
-- <S2> -tool
-- <anOperation> - the type of the operation
-- <PF> - PaveFiller object that is carried out
-- Obsolete
end Cut;

14
src/BRepAlgoAPI/BRepAlgoAPI_Cut.cxx
View File

@ -29,13 +29,22 @@ BRepAlgoAPI_Cut::BRepAlgoAPI_Cut()
myOperation=BOPAlgo_CUT;
}
//=======================================================================
//function : BRepAlgoAPI_Cut
//purpose :
//=======================================================================
BRepAlgoAPI_Cut::BRepAlgoAPI_Cut(const BOPAlgo_PaveFiller& aPF)
:
BRepAlgoAPI_BooleanOperation(aPF)
{
myOperation=BOPAlgo_CUT;
}
//=======================================================================
//function : ~BRepAlgoAPI_Cut
//purpose :
//=======================================================================
BRepAlgoAPI_Cut::~BRepAlgoAPI_Cut()
{
}
//=======================================================================
//function : BRepAlgoAPI_Cut
//purpose :
@ -58,7 +67,8 @@ BRepAlgoAPI_Cut::BRepAlgoAPI_Cut(const TopoDS_Shape& S1,
const BOPAlgo_PaveFiller& aDSF,
const Standard_Boolean bFWD)
:
BRepAlgoAPI_BooleanOperation(S1, S2, aDSF, (bFWD) ? BOPAlgo_CUT : BOPAlgo_CUT21)
BRepAlgoAPI_BooleanOperation(S1, S2, aDSF,
(bFWD) ? BOPAlgo_CUT : BOPAlgo_CUT21)
{
BRepAlgoAPI_BooleanOperation* pBO=
(BRepAlgoAPI_BooleanOperation*) (void*) this;

30
src/BRepAlgoAPI/BRepAlgoAPI_Fuse.cdl
View File

@ -14,14 +14,12 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class Fuse from BRepAlgoAPI inherits BooleanOperation from BRepAlgoAPI
class Fuse from BRepAlgoAPI
inherits BooleanOperation from BRepAlgoAPI
---Purpose: The class Fuse provides a
-- Boolean fusion operation on a pair of arguments (Boolean Union).
-- The class Fuse provides a framework for:
-- - Defining the construction of a fused shape;
-- - Implementing the building algorithm
-- - Consulting the result.
---Purpose:
-- The class provides Boolean fusion operation
-- between arguments and tools (Boolean Union).
uses
Shape from TopoDS,
@ -34,13 +32,27 @@ is
---C++: alias "Standard_EXPORT virtual ~BRepAlgoAPI_Fuse();"
--- Purpose: Empty constructor
Create (PF: PaveFiller from BOPAlgo)
returns Fuse from BRepAlgoAPI;
--- Purpose: Empty constructor
-- <PF> - PaveFiller object that is carried out
Create (S1,S2 : Shape from TopoDS)
returns Fuse from BRepAlgoAPI;
---Purpose: Constructs a fuse of shapes aS1 and aS2.
---Purpose: Constructor with two shapes
-- <S1> -argument
-- <S2> -tool
-- <anOperation> - the type of the operation
-- Obsolete
Create (S1,S2 : Shape from TopoDS;
aDSF:PaveFiller from BOPAlgo)
returns Fuse from BRepAlgoAPI;
---Purpose: Constructs a new shape that is a fuse of shapes aS1 and aS2 using aDSFiller.
---Purpose: Constructor with two shapes
-- <S1> -argument
-- <S2> -tool
-- <anOperation> - the type of the operation
-- <PF> - PaveFiller object that is carried out
-- Obsolete
end Fuse;

12
src/BRepAlgoAPI/BRepAlgoAPI_Fuse.cxx
View File

@ -29,13 +29,22 @@ BRepAlgoAPI_Fuse::BRepAlgoAPI_Fuse()
myOperation=BOPAlgo_FUSE;
}
//=======================================================================
//function : BRepAlgoAPI_Fuse
//purpose :
//=======================================================================
BRepAlgoAPI_Fuse::BRepAlgoAPI_Fuse(const BOPAlgo_PaveFiller& aPF)
:
BRepAlgoAPI_BooleanOperation(aPF)
{
myOperation=BOPAlgo_FUSE;
}
//=======================================================================
//function : ~BRepAlgoAPI_Fuse
//purpose :
//=======================================================================
BRepAlgoAPI_Fuse::~BRepAlgoAPI_Fuse()
{
}
//=======================================================================
//function : BRepAlgoAPI_Fuse
//purpose :
@ -49,7 +58,6 @@ BRepAlgoAPI_Fuse::BRepAlgoAPI_Fuse(const TopoDS_Shape& S1,
(BRepAlgoAPI_BooleanOperation*) (void*) this;
pBO->Build();
}
//=======================================================================
//function : BRepAlgoAPI_Fuse
//purpose :

353
src/BRepAlgoAPI/BRepAlgoAPI_Section.cdl
View File

@ -19,29 +19,47 @@
class Section from BRepAlgoAPI
inherits BooleanOperation from BRepAlgoAPI
---Purpose: Computes the intersection of two shapes or geometries.
-- Geometries can be surfaces of planes.
-- Geometries are converted to faces
-- When a geometry has been converted to
-- topology the created shape can be found using
-- the methods Shape1 and Shape2 inherited from the class BooleanOperation.
-- The result (Shape() method) is a compound containing
-- edges built on intersection curves.
-- By default, the section is performed immediatly in
-- class constructors, with default values :
---Purpose:
-- The algorithm is to build a Secton operation between arguments and tools.
-- The result of Section operation consists of vertices and edges.
-- The result of Section operation contains:
-- 1. new vertices that are subjects of V/V, E/E, E/F, F/F interferences
-- 2. vertices that are subjects of V/E, V/F interferences
-- 3. new edges that are subjects of F/F interferences
-- 4. edges that are Common Blocks
-- The vertex is included in Section only when it is not shared
-- between the edges above
-- --
-- Default values:
-- - geometries built are NOT approximated.
-- - PCurves are NOT computed on both parts.
-- Example : giving two shapes S1,S2 accessing faces,
-- let compute the section edges R on S1,S2,
-- performing approximation on new curves,
-- performing PCurve on part 1 but not on part 2 :
-- Standard_Boolean PerformNow = Standard_False;
-- BRepBoolAPI_Section S(S1,S2,PerformNow);
-- S.ComputePCurveOn1(Standard_True);
-- S.Approximation(Standard_True);
-- S.Build();
-- TopoDS_Shape R = S.Shape();
-- On Null Shapes of geometries, NotDone() is called.
-- Example of use:
-- Standard_Boolean bRunParallel;
-- Standard_Integer iErr;
-- BRepAlgoAPI_Section aSection;
-- //
-- bRunParallel=...; // turn parallelism on/off
-- const TopTools_ListOfShape& aLS=...; // Arguments
-- const TopTools_ListOfShape& aLT=...; // Tools
-- //
-- aSection.SetRunParallel();
-- aSection.SetArguments(aLS);
-- aSection.SetTools(aLT);
-- aSection.Approximation(Standard_True);
-- //
-- aSection.Build(); // perform the algorithm
-- iErr=pBuilder->ErrorStatus();
-- if (iErr) {
-- // errors occured
-- return 0;
-- }
-- //
-- const TopoDS_Shape& aR=aSection.Shape();// the result
-- //...
uses
Pln from gp,
@ -49,7 +67,9 @@ uses
Surface from Geom,
Curve from Geom2d,
PaveFiller from BOPAlgo,
ListOfShape from TopTools
Operation from BOPAlgo,
ListOfShape from TopTools,
BaseAllocator from BOPCol
is
Create
@ -57,256 +77,178 @@ is
---C++: alias "Standard_EXPORT virtual ~BRepAlgoAPI_Section();"
--- Purpose: Empty constructor
Create (PF: PaveFiller from BOPAlgo)
returns Section from BRepAlgoAPI;
--- Purpose: Empty constructor
-- <PF> - PaveFiller object that is carried out
Create (S1,S2 : Shape from TopoDS;
Create(S1 : Shape from TopoDS;
S2 : Shape from TopoDS;
PerformNow : Boolean = Standard_True)
returns Section from BRepAlgoAPI;
---Purpose: Constructor with two shapes
-- <S1> -argument
-- <S2> -tool
-- <PerformNow> - the flag:
-- if <PerformNow>=True - the algorithm is performed immediatly
-- Obsolete
Create (S1 : Shape from TopoDS;
S2 : Shape from TopoDS;
aDSF:PaveFiller from BOPAlgo;
PerformNow : Boolean = Standard_True)
returns Section from BRepAlgoAPI;
---Purpose: Constructor with two shapes
-- <S1> -argument
-- <S2> -tool
-- <PF> - PaveFiller object that is carried out
-- <PerformNow> - the flag:
-- if <PerformNow>=True - the algorithm is performed immediatly
-- Obsolete
Create(Sh1,Sh2 : Shape from TopoDS;
PerformNow : Boolean = Standard_True)
returns Section from BRepAlgoAPI;
---Purpose: see upper
---Level: Public
Create(Sh : Shape from TopoDS;
Create(S1 : Shape from TopoDS;
Pl : Pln from gp;
PerformNow : Boolean = Standard_True)
returns Section from BRepAlgoAPI;
---Purpose: see upper
---Level: Public
---Purpose: Constructor with two shapes
-- <S1> - argument
-- <Pl> - tool
-- <PerformNow> - the flag:
-- if <PerformNow>=True - the algorithm is performed immediatly
-- Obsolete
Create(Sh : Shape from TopoDS;
Create(S1 : Shape from TopoDS;
Sf : Surface from Geom;
PerformNow : Boolean = Standard_True)
returns Section from BRepAlgoAPI;
---Purpose: see upper
---Level: Public
---Purpose: Constructor with two shapes
-- <S1> - argument
-- <Sf> - tool
-- <PerformNow> - the flag:
-- if <PerformNow>=True - the algorithm is performed immediatly
-- Obsolete
Create(Sf : Surface from Geom;
Sh : Shape from TopoDS;
S2 : Shape from TopoDS;
PerformNow : Boolean = Standard_True)
returns Section from BRepAlgoAPI;
---Purpose: see upper
---Level: Public
---Purpose: Constructor with two shapes
-- <Sf> - argument
-- <S2> - tool
-- <PerformNow> - the flag:
-- if <PerformNow>=True - the algorithm is performed immediatly
-- Obsolete
Create(Sf1 : Surface from Geom;
Sf2 : Surface from Geom;
PerformNow : Boolean = Standard_True)
returns Section from BRepAlgoAPI;
---Purpose: This and the above classes construct a framework for
-- computing the section lines of:
-- - two shapes Sh1 and Sh2, or
-- - shape Sh and plane Pl, or
-- - shape Sh and surface Sf, or
-- - surface Sf and shape Sh, or
-- - two surfaces Sf1 and Sf2,
-- and builds a result if PerformNow equals true, its
-- default value. If PerformNow equals false, the intersection
-- will be computed later by the function Build.
-- The constructed shape will be returned by the function Shape.
-- This is a compound object composed of edges. These
-- intersection edges may be built:
-- - on new intersection lines, or
-- - on coincident portions of edges in the two intersected shapes.
-- These intersection edges are independent: they are not
-- chained or grouped in wires. If no intersection edge exists, the
-- result is an empty compound object.
-- Note that other objects than TopoDS_Shape shapes involved in
-- these syntaxes are converted into faces or shells before
-- performing the computation of the intersection. A shape
-- resulting from this conversion can be retrieved with the
-- function Shape1 or Shape2.
-- Parametric 2D curves on intersection edges
-- No parametric 2D curve (pcurve) is defined for each elementary
-- edge of the result. To attach such parametric curves to the
-- constructed edges you may use a constructor with the PerformNow
-- flag equal to false; then you use:
-- - the function ComputePCurveOn1 to ask for
-- the additional computation of a pcurve in the parametric
-- space of the first shape,
-- - the function ComputePCurveOn2 to ask for
-- the additional computation of a pcurve in the parametric
-- space of the second shape, in the end,
-- - the function Build to construct the result.
-- Approximation of intersection edges
-- The underlying 3D geometry attached to each elementary edge
-- of the result is:
-- - analytic where possible, provided the corresponding
-- geometry corresponds to a type of analytic curve
-- defined in the Geom package; for example, the intersection
-- of a cylindrical shape with a plane gives an ellipse or a circle;
-- - or elsewhere, given as a succession of points grouped
-- together in a BSpline curve of degree 1.
-- If you prefer to have an attached 3D geometry which is a
-- BSpline approximation of the computed set of points on
-- computed elementary intersection edges whose underlying geometry
-- is not analytic, you may use a constructor with the PerformNow
-- flag equal to false. Then you use:
-- - the function Approximation to ask for this
-- computation option, and
-- - the function Build to construct the result.
-- - Note that as a result, approximations will only be
-- computed on edges built on new intersection lines.
-- - Example
-- You may also combine these computation options. In the following example:
-- - each elementary edge of the computed intersection,
-- built on a new intersection line, which does not
-- correspond to an analytic Geom curve, will be approximated by
-- a BSpline curve whose degree is not greater than 8.
-- - each elementary edge built on a new intersection line, will have:
-- - a pcurve in the parametric space of the intersected face of shape S1,
-- - no pcurve in the parametric space of the intersected face of shape S2.
-- // TopoDS_Shape S1 = ... , S2 = ... ;
-- Standard_Boolean PerformNow = Standard_False;
-- BRepAlgoAPI_Section S ( S1, S2, PerformNow );
-- S.ComputePCurveOn1 (Standard_True);
-- S.Approximation (Standard_True);
-- S.Build();
-- TopoDS_Shape R = S.Shape();
---Purpose:
---Purpose: Constructor with two shapes
-- <Sf1> - argument
-- <Sf2> - tool
-- <PerformNow> - the flag:
-- if <PerformNow>=True - the algorithm is performed immediatly
-- Obsolete
Init1(me : out;
S1 : Shape from TopoDS);
---Purpose: initialize first part
---Level: Public
---Purpose: initialize the argument
-- <S1> - argument
-- Obsolete
Init1(me : out;
Pl : Pln from gp);
---Purpose: initialize first part
---Level: Public
---Purpose: initialize the argument
-- <Pl> - argument
-- Obsolete
Init1(me : out;
Sf : Surface from Geom);
---Purpose: initialize first part
---Level: Public
---Purpose: initialize the argument
-- <Sf> - argument
-- Obsolete
Init2(me : out;
S2 : Shape from TopoDS);
---Purpose: initialize second part
---Level: Public
---Purpose: initialize the tool
-- <S2> - tool
-- Obsolete
Init2(me : out;
Pl : Pln from gp);
---Purpose: initialize second part
---Level: Public
---Purpose: initialize the tool
-- <Pl> - tool
-- Obsolete
Init2(me : out;
Sf : Surface from Geom);
---Purpose: Reinitializes the first and the
-- second parts on which this algorithm is going to perform
-- the intersection computation. This is done with either: the
-- surface Sf, the plane Pl or the shape Sh.
-- You use the function Build to construct the result.
---Purpose: initialize the tool
-- <Sf> - tool
-- Obsolete
Approximation(me : out;
B : Boolean from Standard);
---Level: Public
---Purpose: Defines an option for computation
-- of further intersections. This computation will be performed by
-- the function Build in this framework.
---Purpose:
--Defines an option for computation
-- of further intersections.
-- By default, the underlying 3D geometry attached to each
-- elementary edge of the result of a computed intersection is:
-- elementary edge of the result is:
-- - analytic where possible, provided the corresponding
-- geometry corresponds to a type of analytic curve defined in
-- the Geom package; for example the intersection of a
-- cylindrical shape with a plane gives an ellipse or a circle;
-- - or elsewhere, given as a succession of points grouped
-- together in a BSpline curve of degree 1. If Approx equals
-- true, when further computations are performed in this framework
-- with the function Build, these edges will have an attached 3D
-- together in a BSpline curve of degree 1.
-- If Approx equals true, these edges will have an attached 3D
-- geometry which is a BSpline approximation of the computed
-- set of points.
-- Note that as a result, approximations will be computed
-- on edges built only on new intersection lines.
-- on edges built only on new intersection curves.
ComputePCurveOn1(me : out;
B : Boolean from Standard);
---Level: Public
---Purpose:
-- Indicates if the Pcurve must be (or not) performed on first part.
-- Indicates whether the P-Curve should be (or not)
-- performed on the argument.
-- By default, no parametric 2D curve (pcurve) is defined for the
-- edges of the result.
-- If ComputePCurve1 equals true, further computations performed
-- to attach an P-Curve in the parametric space of the argument
-- to the constructed edges.
-- Obsolete
ComputePCurveOn2(me : out;
B : Boolean from Standard);
---Level: Public
---Purpose: Define options for the computation of further
-- intersections, which will be performed by the function Build
-- in this framework.
---Purpose:
-- Indicates whether the P-Curve should be (or not)
-- performed on the tool.
-- By default, no parametric 2D curve (pcurve) is defined for the
-- elementary edges of the result. If ComputePCurve1 equals true,
-- further computations performed in this framework with the function
-- Build will attach an additional pcurve in the parametric space of
-- the first shape to the constructed edges.
-- If ComputePCurve2 equals true, the additional pcurve will be
-- attached to the constructed edges in the parametric space of the
-- second shape.
-- These two functions may be used together.
-- edges of the result.
-- If ComputePCurve1 equals true, further computations performed
-- to attach an P-Curve in the parametric space of the tool
-- to the constructed edges.
-- Obsolete
Build(me : in out)
is redefined;
---Purpose: Performs the computation of
-- section lines between two parts defined at the time of
-- construction of this framework or reinitialized with the Init1 and
-- Init2 functions.
-- The constructed shape will be returned by the function Shape.
-- This is a compound object composed of edges. These
-- intersection edges may be built:
-- - on new intersection lines, or
-- - on coincident portions of edges in the two intersected shapes.
-- These intersection edges are independent: they are not chained
-- or grouped into wires.
-- If no intersection edge exists, the result is an empty compound object.
-- The shapes involved in the construction of section lines can
-- be retrieved with the function Shape1 or Shape2. Note that other
-- objects than TopoDS_Shape shapes given as arguments at the
-- construction time of this framework, or to the Init1 or
-- Init2 function, are converted into faces or shells before
-- performing the computation of the intersection.
-- Parametric 2D curves on intersection edges
-- No parametric 2D curve (pcurve) is defined for the elementary
-- edges of the result. To attach parametric curves like this to
-- the constructed edges you have to use:
-- - the function
-- ComputePCurveOn1 to ask for the additional computation of a
-- pcurve in the parametric space of the first shape,
-- - the function
-- ComputePCurveOn2 to ask for the additional computation of a
-- pcurve in the parametric space of the second shape.
-- This must be done before calling this function.
-- Approximation of intersection edges
-- The underlying 3D geometry attached to each elementary edge of the result is:
-- - analytic (where possible) provided the corresponding
-- geometry corresponds to a type of analytic curve defined in
-- the Geom package; for example, the intersection of a
-- cylindrical shape with a plane gives an ellipse or a circle; or
-- - elsewhere, given as a succession of points grouped
-- together in a BSpline curve of degree 1.
-- If, on computed elementary intersection edges whose
-- underlying geometry is not analytic, you prefer to have an
-- attached 3D geometry which is a Bspline approximation of the
-- computed set of points, you have to use the function Approximation
-- to ask for this computation option before calling this function.
-- You may also have combined these computation options: look at the
-- example given above to illustrate the use of the constructors.
---Purpose: Performs the algorithm
-- Filling interference Data Structure (if it is necessary)
-- Building the result of the operation.
HasAncestorFaceOn1(me;
E : Shape from TopoDS;
F : out Shape from TopoDS)
returns Boolean from Standard;
---Level: Public
---Purpose:
-- get the face of the first part giving section edge <E>.
-- Returns True on the 3 following conditions :
-- 1/ <E> is an edge returned by the Shape() method.
-- 1/ <E> is an edge returned by the Shape() metwod.
-- 2/ First part of section performed is a shape.
-- 3/ <E> is built on a intersection curve (i.e <E>
-- is not the result of common edges)
-- When False, F remains untouched.
-- Obsolete
HasAncestorFaceOn2(me;
E : Shape from TopoDS;
@ -330,15 +272,20 @@ is
-- To use these functions properly, you have to test the returned
-- Boolean value before using the ancestor face: F is significant
-- only if the returned Boolean value equals true.
-- Obsolete
InitParameters(me: out)
is private;
---Level: Private
--
-- protected methods
--
Init(me: out;
PerformNow : Boolean)
is protected;
SetAttributes (me:out)
is redefined protected;
fields
myshapeisnull : Boolean from Standard;
myparameterschanged : Boolean from Standard;
myParametersChanged : Boolean from Standard;
myApprox : Boolean from Standard;
myComputePCurve1 : Boolean from Standard;
myComputePCurve2 : Boolean from Standard;

345
src/BRepAlgoAPI/BRepAlgoAPI_Section.cxx
View File

@ -32,9 +32,10 @@
#include <TopoDS_Face.hxx>
#include <BRep_Tool.hxx>
#include <BOPDS_DS.hxx>
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPAlgo_BOP.hxx>
#include <BOPDS_DS.hxx>
#include <BOPAlgo_Section.hxx>
//
static
@ -45,7 +46,12 @@ static
const TopoDS_Shape&,
TopoDS_Shape&,
TopoDS_Shape&);
static
Standard_Boolean HasAncestorFace (const BOPAlgo_PPaveFiller& ,
Standard_Integer ,
const TopoDS_Shape& ,
TopoDS_Shape& );
//
//=======================================================================
//function : BRepAlgoAPI_Section
//purpose :
@ -54,27 +60,17 @@ BRepAlgoAPI_Section::BRepAlgoAPI_Section()
:
BRepAlgoAPI_BooleanOperation()
{
myOperation=BOPAlgo_SECTION;
InitParameters();
Init(Standard_False);
}
//=======================================================================
//function : ~BRepAlgoAPI_Section
//function : BRepAlgoAPI_Section
//purpose :
//=======================================================================
BRepAlgoAPI_Section::~BRepAlgoAPI_Section()
BRepAlgoAPI_Section::BRepAlgoAPI_Section(const BOPAlgo_PaveFiller& aPF)
:
BRepAlgoAPI_BooleanOperation(aPF)
{
}
//=======================================================================
//function : InitParameters
//purpose :
//=======================================================================
void BRepAlgoAPI_Section::InitParameters()
{
myparameterschanged = Standard_False;
myshapeisnull = Standard_False;
myApprox = Standard_False;
myComputePCurve1 = Standard_False;
myComputePCurve2 = Standard_False;
Init(Standard_False);
}
//=======================================================================
//function : Constructor
@ -84,17 +80,11 @@ BRepAlgoAPI_Section::BRepAlgoAPI_Section(const TopoDS_Shape& Sh1,
const TopoDS_Shape& Sh2,
const Standard_Boolean PerformNow)
:
BRepAlgoAPI_BooleanOperation(Sh1, Sh2, BOPAlgo_SECTION)
BRepAlgoAPI_BooleanOperation(Sh1,
Sh2,
BOPAlgo_SECTION)
{
InitParameters();
myparameterschanged = Standard_True;
if(myS1.IsNull() || myS2.IsNull()) {
myshapeisnull = Standard_True;
}
if (PerformNow) {
Build();
}
Init(PerformNow);
}
//=======================================================================
//function : BRepAlgoAPI_Section
@ -106,18 +96,12 @@ BRepAlgoAPI_Section::BRepAlgoAPI_Section
const BOPAlgo_PaveFiller& aDSF,
const Standard_Boolean PerformNow)
:
BRepAlgoAPI_BooleanOperation(aS1, aS2, aDSF, BOPAlgo_SECTION)
BRepAlgoAPI_BooleanOperation(aS1,
aS2,
aDSF,
BOPAlgo_SECTION)
{
InitParameters();
myparameterschanged = Standard_True;
if(myS1.IsNull() || myS2.IsNull()) {
myshapeisnull = Standard_True;
}
if (PerformNow) {
Build();
}
Init(PerformNow);
}
//=======================================================================
//function : Constructor
@ -128,18 +112,11 @@ BRepAlgoAPI_Section::BRepAlgoAPI_Section
const gp_Pln& Pl,
const Standard_Boolean PerformNow)
:
BRepAlgoAPI_BooleanOperation(Sh, MakeShape(new Geom_Plane(Pl)),
BRepAlgoAPI_BooleanOperation(Sh,
MakeShape(new Geom_Plane(Pl)),
BOPAlgo_SECTION)
{
InitParameters();
myparameterschanged = Standard_True;
if(Sh.IsNull() || myS2.IsNull()) {
myshapeisnull = Standard_True;
}
if (PerformNow) {
Build();
}
Init(PerformNow);
}
//=======================================================================
//function : Constructor
@ -150,17 +127,11 @@ BRepAlgoAPI_Section::BRepAlgoAPI_Section
const Handle(Geom_Surface)& Sf,
const Standard_Boolean PerformNow)
:
BRepAlgoAPI_BooleanOperation(Sh, MakeShape(Sf), BOPAlgo_SECTION)
BRepAlgoAPI_BooleanOperation(Sh,
MakeShape(Sf),
BOPAlgo_SECTION)
{
InitParameters();
myparameterschanged = Standard_True;
if(Sh.IsNull() || myS2.IsNull()) {
myshapeisnull = Standard_True;
}
if (PerformNow) {
Build();
}
Init(PerformNow);
}
//=======================================================================
//function : Constructor
@ -171,17 +142,11 @@ BRepAlgoAPI_Section::BRepAlgoAPI_Section
const TopoDS_Shape& Sh,
const Standard_Boolean PerformNow)
:
BRepAlgoAPI_BooleanOperation(MakeShape(Sf), Sh, BOPAlgo_SECTION)
BRepAlgoAPI_BooleanOperation(MakeShape(Sf),
Sh,
BOPAlgo_SECTION)
{
InitParameters();
myparameterschanged = Standard_True;
if(myS1.IsNull() || Sh.IsNull()) {
myshapeisnull = Standard_True;
}
if (PerformNow) {
Build();
}
Init(PerformNow);
}
//=======================================================================
//function : Constructor
@ -196,14 +161,29 @@ BRepAlgoAPI_Section::BRepAlgoAPI_Section
MakeShape(Sf2),
BOPAlgo_SECTION)
{
InitParameters();
myparameterschanged = Standard_True;
if(myS1.IsNull() || myS2.IsNull()) {
myshapeisnull = Standard_True;
Init(PerformNow);
}
if (PerformNow) {
//=======================================================================
//function : ~BRepAlgoAPI_Section
//purpose :
//=======================================================================
BRepAlgoAPI_Section::~BRepAlgoAPI_Section()
{
}
//=======================================================================
//function : Init
//purpose :
//=======================================================================
void BRepAlgoAPI_Section::Init(const Standard_Boolean bFlag)
{
myOperation=BOPAlgo_SECTION;
myParametersChanged = Standard_False;
myApprox = Standard_False;
myComputePCurve1 = Standard_False;
myComputePCurve2 = Standard_False;
myParametersChanged = Standard_True;
//
if (bFlag) {
Build();
}
}
@ -213,26 +193,9 @@ BRepAlgoAPI_Section::BRepAlgoAPI_Section
//=======================================================================
void BRepAlgoAPI_Section::Init1(const TopoDS_Shape& S1)
{
if(!S1.IsNull()) {
if (!S1.IsEqual(myS1)) {
myS1 = S1;
if(!myS2.IsNull()) {
myshapeisnull = Standard_False;
}
myparameterschanged = Standard_True;
}
}
else {
if(!myS1.IsNull()) {
myS1 = S1;
myshapeisnull = Standard_True;
myparameterschanged = Standard_True;
}
}
if(myparameterschanged)
NotDone();
myArguments.Clear();
myArguments.Append(S1);
myParametersChanged = Standard_True;
}
//=======================================================================
//function : Init1
@ -256,27 +219,9 @@ void BRepAlgoAPI_Section::Init1(const Handle(Geom_Surface)& Sf)
//=======================================================================
void BRepAlgoAPI_Section::Init2(const TopoDS_Shape& S2)
{
if(!S2.IsNull()) {
if (!S2.IsEqual(myS2)) {
myS2 = S2;
if(!myS1.IsNull()) {
myshapeisnull = Standard_False;
}
myparameterschanged = Standard_True;
}
}
else {
if(!myS2.IsNull()) {
myS2 = S2;
myshapeisnull = Standard_True;
myparameterschanged = Standard_True;
}
}
if(myparameterschanged) {
NotDone();
}
myTools.Clear();
myTools.Append(S2);
myParametersChanged = Standard_True;
}
//=======================================================================
//function : Init2
@ -302,7 +247,7 @@ void BRepAlgoAPI_Section::Approximation(const Standard_Boolean B)
{
if(myApprox != B) {
myApprox = B;
myparameterschanged = Standard_True;
myParametersChanged = Standard_True;
}
}
//=======================================================================
@ -313,7 +258,7 @@ void BRepAlgoAPI_Section::ComputePCurveOn1(const Standard_Boolean B)
{
if(myComputePCurve1 != B) {
myComputePCurve1 = B;
myparameterschanged = Standard_True;
myParametersChanged = Standard_True;
}
}
//=======================================================================
@ -324,133 +269,125 @@ void BRepAlgoAPI_Section::ComputePCurveOn2(const Standard_Boolean B)
{
if(myComputePCurve2 != B) {
myComputePCurve2 = B;
myparameterschanged = Standard_True;
myParametersChanged = Standard_True;
}
}
//=======================================================================
//function : SetAttributes
//purpose :
//=======================================================================
void BRepAlgoAPI_Section::SetAttributes()
{
BOPAlgo_SectionAttribute theSecAttr(myApprox,
myComputePCurve1,
myComputePCurve2);
myDSFiller->SetSectionAttribute(theSecAttr);
}
//=======================================================================
//function : Build
//purpose :
//=======================================================================
void BRepAlgoAPI_Section::Build()
{
if(myshapeisnull) {
myErrorStatus = 2;
NotDone();
return;
}
if(myparameterschanged) {
Standard_Boolean bIsNewFiller = PrepareFiller();
//
if (myErrorStatus!=1) {
NotDone();
// there were errors during the preparation
return;
}
//
if (bIsNewFiller) {
BOPAlgo_SectionAttribute theSecAttr(myApprox,
myComputePCurve1,
myComputePCurve2);
myDSFiller->SetSectionAttribute(theSecAttr);
myDSFiller->Perform();
}
//
BRepAlgoAPI_BooleanOperation::Build();
//
myparameterschanged = Standard_False;
}
}
//=======================================================================
//function : HasAncestorFaceOn1
//purpose :
//=======================================================================
Standard_Boolean BRepAlgoAPI_Section::HasAncestorFaceOn1
(const TopoDS_Shape& E,
TopoDS_Shape& F) const
(const TopoDS_Shape& aE,
TopoDS_Shape& aF) const
{
Standard_Boolean aResult = Standard_False;
if(E.IsNull()) {
return aResult;
}
if(E.ShapeType() != TopAbs_EDGE) {
return aResult;
}
TopoDS_Shape F1, F2;
aResult = HasAncestorFaces(myDSFiller, E, F1, F2);
if(F1.IsNull()) {
return Standard_False;
}
F = F1;
return aResult;
Standard_Boolean bRes;
//
bRes = HasAncestorFace(myDSFiller,1 , aE, aF);
return bRes;
}
//=======================================================================
//function : HasAncestorFaceOn2
//purpose :
//=======================================================================
Standard_Boolean BRepAlgoAPI_Section::HasAncestorFaceOn2
(const TopoDS_Shape& E,
TopoDS_Shape& F) const
(const TopoDS_Shape& aE,
TopoDS_Shape& aF) const
{
Standard_Boolean aResult = Standard_False;
if(E.IsNull()) {
return aResult;
Standard_Boolean bRes;
//
bRes = HasAncestorFace(myDSFiller, 2, aE, aF);
return bRes;
}
if(E.ShapeType() != TopAbs_EDGE) {
return aResult;
//=======================================================================
//function : HasAncestorFace
//purpose :
//=======================================================================
Standard_Boolean HasAncestorFace (const BOPAlgo_PPaveFiller& pPF,
Standard_Integer aIndex,
const TopoDS_Shape& aE,
TopoDS_Shape& aF)
{
Standard_Boolean bRes;
//
bRes = Standard_False;
if(aE.IsNull()) {
return bRes;
}
TopoDS_Shape F1, F2;
aResult = HasAncestorFaces(myDSFiller, E, F1, F2);
if(F2.IsNull()) {
return Standard_False;
if(aE.ShapeType() != TopAbs_EDGE) {
return bRes;
}
F = F2;
return aResult;
//
TopoDS_Shape aF1, aF2;
//
bRes=HasAncestorFaces(pPF, aE, aF1, aF2);
if (!bRes) {
return bRes;
}
//
aF=(aIndex==1) ? aF1 : aF2;
return bRes;
}
//=======================================================================
//function : HasAncestorFaces
//purpose :
//=======================================================================
Standard_Boolean HasAncestorFaces(const BOPAlgo_PPaveFiller& theDSFiller,
const TopoDS_Shape& E,
TopoDS_Shape& F1,
TopoDS_Shape&F2)
Standard_Boolean HasAncestorFaces (const BOPAlgo_PPaveFiller& pPF,
const TopoDS_Shape& aEx,
TopoDS_Shape& aF1,
TopoDS_Shape& aF2)
{
Standard_Integer aNb, i, j, nE, nF1, nF2, aNbCurves;
Standard_Integer aNbFF, i, j, nE, nF1, nF2, aNbVC;
BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
//
const BOPDS_PDS& pDS = theDSFiller->PDS();
const BOPDS_PDS& pDS = pPF->PDS();
BOPDS_VectorOfInterfFF& aFFs=pDS->InterfFF();
//
aNb=aFFs.Extent();
//section edges
for (i = 0; i < aNb; i++) {
aNbFF=aFFs.Extent();
for (i = 0; i<aNbFF; ++i) {
BOPDS_InterfFF& aFFi=aFFs(i);
aFFi.Indices(nF1, nF2);
//
const BOPDS_VectorOfCurve& aSeqOfCurve=aFFi.Curves();
aNbCurves=aSeqOfCurve.Extent();
for (j=0; j<aNbCurves; j++) {
const BOPDS_Curve& aCurve=aSeqOfCurve(j);
const BOPDS_ListOfPaveBlock& aSectEdges = aCurve.PaveBlocks();
BOPDS_ListIteratorOfListOfPaveBlock anIt;
anIt.Initialize(aSectEdges);
for(; anIt.More(); anIt.Next()) {
const Handle(BOPDS_PaveBlock)& aPB = anIt.Value();
nE = aPB->Edge();
if(nE < 0) continue;
const BOPDS_VectorOfCurve& aVC=aFFi.Curves();
aNbVC=aVC.Extent();
for (j=0; j<aNbVC; j++) {
const BOPDS_Curve& aBC=aVC(j);
//
if(E.IsSame(pDS->Shape(nE))) {
F1 = pDS->Shape(nF1);
F2 = pDS->Shape(nF2);
const BOPDS_ListOfPaveBlock& aLPB = aBC.PaveBlocks();
//
aItLPB.Initialize(aLPB);
for(; aItLPB.More(); aItLPB.Next()) {
const Handle(BOPDS_PaveBlock)& aPB = aItLPB.Value();
nE = aPB->Edge();
if(nE < 0) {
continue;
}
//
const TopoDS_Shape aE=pDS->Shape(nE);
if(aEx.IsSame(aE)) {
aF1 = pDS->Shape(nF1);
aF2 = pDS->Shape(nF2);
return Standard_True;
}
}

4
src/QANewModTopOpe/QANewModTopOpe_Glue.cxx
View File

@ -104,7 +104,6 @@ QANewModTopOpe_Glue::QANewModTopOpe_Glue(const TopoDS_Shape& theS1,
if (thePerformNow)
Build();
}
//=======================================================================
//function : Build
//purpose :
@ -112,6 +111,9 @@ QANewModTopOpe_Glue::QANewModTopOpe_Glue(const TopoDS_Shape& theS1,
void QANewModTopOpe_Glue::Build()
{
TopoDS_Shape& myS1=myArguments.First();
TopoDS_Shape& myS2=myTools.First();
if (myCompleted) return;
TopAbs_ShapeEnum aType1, aType2;

3
src/QANewModTopOpe/QANewModTopOpe_Glue_SDFaces.cxx
View File

@ -323,6 +323,9 @@ Standard_Boolean QANewModTopOpe_Glue::SubstitudeSDFaces
void
QANewModTopOpe_Glue::PerformSDFaces()
{
TopoDS_Shape& myS1=myArguments.First();
TopoDS_Shape& myS2=myTools.First();
TopExp_Explorer anExp;
TopoDS_Shape aS1, aS2;
Standard_Boolean aWire1 = Standard_False, aWire2 = Standard_False;

4
src/QANewModTopOpe/QANewModTopOpe_Glue_shell.cxx
View File

@ -322,7 +322,9 @@ CorrectAncestorsList (const TopoDS_Edge& theEdge, TopTools_ListOfShape& aListF)
void
QANewModTopOpe_Glue::PerformShell()
{
// Standard_Boolean isSolidShell = (myS1.ShapeType() == TopAbs_SOLID);
TopoDS_Shape& myS1=myArguments.First();
TopoDS_Shape& myS2=myTools.First();
Standard_Boolean isSolidShell = Standard_False;
Standard_Integer i;

5
src/QANewModTopOpe/QANewModTopOpe_Glue_vertex.cxx
View File

@ -32,6 +32,9 @@
void
QANewModTopOpe_Glue::PerformVertex()
{
TopoDS_Shape& myS1=myArguments.First();
TopoDS_Shape& myS2=myTools.First();
BRepExtrema_DistShapeShape aExtrema (myS1, myS2);
if (!aExtrema.IsDone()) return;
if (aExtrema.InnerSolution()) {
@ -44,6 +47,8 @@ QANewModTopOpe_Glue::PerformVertex()
aList.Append (aV);
myMapGener.Bind(myS1, aList);
myShape = myS1;
myShape.Orientation(myS1.Orientation());
Done();

6
src/QANewModTopOpe/QANewModTopOpe_Glue_wire.cxx
View File

@ -575,6 +575,9 @@ UpdateEdgeOnFace (const TopoDS_Edge& theEdge, const TopoDS_Face& theFace)
void
QANewModTopOpe_Glue::PerformShellWire()
{
TopoDS_Shape& myS1=myArguments.First();
TopoDS_Shape& myS2=myTools.First();
Standard_Boolean anOnlyOneFace = Standard_False;
BRep_Builder aBld;
if(myS1.ShapeType() == TopAbs_FACE) {
@ -1258,6 +1261,9 @@ static void FillMapModif(const BRepTools_Substitution &theSubst,
void
QANewModTopOpe_Glue::PerformWires()
{
TopoDS_Shape& myS1=myArguments.First();
TopoDS_Shape& myS2=myTools.First();
Standard_Boolean S1IsEdge = Standard_False, S2IsEdge = Standard_False;
if(myS1.ShapeType() == TopAbs_EDGE) {
myS1 = BRepBuilderAPI_MakeWire(TopoDS::Edge(myS1));

3
src/QANewModTopOpe/QANewModTopOpe_Intersection.cdl
View File

@ -13,7 +13,8 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class Intersection from QANewModTopOpe inherits BooleanOperation from BRepAlgoAPI
class Intersection from QANewModTopOpe
inherits BooleanOperation from BRepAlgoAPI
---Purpose: provides intersection of two shapes;

34
src/QANewModTopOpe/QANewModTopOpe_Intersection.cxx
View File

@ -46,10 +46,19 @@ static Standard_Boolean NoFaces(const TopoDS_Shape& S1, const TopoDS_Shape& S2)
return !f1&&!f2;
}
QANewModTopOpe_Intersection::QANewModTopOpe_Intersection( const TopoDS_Shape& theObject1,
//=======================================================================
//function : QANewModTopOpe_Intersection
//purpose :
//=======================================================================
QANewModTopOpe_Intersection::QANewModTopOpe_Intersection
( const TopoDS_Shape& theObject1,
const TopoDS_Shape& theObject2 )
: BRepAlgoAPI_BooleanOperation( theObject1, theObject2, BOPAlgo_SECTION)
:
BRepAlgoAPI_BooleanOperation( theObject1, theObject2, BOPAlgo_SECTION)
{
TopoDS_Shape& myS1=myArguments.First();
TopoDS_Shape& myS2=myTools.First();
myMapGener.Clear();
if(NoFaces(myS1, myS2)) {
@ -100,14 +109,14 @@ QANewModTopOpe_Intersection::QANewModTopOpe_Intersection( const TopoDS_Shape& th
BB.Add(myShape, mkV.Vertex());
if (!myMapGener.IsBound(DSS. SupportOnShape1(i))) {
// for Mandrake-10 - mkv,02.06.06 - myMapGener.Bind(DSS.SupportOnShape1(i), TopTools_ListOfShape());
TopTools_ListOfShape aListOfShape1;
myMapGener.Bind(DSS.SupportOnShape1(i), aListOfShape1);
}
myMapGener(DSS.SupportOnShape1(i)).Append(mkV.Vertex());
if (!myMapGener.IsBound(DSS.SupportOnShape2(i))) {
// for Mandrake-10 - mkv,02.06.06 - myMapGener.Bind(DSS.SupportOnShape2(i), TopTools_ListOfShape());
TopTools_ListOfShape aListOfShape2;
myMapGener.Bind(DSS.SupportOnShape2(i), aListOfShape2);
}
@ -123,20 +132,6 @@ QANewModTopOpe_Intersection::QANewModTopOpe_Intersection( const TopoDS_Shape& th
Done();
return;
}
Standard_Boolean bIsNewFiller = PrepareFiller();
//
if (myErrorStatus!=1) {
// there were errors during the preparation
return;
}
//
if (bIsNewFiller) {
//Prepare the DS
myDSFiller->Perform();
}
Build();
Standard_Boolean bcw = BuilderCanWork();
@ -329,6 +324,9 @@ Standard_Boolean QANewModTopOpe_Intersection::IsDeleted(const TopoDS_Shape& aS)
//=======================================================================
Standard_Boolean QANewModTopOpe_Intersection::HasDeleted() const
{
const TopoDS_Shape& myS1=myArguments.First();
const TopoDS_Shape& myS2=myTools.First();
TopExp_Explorer anExp;
for(Standard_Integer argit = 0; argit < 2; argit++) {

57
tests/bugs/modalg_5/bug25614_common Executable file
View File

@ -0,0 +1,57 @@
puts "============"
puts "OCC25614"
puts "============"
puts ""
###############################
## Provide API access to the new functionalities of Boolean Components
###############################
#====================
box b 10 10 4
ttranslate b 0 0 -2
set qs1 {}
set N 11
for {set i 0} {$i < $N} {incr i} {
for {set j 0} {$j < $N} {incr j} {
tcopy b b_${i}_${j}
ttranslate b_${i}_${j} [expr $i * 10] [expr $j * 10] 0.
lappend qs1 b_${i}_${j}
}
}
eval compound $qs1 b1
pcylinder b 6 10
ttranslate b 10 10 -5
set qs2 {}
set N 10
for {set i 0} {$i < $N} {incr i} {
for {set j 0} {$j < $N} {incr j} {
tcopy b b_${i}_${j}
ttranslate b_${i}_${j} [expr $i * 10] [expr $j * 10] 0.
lappend qs2 b_${i}_${j}
}
}
eval compound $qs2 b2
#====================
bclearobjects
bcleartools
baddcompound b1
baddctools b2
bapibop result 0
set nb_v_good 1720
set nb_e_good 3800
set nb_w_good 1920
set nb_f_good 1920
set nb_sh_good 1
set nb_sol_good 1
set nb_compsol_good 0
set nb_compound_good 1
set nb_shape_good 9363
set 3dviewer 1

57
tests/bugs/modalg_5/bug25614_cut Executable file
View File

@ -0,0 +1,57 @@
puts "============"
puts "OCC25614"
puts "============"
puts ""
###############################
## Provide API access to the new functionalities of Boolean Components
###############################
#====================
box b 10 10 4
ttranslate b 0 0 -2
set qs1 {}
set N 11
for {set i 0} {$i < $N} {incr i} {
for {set j 0} {$j < $N} {incr j} {
tcopy b b_${i}_${j}
ttranslate b_${i}_${j} [expr $i * 10] [expr $j * 10] 0.
lappend qs1 b_${i}_${j}
}
}
eval compound $qs1 b1
pcylinder b 6 10
ttranslate b 10 10 -5
set qs2 {}
set N 10
for {set i 0} {$i < $N} {incr i} {
for {set j 0} {$j < $N} {incr j} {
tcopy b b_${i}_${j}
ttranslate b_${i}_${j} [expr $i * 10] [expr $j * 10] 0.
lappend qs2 b_${i}_${j}
}
}
eval compound $qs2 b2
#====================
bclearobjects
bcleartools
baddcompound b1
baddctools b2
bapibop result 2
set nb_v_good 888
set nb_e_good 1412
set nb_w_good 686
set nb_f_good 686
set nb_sh_good 82
set nb_sol_good 82
set nb_compsol_good 0
set nb_compound_good 1
set nb_shape_good 3837
set 3dviewer 1

57
tests/bugs/modalg_5/bug25614_cut21 Executable file
View File

@ -0,0 +1,57 @@
puts "============"
puts "OCC25614"
puts "============"
puts ""
###############################
## Provide API access to the new functionalities of Boolean Components
###############################
#====================
box b 10 10 4
ttranslate b 0 0 -2
set qs1 {}
set N 11
for {set i 0} {$i < $N} {incr i} {
for {set j 0} {$j < $N} {incr j} {
tcopy b b_${i}_${j}
ttranslate b_${i}_${j} [expr $i * 10] [expr $j * 10] 0.
lappend qs1 b_${i}_${j}
}
}
eval compound $qs1 b1
pcylinder b 6 10
ttranslate b 10 10 -5
set qs2 {}
set N 10
for {set i 0} {$i < $N} {incr i} {
for {set j 0} {$j < $N} {incr j} {
tcopy b b_${i}_${j}
ttranslate b_${i}_${j} [expr $i * 10] [expr $j * 10] 0.
lappend qs2 b_${i}_${j}
}
}
eval compound $qs2 b2
#====================
bclearobjects
bcleartools
baddcompound b1
baddctools b2
bapibop result 3
set nb_v_good 2640
set nb_e_good 5780
set nb_w_good 2820
set nb_f_good 2820
set nb_sh_good 2
set nb_sol_good 2
set nb_compsol_good 0
set nb_compound_good 1
set nb_shape_good 14065
set 3dviewer 1

57
tests/bugs/modalg_5/bug25614_fuse Executable file
View File

@ -0,0 +1,57 @@
puts "============"
puts "OCC25614"
puts "============"
puts ""
###############################
## Provide API access to the new functionalities of Boolean Components
###############################
#====================
box b 10 10 4
ttranslate b 0 0 -2
set qs1 {}
set N 11
for {set i 0} {$i < $N} {incr i} {
for {set j 0} {$j < $N} {incr j} {
tcopy b b_${i}_${j}
ttranslate b_${i}_${j} [expr $i * 10] [expr $j * 10] 0.
lappend qs1 b_${i}_${j}
}
}
eval compound $qs1 b1
pcylinder b 6 10
ttranslate b 10 10 -5
set qs2 {}
set N 10
for {set i 0} {$i < $N} {incr i} {
for {set j 0} {$j < $N} {incr j} {
tcopy b b_${i}_${j}
ttranslate b_${i}_${j} [expr $i * 10] [expr $j * 10] 0.
lappend qs2 b_${i}_${j}
}
}
eval compound $qs2 b2
#====================
bclearobjects
bcleartools
baddcompound b1
baddctools b2
bapibop result 1
set nb_v_good 1808
set nb_e_good 3392
set nb_w_good 1586
set nb_f_good 1586
set nb_sh_good 1
set nb_sol_good 1
set nb_compsol_good 0
set nb_compound_good 1
set nb_shape_good 8375
set 3dviewer 1

57
tests/bugs/modalg_5/bug25614_genfuse Executable file
View File

@ -0,0 +1,57 @@
puts "============"
puts "OCC25614"
puts "============"
puts ""
###############################
## Provide API access to the new functionalities of Boolean Components
###############################
#====================
box b 10 10 4
ttranslate b 0 0 -2
set qs1 {}
set N 11
for {set i 0} {$i < $N} {incr i} {
for {set j 0} {$j < $N} {incr j} {
tcopy b b_${i}_${j}
ttranslate b_${i}_${j} [expr $i * 10] [expr $j * 10] 0.
lappend qs1 b_${i}_${j}
}
}
eval compound $qs1 b1
pcylinder b 6 10
ttranslate b 10 10 -5
set qs2 {}
set N 10
for {set i 0} {$i < $N} {incr i} {
for {set j 0} {$j < $N} {incr j} {
tcopy b b_${i}_${j}
ttranslate b_${i}_${j} [expr $i * 10] [expr $j * 10] 0.
lappend qs2 b_${i}_${j}
}
}
eval compound $qs2 b2
#====================
bclearobjects
bcleartools
baddcompound b1
baddcompound b2
bapibuild result
set nb_v_good 2728
set nb_e_good 7032
set nb_w_good 5746
set nb_f_good 5746
set nb_sh_good 1441
set nb_sol_good 1441
set nb_compsol_good 0
set nb_compound_good 1
set nb_shape_good 24135
set 3dviewer 1

57
tests/bugs/modalg_5/bug25614_section Executable file
View File

@ -0,0 +1,57 @@
puts "============"
puts "OCC25614"
puts "============"
puts ""
###############################
## Provide API access to the new functionalities of Boolean Components
###############################
#====================
box b 10 10 4
ttranslate b 0 0 -2
set qs1 {}
set N 11
for {set i 0} {$i < $N} {incr i} {
for {set j 0} {$j < $N} {incr j} {
tcopy b b_${i}_${j}
ttranslate b_${i}_${j} [expr $i * 10] [expr $j * 10] 0.
lappend qs1 b_${i}_${j}
}
}
eval compound $qs1 b1
pcylinder b 6 10
ttranslate b 10 10 -5
set qs2 {}
set N 10
for {set i 0} {$i < $N} {incr i} {
for {set j 0} {$j < $N} {incr j} {
tcopy b b_${i}_${j}
ttranslate b_${i}_${j} [expr $i * 10] [expr $j * 10] 0.
lappend qs2 b_${i}_${j}
}
}
eval compound $qs2 b2
#====================
bclearobjects
bcleartools
baddcompound b1
baddctools b2
bapibop result 4
set nb_v_good 2700
set nb_e_good 6000
set nb_w_good 0
set nb_f_good 0
set nb_sh_good 0
set nb_sol_good 0
set nb_compsol_good 0
set nb_compound_good 1
set nb_shape_good 8701
set 3dviewer 1