OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-08-09 13:22:24 +03:00
Code Activity

0028179: Update documentation of Boolean Component

Browse Source
This commit is contained in:
emv
2017-04-05 07:59:14 +03:00
committed by bugmaster
parent e473b95fe9
commit aeee70d353
6 changed files with 145 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
src/BOPAlgo/BOPAlgo_GlueEnum.hxx
View File

@@ -17,43 +17,42 @@
//! The Enumeration describes an additional option for the algorithms
//! in the Boolean Component such as General Fuse, Boolean operations,
//! Section operation, Maker Volume and Cells Builder algorithms.
//! Section, Maker Volume, Splitter and Cells Builder algorithms.<br>
//!
//! The Gluing options have been designed to speed up the computation
//! of the interference among arguments of the operations on special cases,
//! in which the arguments may be overlapping but do not have real intersections
//! between their sub-shapes.
//! between their sub-shapes.<br>
//!
//! This option cannot be used on the shapes having real intersections,
//! like intersection vertex between edges, or intersection vertex between
//! edge and a face or intersection line between faces.
//! edge and a face or intersection line between faces.<br>
//!
//! There are two possibilities of overlapping shapes:
//! There are two possibilities of overlapping shapes:<br>
//! 1. The shapes can be partially coinciding - the faces do not have
//! intersection curves, but overlapping. The faces of such arguments will
//! be split during the operation;
//! be split during the operation;<br>
//! 2. The shapes can be fully coinciding - there should be no partial
//! overlapping of the faces, thus no intersection of type EDGE/FACE at all.
//! In such cases the faces will not be split during the operation.
//! In such cases the faces will not be split during the operation.<br>
//!
//! Even though there are no real intersections on such cases without Gluing options the algorithm
//! will still intersect the sub-shapes of the arguments with interfering bounding boxes.
//! will still intersect the sub-shapes of the arguments with interfering bounding boxes.<br>
//!
//! The performance improvement in gluing mode is achieved by excluding
//! the most time consuming computations according to the given Gluing parameter:
//! 1. Computation of FACE/FACE intersections for partial coincidence;
//! 2. And computation of VERTEX/FACE, EDGE/FACE and FACE/FACE intersections for full coincidence.
//! the most time consuming computations according to the given Gluing parameter:<br>
//! 1. Computation of FACE/FACE intersections for partial coincidence;<br>
//! 2. And computation of VERTEX/FACE, EDGE/FACE and FACE/FACE intersections for full coincidence.<br>
//!
//! By setting the Gluing option for the operation user should guarantee
//! that the arguments are really coinciding. The algorithms do not check this itself.
//! Setting inappropriate option for the operation is likely to lead to incorrect result.
//! Setting inappropriate option for the operation is likely to lead to incorrect result.<br>
//!
//! There are following items in the enumeration:
//! BOPAlgo_GlueOff - default value for the algorithms, Gluing is switched off;
//! BOPAlgo_GlueShift - Glue option for shapes with partial coincidence;
//! BOPAlgo_GlueFull - Glue option for shapes with full coincidence.
//! There are following items in the enumeration:<br>
//! **BOPAlgo_GlueOff** - default value for the algorithms, Gluing is switched off;<br>
//! **BOPAlgo_GlueShift** - Glue option for shapes with partial coincidence;<br>
//! **BOPAlgo_GlueFull** - Glue option for shapes with full coincidence.
//!
enum BOPAlgo_GlueEnum
{
BOPAlgo_GlueOff,

28
src/BOPAlgo/BOPAlgo_Splitter.hxx
View File

@@ -21,17 +21,25 @@
#include <BOPAlgo_Builder.hxx>
//! The class is a General Fuse (GF) based algorithm.<br>
//! It provides means to split an arbitrary number of shapes of arbitrary
//! dimensions by other arbitrary shapes.<br>
//! The arguments of the operation are divided on two groups - Objects
//! (shapes that will be split) and Tools (shapes by which the objects will be split).<br>
//! The result of the operation contains only the split parts of the Objects.<br>
//! The split parts of the Tools are excluded from the result.<br>
//! If there are no Tool shapes, the operation will be equivalent to General Fuse.<br>
//! The **Splitter algorithm** is the algorithm for splitting a group of
//! arbitrary shapes by the other group of arbitrary shapes.<br>
//! The arguments of the operation are divided on two groups:<br>
//! *Objects* - shapes that will be split;<br>
//! *Tools* - shapes by which the *Objects* will be split.<br>
//! The result of the operation contains only the split parts
//! of the shapes from the group of *Objects*.<br>
//! The split parts of the shapes from the group of *Tools* are excluded
//! from the result.<br>
//! The shapes can be split by the other shapes from the same group
//! (in case these shapes are interfering).
//!
//! All options of the General Fuse algorithm, such as Fuzzy mode, safe mode, parallel
//! mode, gluing mode and history support are also available in this algorithm.<br>
//! 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.<br>
//! 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 implementation of the algorithm is minimal - only the methods
//! CheckData() and Perform() have been overridden.<br>