BRepAlgoAPI

Provides the root interface for the API algorithms.

The root API class for performing Boolean Operations on arbitrary shapes.
The arguments of the operation are divided in two groups - Objects and Tools. Each group can contain any number of shapes, but each shape should be valid in terms of BRepCheck_Analyzer and BOPAlgo_ArgumentAnalyzer. The algorithm builds the splits of the given arguments using the intersection results and combines the result of Boolean Operation of given type:

• FUSE - union of two groups of objects;
• COMMON - intersection of two groups of objects;
• CUT - subtraction of one group from the other;
• SECTION - section edges and vertices of all arguments;
  The rules for the arguments and type of the operation are the following:
• For Boolean operation FUSE all arguments should have equal dimensions;
• For Boolean operation CUT the minimal dimension of Tools should not be less than the maximal dimension of Objects;
• For Boolean operation COMMON the arguments can have any dimension.
• For Boolean operation SECTION the arguments can be of any type.
  Additionally to the errors of the base class the algorithm returns the following Errors:
• BOPAlgo_AlertBOPNotSet - in case the type of Boolean Operation is not set.

The class contains API level of the General Fuse algorithm.
Additionally to the options defined in the base class, the algorithm has the following options:

• Safe processing mode - allows to avoid modification of the input shapes during the operation (by default it is off);
• Gluing options - allows to speed up the calculation of the intersections on the special cases, in which some sub-shapes are coinciding.
• Disabling the check for inverted solids - Disables/Enables the check of the input solids for inverted status (holes in the space). The default value is TRUE, i.e. the check is performed. Setting this flag to FALSE for inverted solids, most likely will lead to incorrect results.
• Disabling history collection - allows disabling the collection of the history of shapes modifications during the operation.
  It returns the following Error statuses:
• 0 - in case of success;
• BOPAlgo_AlertTooFewArguments - in case there are no enough arguments to perform the operation;
• BOPAlgo_AlertIntersectionFailed - in case the intersection of the arguments has failed;
• BOPAlgo_AlertBuilderFailed - in case building of the result shape has failed.
  Warnings statuses from underlying DS Filler and Builder algorithms are collected in the report.
  The class provides possibility to simplify the resulting shape by unification of the tangential edges and faces. It is performed by the method SimplifyResult. See description of this method for more details.

The class Check provides a diagnostic tool for checking the validity of the single shape or couple of shapes. The shapes are checked on:

• Topological validity;
• Small edges;
• Self-interference;
• Validity for Boolean operation of certain type (for couple of shapes only).
  The class provides two ways of checking shape(-s)

1. Constructors BRepAlgoAPI_Check aCh(theS); bool isValid = aCh.IsValid();
2. Methods SetData and Perform BRepAlgoAPI_Check aCh; aCh.SetData(theS1, theS2, BOPAlgo_FUSE, false); aCh.Perform(); bool isValid = aCh.IsValid();

The class provides Boolean common operation between arguments and tools (Boolean Intersection).

The class Cut provides Boolean cut operation between arguments and tools (Boolean Subtraction).

The BRepAlgoAPI_Defeaturing algorithm is the API algorithm intended for removal of the unwanted parts from the shape. The unwanted parts (or features) can be holes, protrusions, gaps, chamfers, fillets etc. The shape itself is not modified, the new shape is built as the result.
The actual removal of the features from the shape is performed by the low-level BOPAlgo_RemoveFeatures tool. So the defeaturing algorithm has the same options, input data requirements, limitations as the low-level algorithm.
Input data
Currently, only the shapes of type SOLID, COMPSOLID, and COMPOUND of Solids are supported. And only the FACEs can be removed from the shape.
On the input the algorithm accepts the shape itself and the features which have to be removed. It does not matter how the features are given. It could be the separate faces or the collections of faces. The faces should belong to the initial shape, and those that do not belong will be ignored.
Options
The algorithm has the following options:

• History support;
  and the options available from base class:
• Error/Warning reporting system;
• Parallel processing mode.
  Please note that the other options of the base class are not supported here and will have no effect.
  For the details on the available options please refer to the description of BOPAlgo_RemoveFeatures algorithm.
  Limitations
  The defeaturing algorithm has the same limitations as BOPAlgo_RemoveFeatures algorithm.
  Example
  Here is the example of usage of the algorithm:

TopoDS_ShapeaSolid=...;//Inputshapetoremovethefeaturesfrom NCollection_List<TopoDS_Shape>aFeatures=...;//Featurestoremovefromtheshape boolbRunParallel=...;//Parallelprocessingmode boolisHistoryNeeded=...;//Historysupport BRepAlgoAPI_DefeaturingaDF;//De-Featuringalgorithm aDF.SetShape(aSolid);//Settheshape aDF.AddFacesToRemove(aFaces);//Addfacestoremove aDF.SetRunParallel(bRunParallel);//Definetheprocessingmode(parallelorsingle) aDF.SetToFillHistory(isHistoryNeeded);//Definewhethertotracktheshapesmodifications aDF.Build();//Performtheoperation if(!aDF.IsDone())//Checkfortheerrors { //errortreatment Standard_SStreamaSStream; aDF.DumpErrors(aSStream); return; } if(aDF.HasWarnings())//Checkforthewarnings { //warningstreatment Standard_SStreamaSStream; aDF.DumpWarnings(aSStream); } constTopoDS_Shape&aResult=aDF.Shape();//Resultshape

The algorithm preserves the type of the input shape in the result shape. Thus, if the input shape is a COMPSOLID, the resulting solids will also be put into a COMPSOLID.

The class provides Boolean fusion operation between arguments and tools (Boolean Union).

The algorithm is to build a Section 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 class contains API level of the Splitter algorithm, which allows splitting a group of arbitrary shapes by the other group of arbitrary shapes. The arguments of the operation are divided on two groups: Objects - shapes that will be split; Tools - shapes by which the Objects will be split. The result of the operation contains only the split parts of the shapes from the group of Objects. The split parts of the shapes from the group of Tools are excluded from the result. The shapes can be split by the other shapes from the same group (in case these shapes are interfering).
The class is a General Fuse based algorithm. Thus, all options of the General Fuse algorithm such as Fuzzy mode, safe processing mode, parallel processing mode, gluing mode and history support are also available in this algorithm. There is no requirement on the existence of the Tools shapes. And if there are no Tools shapes, the result of the splitting operation will be equivalent to the General Fuse result.
The algorithm returns the following Error statuses:

• 0 - in case of success;
• BOPAlgo_AlertTooFewArguments - in case there is no enough arguments for the operation;
• BOPAlgo_AlertIntersectionFailed - in case the Intersection of the arguments has failed;
• BOPAlgo_AlertBuilderFailed - in case the Building of the result has failed.