1 Boolean Operations {#occt_user_guides__boolean_operations}
2 =========================
6 @section occt_algorithms_1 Introduction
8 This document provides a comprehensive description of the Boolean Operation Algorithm (BOA) as it is implemented in Open CASCADE Technology. The Boolean Component contains:
10 * General Fuse Operator (GFA),
11 * Boolean Operator (BOA),
12 * Section Operator (SA),
13 * Splitter Operator (SPA).
15 GFA is the base algorithm for BOA, SPA, SA.
17 GFA has a history-based architecture designed to allow using OCAF naming functionality. The architecture of GFA is expandable, that allows creating new algorithms basing on it.
20 @section occt_algorithms_2 Overview
22 @subsection occt_algorithms_2_1 Operators
24 @subsubsection occt_algorithms_2_1_1 Boolean operator
26 The Boolean operator provides the operations (Common, Fuse, Cut) between two groups: *Objects* and *Tools*. Each group consists of an arbitrary number of arguments in terms of *TopoDS_Shape*.
28 The operator can be represented as:
30 <i>R<sub>B</sub>=B<sub>j</sub> (G<sub>1</sub>, G<sub>2</sub>),</i>
33 * *R<sub>B</sub>* -- result of the operation;
34 * *B<sub>j</sub>* -- operation of type *j* (Common, Fuse, Cut);
35 * *G<sub>1</sub>={S<sub>11</sub>, S<sub>12</sub> ... S<sub>1n1</sub>}* group of arguments (Objects);
36 * *G<sub>2</sub>={S<sub>21</sub>, S<sub>22</sub> ... S<sub>2n2</sub>}* group of arguments (Tools);
37 * *n<sub>1</sub>* -- Number of arguments in *Objects* group;
38 * *n<sub>2</sub>* -- Number of arguments in *Tools* group.
41 **Note** There is an operation *Cut21*, which is an extension for forward Cut operation, i.e <i>Cut21=Cut(G2, G1)</i>.
43 For more details see @ref occt_algorithms_9 "Boolean Operations Algorithm" section.
45 @subsubsection occt_algorithms_2_1_2 General Fuse operator
47 The General fuse operator can be applied to an arbitrary number of arguments in terms of *TopoDS_Shape*.
49 The GFA operator can be represented as:
51 <i>R<sub>GF</sub> = GF (S<sub>1</sub>, S<sub>2</sub> ... S<sub>n</sub>), </i>
54 * *R<sub>GF</sub>* -- result of the operation,
55 * *S<sub>1</sub>, S<sub>2</sub> ... S<sub>n</sub>* -- arguments of the operation,
56 * *n* -- number of arguments.
58 The result of the Boolean operator, *R<sub>B</sub>*, can be obtained from *R<sub>GF</sub>*.
60 For example, for two arguments *S<sub>1</sub>* and *S<sub>2</sub>* the result *R<sub>GF</sub>* is
62 <i>R<sub>GF</sub> = GF (S<sub>1</sub>, S<sub>2</sub>) = S<sub>p1</sub> + S<sub>p2</sub> + S<sub>p12</sub></i>
64 @figure{/user_guides/boolean_operations/images/operations_image001.svg,"Operators",320}
66 This Figure shows that
67 * <i>B<sub>common</sub> (S<sub>1</sub>, S<sub>2</sub>) = S<sub>p12</sub>;</i>
68 * <i>B<sub>cut12</sub> (S<sub>1</sub>, S<sub>2</sub>) = S<sub>p1</sub>;</i>
69 * <i>B<sub>cut21</sub> (S<sub>1</sub>, S<sub>2</sub>) = S<sub>p2</sub>;</i>
70 * <i>B<sub>fuse</sub> (S<sub>1</sub>, S<sub>2</sub>) = S<sub>p1</sub>+S<sub>p2</sub>+S<sub>p12</sub></i>
72 <i>R<sub>GF</sub>=GF (S<sub>1</sub>, S<sub>2</sub>) = B<sub>fuse</sub> = B<sub>common</sub>+ B<sub>cut12</sub>+ B<sub>cut21</sub>.</i>
74 The fact that *R<sub>GF</sub>* contains the components of *R<sub>B</sub>* allows considering GFA as the general case of BOA. So it is possible to implement BOA as a subclass of GFA.
76 For more details see @ref occt_algorithms_7 "General Fuse Algorithm" section.
78 @subsubsection occt_algorithms_2_1_3 Splitter operator
80 The Splitter operator can be applied to an arbitrary number of arguments in terms of *TopoDS_Shape*. The arguments are divided into two groups: *Objects* and *Tools*. The result of *SPA* contains all parts that belong to the *Objects* but does not contain the parts that belong to the *Tools*.
82 The *SPA* operator can be represented as follows:
84 <i>R<sub>SPA</sub>=SPA (G<sub>1</sub>, G<sub>2</sub>),</i>
86 * <i>R<sub>SPA</sub></i> -- is the result of the operation;
87 * *G<sub>1</sub>={S<sub>11</sub>, S<sub>12</sub> ... S<sub>1n1</sub>}* group of arguments (*Objects*);
88 * *G<sub>2</sub>={S<sub>21</sub>, S<sub>22</sub> ... S<sub>2n2</sub>}* group of arguments (*Tools*);
89 * *n<sub>1</sub>* -- Number of arguments in *Objects* group;
90 * *n<sub>2</sub>* -- Number of arguments in *Tools* group.
92 The result *R<sub>SPA</sub>* can be obtained from *R<sub>GF</sub>* .
94 For example, for two arguments *S<sub>1</sub>* and *S<sub>2</sub>* the result *R<sub>SPA</sub>* is
96 <i>R<sub>SPA</sub>=SPA(S<sub>1</sub>,S<sub>2</sub>)=S<sub>p1</sub>+S<sub>p12</sub>.</i>
98 In case when all arguments of the *SPA* are *Objects* and there are no *Tools*, the result of *SPA* is equivalent to the result of *GFA*.
100 For example, when *G<sub>1</sub>* consists of shapes *S<sub>1</sub>* and *S<sub>2</sub>* the result of *SPA* is
102 <i>R<sub>SPA</sub>=SPA(S<sub>1</sub>, S<sub>2</sub>) = S<sub>p1</sub> + S<sub>p2</sub> + S<sub>p12</sub> = GF (S<sub>1</sub>, S<sub>2</sub>)</i>
104 The fact that the *R<sub>GF</sub>* contains the components of *R<sub>SPA</sub>* allows considering *GFA* as the general case of *SPA*. Thus, it is possible to implement *SPA* as a subclass of *GFA*.
106 For more details see @ref occt_algorithms_8 "Splitter Algorithm" section.
108 @subsubsection occt_algorithms_2_1_4 Section operator
110 The Section operator *SA* can be applied to arbitrary number of arguments in terms of *TopoDS_Shape*. The result of *SA* contains vertices and edges in accordance with interferences between the arguments
111 The SA operator can be represented as follows:
112 <i>R<sub>SA</sub>=SA(S1, S2… Sn)</i>, where
113 * <i>R<sub>SA</sub></i> -- the operation result;
114 * <i>S1, S2 ... Sn</i> -- the operation arguments;
115 * *n* -- the number of arguments.
117 For more details see @ref occt_algorithms_10a "Section Algorithm" section.
119 @subsection occt_algorithms_2_2 Parts of algorithms
121 GFA, BOA, SPA and SA have the same Data Structure (DS). The main goal of the Data Structure is to store all necessary information for input data and intermediate results.
123 The operators consist of two main parts:
124 * Intersection Part (IP). The main goal of IP is to compute the interferences between sub-shapes of arguments. The IP uses DS to retrieve input data and store the results of intersections.
125 * Building Part (BP). The main goal of BP is to build required result of an operation. This part also uses DS to retrieve data and store the results.
127 As it follows from the definition of operator results, the main differences between GFA, BOA, SPA and SA are in the Building Part. The Intersection Part is the same for the algorithms.
129 @section occt_algorithms_3 Terms and Definitions
131 This chapter provides the background terms and definitions that are necessary to understand how the algorithms work.
133 @subsection occt_algorithms_3_1 Interferences
135 There are two groups of interferences.
137 At first, each shape having a boundary representation (vertex, edge, face) has an internal value of geometrical tolerance. The shapes interfere with each other in terms of their tolerances. The shapes that have a boundary representation interfere when there is a part of 3D space where the distance between the underlying geometry of shapes is less or equal to the sum of tolerances of the shapes. Three types of shapes: vertex, edge and face -- produce six types of **BRep interferences:**
145 At second, there are interferences that occur between a solid *Z1* and a shape *S2* when *Z1* and *S2* have no BRep interferences but *S2* is completely inside of *Z1*. These interferences are **Non-BRep interferences**. There are four possible cases:
151 @subsubsection occt_algorithms_3_1_1 Vertex/Vertex interference
153 For two vertices *Vi* and *Vj*, the distance between their corresponding 3D points is less than the sum of their tolerances *Tol(Vi)* and *Tol(Vj)*.
155 @figure{/user_guides/boolean_operations/images/operations_image002.svg,"Vertex/vertex interference",420}
157 The result is a new vertex *Vn* with 3D point *Pn* and tolerance value <i>Tol(Vn)</i>.
159 The coordinates of *Pn* and the value <i>Tol(Vn)</i> are computed as the center and the radius of the sphere enclosing the tolerance spheres of the source vertices <i>(V1, V2)</i>.
161 @subsubsection occt_algorithms_3_1_2 Vertex/Edge interference
163 For a vertex *Vi* and an edge *Ej*, the distance *D* between 3D point of the vertex and its projection on the 3D curve of edge *Ej* is less or equal than sum of tolerances of vertex *Tol(Vi)* and edge *Tol(Ej)*.
165 @figure{/user_guides/boolean_operations/images/operations_image003.svg,"Vertex/edge interference",420}
167 The result is vertex *Vi* with the corresponding tolerance value <i>Tol(Vi)=Max(Tol(Vi), D+Tol(Ej))</i>, where <i>D = distance (Pi, PPi)</i>;
169 and parameter *t<sub>i</sub>* of the projected point *PPi* on 3D curve *Cj* of edge *Ej*.
171 @subsubsection occt_algorithms_3_1_3 Vertex/Face interference
173 For a vertex *Vi* and a face *Fj* the distance *D* between 3D point of the vertex and its projection on the surface of the face is less or equal than sum of tolerances of the vertex *Tol(Vi)* and the face *Tol(Fj)*.
175 @figure{/user_guides/boolean_operations/images/operations_image004.svg,"Vertex/face interference",420}
177 The result is vertex *Vi* with the corresponding tolerance value <i>Tol(Vi)=Max(Tol(Vi), D+Tol(Fj))</i>, where <i>D = distance (Pi, PPi)</i>
179 and parameters <i>u<sub>i</sub>, v<sub>i</sub></i> of the projected point *PPi* on surface *Sj* of face *Fj*.
181 @subsubsection occt_algorithms_3_1_4 Edge/Edge interference
183 For two edges *Ei* and *Ej* (with the corresponding 3D curves *Ci* and *Cj*) there are some places where the distance between the curves is less than (or equal to) sum of tolerances of the edges.
185 Let us examine two cases:
187 In the first case two edges have one or several common parts of 3D curves in terms of tolerance.
189 @figure{/user_guides/boolean_operations/images/operations_image005.svg,"Edge/edge interference: common parts",420}
192 * Parametric range <i>[t<sub>i1</sub>, t<sub>i2</sub> ]</i> for 3D curve *Ci* of edge *Ei*.
193 * Parametric range <i>[t<sub>j1</sub>, t<sub>j2</sub> ]</i> for 3D curve *Cj* of edge *Ej*.
195 In the second case two edges have one or several common points in terms of tolerance.
197 @figure{/user_guides/boolean_operations/images/operations_image006.svg,"Edge/edge interference: common points",420}
199 The result is a new vertex *Vn* with 3D point *Pn* and tolerance value *Tol(Vn)*.
201 The coordinates of *Pn* and the value *Tol(Vn)* are computed as the center and the radius of the sphere enclosing the tolerance spheres of the corresponding nearest points *Pi*, *Pj* of 3D curves *Ci*, *Cj* of source edges *Ei*, *Ej*.
203 * Parameter *t<sub>i</sub>* of *Pi* for the 3D curve *Ci*.
204 * Parameter *t<sub>j</sub>* of *Pj* for the 3D curve *Cj*.
206 @subsubsection occt_algorithms_3_1_5 Edge/Face interference
208 For an edge *Ei* (with the corresponding 3D curve *Ci*) and a face *Fj* (with the corresponding 3D surface *Sj*) there are some places in 3D space, where the distance between *Ci* and surface *Sj* is less than (or equal to) the sum of tolerances of edge *Ei* and face *Fj*.
210 Let us examine two cases:
212 In the first case Edge *Ei* and Face *Fj* have one or several common parts in terms of tolerance.
214 @figure{/user_guides/boolean_operations/images/operations_image007.svg,"Edge/face interference: common parts",420}
216 The result is a parametric range <i>[t<sub>i1</sub>, t<sub>i2</sub>]</i> for the 3D curve *Ci* of the edge *Ei*.
218 In the second case Edge *Ei* and Face *Fj* have one or several common points in terms of tolerance.
220 @figure{/user_guides/boolean_operations/images/operations_image008.svg,"Edge/face interference: common points",420}
222 The result is a new vertex *Vn* with 3D point *Pn* and tolerance value *Tol(Vn)*.
224 The coordinates of *Pn* and the value *Tol(Vn)* are computed as the center and the radius of the sphere enclosing the tolerance spheres of the corresponding nearest points *Pi*, *Pj* of 3D curve *Ci* and surface *Sj* of source edges *Ei*, *Fj*.
226 * Parameter *t<sub>i</sub>* of *Pi* for the 3D curve *Ci*.
227 * Parameters *u<sub>i</sub>* and *v<sub>i</sub>* of the projected point *PPi* on the surface *Sj* of the face *Fj*.
229 @subsubsection occt_algorithms_3_1_6 Face/Face Interference
231 For a face *Fi* and a face *Fj* (with the corresponding surfaces *Si* and *Sj*) there are some places in 3D space, where the distance between the surfaces is less than (or equal to) sum of tolerances of the faces.
233 @figure{/user_guides/boolean_operations/images/operations_image009.svg,"Face/face interference: common curves",418}
235 In the first case the result contains intersection curves *C<sub>ijk</sub> (k = 0, 1, 2…k<sub>N</sub>,* where *k<sub>N</sub>* is the number of intersection curves with corresponding values of tolerances *Tol(C<sub>ijk</sub>)*.
237 @figure{/user_guides/boolean_operations/images/operations_image010.svg,"Face/face interference: common points",305}
239 In the second case Face *Fi* and face *Fj* have one or several new vertices *V<sub>ijm</sub>*, where <i>m=0,1,2, ... mN, mN </i> is the number of intersection points.
241 The coordinates of a 3D point *P<sub>ijm</sub>* and the value *Tol(V<sub>ijm</sub>)* are computed as the center and the radius of the sphere enclosing the tolerance spheres of the corresponding nearest points *Pi*, *Pj* of the surface *Si*, *Sj* of source shapes *Fi*, *Fj*.
243 * Parameters *u<sub>j</sub>*, *v<sub>j</sub>* belong to point *PPj* projected on surface *Sj* of face *Fj*.
244 * Parameters *u<sub>i</sub>* and *v<sub>i</sub>* belong to point *PPi* projected on surface *Si* of face *Fi*.
246 @subsubsection occt_algorithms_3_1_7 Vertex/Solid Interference
248 For a vertex *Vi* and a solid *Zj* there is Vertex/Solid interference if the vertex *Vi* has no BRep interferences with any sub-shape of *Zj* and *Vi* is completely inside the solid *Zj*.
250 @figure{/user_guides/boolean_operations/images/operations_image060.png,"Vertex/Solid Interference",220}
252 @subsubsection occt_algorithms_3_1_8 Edge/Soild Interference
254 For an edge *Ei* and a solid *Zj* there is Edge/Solid interference if the edge *Ei* and its sub-shapes have no BRep interferences with any sub-shape of *Zj* and *Ei* is completely inside the solid *Zj*.
256 @figure{/user_guides/boolean_operations/images/operations_image061.png,"Edge/Solid Interference",220}
258 @subsubsection occt_algorithms_3_1_9 Face/Soild Interference
260 For a face *Fi* and a solid *Zj* there is Face/Solid interference if the face *Fi* and its sub-shapes have no BRep interferences with any sub-shape of *Zj* and *Fi* is completely inside the solid *Zj*.
262 @figure{/user_guides/boolean_operations/images/operations_image062.png,"Face/Solid Interference",220}
264 @subsubsection occt_algorithms_3_1_10 Solid/Soild Interference
266 For a solid *Zi* and a solid *Zj* there is Solid/Solid interference if the solid *Zi* and its sub-shapes have no BRep interferences with any sub-shape of *Zj* and *Zi* is completely inside the solid *Zj*.
268 @figure{/user_guides/boolean_operations/images/operations_image063.png,"Solid/Solid Interference",220}
271 @subsubsection occt_algorithms_3_1_11 Computation Order
273 The interferences between shapes are computed on the basis of increasing of the dimension value of the shape in the following order:
285 This order allows avoiding the computation of redundant interferences between upper-level shapes *Si* and *Sj* when there are interferences between lower sub-shapes *Sik* and *Sjm*.
287 @subsubsection occt_algorithms_3_1_12 Results
289 * The result of the interference is a shape that can be either interfered shape itself (or its part) or a new shape.
290 * The result of the interference is a shape with the dimension value that is less or equal to the minimal dimension value of interfered shapes. For example, the result of Vertex/Edge interference is a vertex, but not an edge.
291 * The result of the interference splits the source shapes on the parts each time as it can do that.
293 @subsection occt_algorithms_3_2 Paves
295 The result of interferences of the type Vertex/Edge, Edge/Edge and Edge/Face in most cases is a vertex (new or old) lying on an edge.
297 The result of interferences of the type Face/Face in most cases is intersection curves, which go through some vertices lying on the faces.
299 The position of vertex *Vi* on curve *C* can be defined by a value of parameter <i>t<sub>i</sub></i> of the 3D point of the vertex on the curve.
300 Pave *PVi* on curve *C* is a structure containing the vertex *Vi* and correspondent value of the parameter <i>t<sub>i</sub></i> of the 3D point of the vertex on the curve. Curve *C* can be a 3D or a 2D curve.
302 @figure{/user_guides/boolean_operations/images/operations_image011.svg,"Paves",340}
304 Two paves *PV1* and *PV2* on the same curve *C* can be compared using the parameter value @code PV1 > PV2 if t1 > t2 @endcode
306 The usage of paves allows binding of the vertex to the curve (or any structure that contains a curve: edge, intersection curve).
309 @subsection occt_algorithms_3_3 Pave Blocks
311 A set of paves *PVi (i=1, 2...nPV)*, where *nPV* is the number of paves] of curve *C* can be sorted in the increasing order using the value of parameter *t* on curve *C*.
313 A pave block *PBi* is a part of the object (edge, intersection curve) between neighboring paves.
315 @figure{/user_guides/boolean_operations/images/operations_image012.svg,"Pave Blocks",340}
317 Any finite source edge *E* has at least one pave block that contains two paves *PVb* and *PVe*:
318 * Pave *PVb* corresponds to the vertex *Vb* with minimal parameter <i>t<sub>b</sub></i> on the curve of the edge.
319 * Pave *PVe* corresponds to the vertex *Ve* with maximal parameter <i>t<sub>e</sub></i> on the curve of the edge.
321 @subsection occt_algorithms_3_4 Shrunk Range
323 Pave block *PV* of curve *C* is bounded by vertices *V1* and *V2* with tolerance values *Tol(V1)* and *Tol(V2)*. Curve *C* has its own tolerance value *Tol(C)*:
324 * In case of edge, the tolerance value is the tolerance of the edge.
325 * In case of intersection curve, the tolerance value is obtained from an intersection algorithm.
327 @figure{/user_guides/boolean_operations/images/operations_image013.svg,"Shrunk Range",340}
329 The theoretical parametric range of the pave block is <i>[t1C, t2C]</i>.
331 The positions of the vertices *V1* and *V2* of the pave block can be different. The positions are determined by the following conditions:
333 Distance (P1, P1c) is equal or less than Tol(V1) + Tol(C)
334 Distance (P2, P2c) is equal or less than Tol(V2) + Tol(C)
336 The Figure shows that each tolerance sphere of a vertex can reduce the parametric range of the pave block to a range <i>[t1S, t2S]</i>. The range <i>[t1S, t2S]</i> is the shrunk range of the pave block.
338 The shrunk range of the pave block is the part of 3D curve that can interfere with other shapes.
340 @subsection occt_algorithms_3_5 Common Blocks
342 The interferences of the type Edge/Edge, Edge/Face produce results as common parts.
344 In case of Edge/Edge interference the common parts are pave blocks that have different base edges.
346 @figure{/user_guides/boolean_operations/images/operations_image014.svg,"Common Blocks: Edge/Edge interference",340}
348 If the pave blocks <i>PB<sub>1</sub>, PB<sub>2</sub>…PB<sub>NbPB</sub></i> , where *NbPB* is the number of pave blocks have the same bounding vertices and geometrically coincide, the pave blocks form common block *CB*.
351 In case of Edge/Face interference the common parts are pave blocks lying on a face(s).
353 @figure{/user_guides/boolean_operations/images/operations_image015.svg,"Common Blocks: Edge/Face interference",265}
355 If the pave blocks *PBi* geometrically coincide with a face *Fj*, the pave blocks form common block *CB*.
357 In general case a common block *CB* contains:
358 * Pave blocks *PBi (i=0,1,2, 3… NbPB)*.
359 * A set of faces *Fj (j=0,1... NbF), NbF* -- number of faces.
362 @subsection occt_algorithms_3_6 FaceInfo
364 The structure *FaceInfo* contains the following information:
365 * Pave blocks that have state **In** for the face;
366 * Vertices that have state **In** for the face;
367 * Pave blocks that have state **On** for the face;
368 * Vertices that have state **On** for the face;
369 * Pave blocks built up from intersection curves for the face;
370 * Vertices built up from intersection points for the face.
372 @figure{/user_guides/boolean_operations/images/operations_image016.svg,"Face Info",420}
374 In the figure, for face *F1*:
375 * Pave blocks that have state **In** for the face: *PB<sub>in1</sub>*.
376 * Vertices that have state **In** for the face: *V<sub>in1</sub>*.
377 * Pave blocks that have state **On** for the face: *PB<sub>on11</sub>*, *PB<sub>on12</sub>*, *PB<sub>on2</sub>*, *PB<sub>on31</sub>*, *PB<sub>on32</sub>*, *PB<sub>on4</sub>*.
378 * Vertices that have state **On** for the face: *V1, V2, V3, V4, V5, V6*.
379 * Pave blocks built up from intersection curves for the face: *PB<sub>sc1</sub>*.
380 * Vertices built up from intersection points for the face: none
383 @section occt_algorithms_4 Data Structure
385 Data Structure (DS) is used to:
386 * Store information about input data and intermediate results;
387 * Provide the access to the information;
388 * Provide the links between the chunks of information.
390 This information includes:
397 Data Structure is implemented in the class *BOPDS_DS*.
399 @subsection occt_algorithms_4_1 Arguments
401 The arguments are shapes (in terms of *TopoDS_Shape*):
402 * Number of arguments is unlimited.
403 * Each argument is a valid shape (in terms of *BRepCheck_Analyzer*).
404 * Each argument can be of one of the following types (see the Table):
406 | No | Type | Index of Type |
407 | :----- | :----- | :----- |
409 | 2 | COMPSOLID | 1 |
417 * The argument of type *0 (COMPOUND)* can include any number of shapes of an arbitrary type (0, 1…7).
418 * The argument should not be self-interfered, i.e. all sub-shapes of the argument that have geometrical coincidence through any topological entities (vertices, edges, faces) must share these entities.
419 * There are no restrictions on the type of underlying geometry of the shapes. The faces or edges of arguments *S<sub>i</sub>* can have underlying geometry of any type supported by Open CASCADE Technology modeling algorithms (in terms of *GeomAbs_CurveType* and *GeomAbs_SurfaceType*).
420 * The faces or edges of the arguments should have underlying geometry with continuity that is not less than C1.
422 @subsection occt_algorithms_4_2 Shapes
424 The information about Shapes is stored in structure *BOPDS_ShapeInfo*. The objects of type *BOPDS_ShapeInfo* are stored in the container of array type. The array allows getting the access to the information by an index (DS index).
425 The structure *BOPDS_ShapeInfo* has the following contents:
429 | :-------- | :----- |
430 | *myShape* | Shape itself |
431 | *myType* | Type of shape |
432 | *myBox* | 3D bounding box of the shape |
433 | *mySubShapes* | List of DS indices of sub-shapes |
434 | *myReference* | Storage for some auxiliary information |
435 | *myFlag* | Storage for some auxiliary information |
437 @subsection occt_algorithms_4_3 Interferences
439 The information about interferences is stored in the instances of classes that are inherited from class <i>BOPDS_Interf</i>.
443 | *BOPDS_Interf* | Root class for interference |
444 | *Index1* | DS index of the shape 1 |
445 | *Index2* | DS index of the shape 2 |
446 | *BOPDS_InterfVV* | Storage for Vertex/Vertex interference |
447 | *BOPDS_InterfVE* | Storage for Vertex/Edge interference |
448 | *myParam* | The value of parameter of the point of the vertex on the curve of the edge |
449 | *BOPDS_InterfVF* | Storage for Vertex/Face interference |
450 | *myU, myV* | The value of parameters of the point of the vertex on the surface of the face |
451 | *BOPDS_InterfEE* | Storage for Edge/Edge interference |
452 | *myCommonPart* | Common part (in terms of *IntTools_CommonPart* ) |
453 | *BOPDS_InterfEF* | Storage for Edge/Face interference |
454 | *myCommonPart* | Common part (in terms of *IntTools_CommonPart* ) |
455 | *BOPDS_InterfFF* | Storage for Face/Face interference |
456 | *myTolR3D, myTolR2D* | The value of tolerances of curves (points) reached in 3D and 2D |
457 | *myCurves* | Intersection Curves (in terms of *BOPDS_Curve*) |
458 | *myPoints* | Intersection Points (in terms of *BOPDS_Point*) |
459 | *BOPDS_InterfVZ* | Storage for Vertex/Solid interference |
460 | *BOPDS_InterfEZ* | Storage for Edge/Solid interference |
461 | *BOPDS_InterfFZ* | Storage for Face/Solid interference |
462 | *BOPDS_InterfZZ* | Storage for Solid/Solid interference |
468 The Figure shows inheritance diagram for *BOPDS_Interf* classes.
470 @figure{/user_guides/boolean_operations/images/operations_image017.svg,"BOPDS_Interf classes",420}
473 @subsection occt_algorithms_4_4 Pave, PaveBlock and CommonBlock
475 The information about the pave is stored in objects of type *BOPDS_Pave*.
480 | *myIndex* | DS index of the vertex |
481 | *myParam* | Value of the parameter of the 3D point of vertex on curve. |
483 The information about pave blocks is stored in objects of type *BOPDS_PaveBlock*.
487 | *BOPDS_PaveBlock* | |
488 | *myEdge* | DS index of the edge produced from the pave block |
489 | *myOriginalEdge* | DS index of the source edge |
490 | *myPave1* | Pave 1 (in terms of *BOPDS_Pave*) |
491 | *myPave2* | Pave 2 (in terms of *BOPDS_Pave*) |
492 | *myExtPaves* | The list of paves (in terms of *BOPDS_Pave*) that is used to store paves lying inside the pave block during intersection process |
493 | *myCommonBlock* | The reference to common block (in terms of *BOPDS_CommonBlock*) if the pave block is a common block |
494 | *myShrunkData* | The shrunk range of the pave block |
496 * To be bound to an edge (or intersection curve) the structures of type *BOPDS_PaveBlock* are stored in one container of list type <i>(BOPDS_ListOfPaveBlock)</i>.
497 * In case of edge, all the lists of pave blocks above are stored in one container of array type. The array allows getting the access to the information by index of the list of pave blocks for the edge. This index (if exists) is stored in the field *myReference*.
499 The information about common block is stored in objects of type *BOPDS_CommonBlock*.
503 | *BOPDS_CommonBlock* | |
504 | *myPaveBlocks* | The list of pave blocks that are common in terms of @ref occt_algorithms_3_5 "Common Blocks" |
505 | *myFaces* | The list of DS indices of the faces, on which the pave blocks lie. |
508 @subsection occt_algorithms_4_5 Points and Curves
509 The information about intersection point is stored in objects of type *BOPDS_Point*.
514 | *myPnt* | 3D point |
515 | *myPnt2D1* | 2D point on the face1 |
516 | *myPnt2D2* | 2D point on the face2 |
518 The information about intersection curve is stored in objects of type *BOPDS_Curve*.
523 | *myCurve* | The intersection curve (in terms of *IntTools_Curve* ) |
524 | *myPaveBlocks* | The list of pave blocks that belong to the curve |
525 | *myBox* | The bounding box of the curve (in terms of *Bnd_Box* ) |
527 @subsection occt_algorithms_4_6 FaceInfo
528 The information about *FaceInfo* is stored in a structure *BOPDS_FaceInfo*.
529 The structure *BOPDS_FaceInfo* has the following contents.
533 | *BOPDS_FaceInfo* | |
534 | *myPaveBlocksIn* | Pave blocks that have state In for the face |
535 | *myVerticesIn* | Vertices that have state In for the face |
536 | *myPaveBlocksOn* | Pave blocks that have state On for the face |
537 | *myVerticesOn* | Vertices that have state On for the face |
538 | *myPaveBlocksSc* | Pave blocks built up from intersection curves for the face |
539 | *myVerticesSc* | Vertices built up from intersection points for the face +
541 The objects of type *BOPDS_FaceInfo* are stored in one container of array type. The array allows getting the access to the information by index. This index (if exists) is stored in the field *myReference*.
543 @section occt_algorithms_root_classes Root Classes
545 @subsection occt_algorithms_root_classes_1 Class BOPAlgo_Options
546 The class *BOPAlgo_Options* provides the following options for the algorithms:
547 * Set the appropriate memory allocator;
548 * Check the presence of the Errors and Warnings;
549 * Turn on/off the parallel processing;
550 * Set the additional tolerance for the operation;
551 * Break the operations by user request;
552 * Usage of Oriented Bounding boxes in the operation.
554 @subsection occt_algorithms_root_classes_2 Class BOPAlgo_Algo
556 The class *BOPAlgo_Algo* provides the base interface for all algorithms:
557 * Perform the operation;
558 * Check the input data;
561 @section occt_algorithms_5 Intersection Part
563 Intersection Part (IP) is used to
564 * Initialize the Data Structure;
565 * Compute interferences between the arguments (or their sub-shapes);
566 * Compute same domain vertices, edges;
568 * Build section edges;
570 * Store all obtained information in DS.
572 IP is implemented in the class *BOPAlgo_PaveFiller*.
574 @figure{/user_guides/boolean_operations/images/operations_image064.png,"Diagram for Class BOPAlgo_PaveFiller",230}
576 The description provided in the next paragraphs is coherent with the implementation of the method *BOPAlgo_PaveFiller::Perform()*.
578 @subsection occt_algorithms_5_1 Initialization
579 The input data for the step is the Arguments. The description of initialization step is shown in the Table.
581 | No | Contents | Implementation |
582 | :--- | :----- | :----- |
583 | 1 | Initialization the array of shapes (in terms of @ref occt_algorithms_4_2 "Shapes"). Filling the array of shapes. | *BOPDS_DS::Init()* |
584 | 2 | Initialization the array pave blocks (in terms of @ref occt_algorithms_4_4 "Pave, PaveBlock, CommonBlock") | *BOPDS_DS::Init()* |
585 | 3 | Initialization of intersection Iterator. The intersection Iterator is the object that computes intersections between sub-shapes of the arguments in terms of bounding boxes. The intersection Iterator provides approximate number of the interferences for given type (in terms of @ref occt_algorithms_3_1 "Interferences") | *BOPDS_Iterator* |
586 | 4 | Initialization of intersection Context. The intersection Context is an object that contains geometrical and topological toolkit (classifiers, projectors, etc). The intersection Context is used to cache the tools to increase the algorithm performance. | *IntTools_Context* |
589 @subsection occt_algorithms_5_2 Compute Vertex/Vertex Interferences
591 The input data for this step is the DS after the @ref occt_algorithms_5_1 "Initialization". The description of this step is shown in the table :
594 | No | Contents | Implementation |
595 | :--- | :---- | :----- |
596 | 1 | Initialize array of Vertex/Vertex interferences. | *BOPAlgo_PaveFiller::PerformVV()* |
597 | 2 | Access to the pairs of interfered shapes <i>(nVi, nVj)k, k=0, 1…nk,</i> where *nVi* and *nVj* are DS indices of vertices *Vi* and *Vj* and *nk* is the number of pairs. | *BOPDS_Iterator* |
598 | 3 | Compute the connexity chains of interfered vertices *nV1C, nV2C… nVnC)k, C=0, 1…nCs*, where *nCs* is the number of the connexity chains | *BOPAlgo_Tools::MakeBlocksCnx()* |
599 | 4 | Build new vertices from the chains *VNc. C=0, 1…nCs.* | *BOPAlgo_PaveFiller::PerformVV()* |
600 | 5 | Append new vertices in DS. | *BOPDS_DS::Append()* |
601 | 6 | Append same domain vertices in DS. | *BOPDS_DS::AddShapeSD()* |
602 | 7 | Append Vertex/Vertex interferences in DS. | *BOPDS_DS::AddInterf()* |
604 * The pairs of interfered vertices are: <i>(nV11, nV12), (nV11, nV13), (nV12, nV13), (nV13, nV15), (nV13, nV14), (nV14, nV15), (nV21, nV22), (nV21, nV23), (nV22, nV23);</i>
605 * These pairs produce two chains: <i>(nV11, nV12, nV13, nV14, nV15)</i> and <i>(nV21, nV22, nV23);</i>
606 * Each chain is used to create a new vertex, *VN1* and *VN2*, correspondingly.
608 The example of connexity chains of interfered vertices is given in the image:
610 @figure{/user_guides/boolean_operations/images/operations_image018.svg,"Connexity chains of interfered vertices",394}
613 @subsection occt_algorithms_5_3 Compute Vertex/Edge Interferences
615 The input data for this step is the DS after computing Vertex/Vertex interferences.
617 | No | Contents | Implementation |
618 | :--- | :--- | :--- |
619 | 1 | Initialize array of Vertex/Edge interferences | *BOPAlgo_PaveFiller::PerformVE()* |
620 | 2 | Access to the pairs of interfered shapes <i>(nVi, nEj)k k=0, 1…nk,</i> where *nVi* is DS index of vertex *Vi*, *nEj* is DS index of edge *Ej* and *nk* is the number of pairs. | *BOPDS_Iterator* |
621 | 3 | Compute paves. See @ref occt_algorithms_3_1_2 "Vertex/Edge Interference" | *BOPInt_Context::ComputeVE()* |
622 | 4 | Initialize pave blocks for the edges *Ej* involved in the interference | *BOPDS_DS:: ChangePaveBlocks()* |
623 | 5 | Append the paves into the pave blocks in terms of @ref occt_algorithms_4_4 "Pave, PaveBlock and CommonBlock" | *BOPDS_PaveBlock:: AppendExtPave()* |
624 | 6 | Append Vertex/Edge interferences in DS | *BOPDS_DS::AddInterf()* |
626 @subsection occt_algorithms_5_4 Update Pave Blocks
627 The input data for this step is the DS after computing Vertex/Edge Interferences.
629 | No | Contents | Implementation |
630 | :--- | :---- | :--- |
631 | 1 | Each pave block PB containing internal paves is split by internal paves into new pave blocks *PBN1, PBN2… PBNn*. PB is replaced by new pave blocks *PBN1, PBN2… PBNn* in the DS. | *BOPDS_DS:: UpdatePaveBlocks()* |
633 @subsection occt_algorithms_5_5 Compute Edge/Edge Interferences
635 The input data for this step is the DS after updating Pave Blocks.
637 | No | Contents | Implementation |
638 | :---- | :---- | :----- |
639 | 1 | Initialize array of Edge/Edge interferences | *BOPAlgo_PaveFiller::PerformEE()* |
640 | 2 | Access to the pairs of interfered shapes <i>(nEi, nEj)k, k=0, 1…nk,</i> where *nEi* is DS index of the edge *Ei*, *nEj* is DS index of the edge *Ej* and *nk* is the number of pairs. | *BOPDS_Iterator* |
641 | 3 | Initialize pave blocks for the edges involved in the interference, if it is necessary. | *BOPDS_DS:: ChangePaveBlocks()* |
642 | 4 | Access to the pave blocks of interfered shapes: <i>(PBi1, PBi2…PBiNi)</i> for edge *Ei* and <i>(PBj1, PBj2…PBjNj)</i> for edge *Ej* | *BOPAlgo_PaveFiller::PerformEE()* |
643 | 5 | Compute shrunk data for pave blocks in terms of @ref occt_algorithms_4_4 "Pave, PaveBlock and CommonBlock", if it is necessary. | *BOPAlgo_PaveFiller::FillShrunkData()* |
644 | 6 | Compute Edge/Edge interference for pave blocks *PBix* and *PBiy*. The result of the computation is a set of objects of type *IntTools_CommonPart* | *IntTools_EdgeEdge* |
645 | 7.1 | For each *CommonPart* of type *VERTEX:* Create new vertices *VNi (i =1, 2…,NbVN),* where *NbVN* is the number of new vertices. Intersect the vertices *VNi* using the steps Initialization and compute Vertex/Vertex interferences as follows: a) create a new object *PFn* of type *BOPAlgo_PaveFiller* with its own DS; b) use new vertices *VNi (i=1, 2…,NbVN), NbVN* as arguments (in terms of *TopoDs_Shape*) of *PFn*; c) invoke method *Perform()* for *PFn*. The resulting vertices *VNXi (i=1, 2…,NbVNX)*, where *NbVNX* is the number of vertices, are obtained via mapping between *VNi* and the results of *PVn*. | *BOPTools_Tools::MakeNewVertex()* |
646 | 7.2 | For each *CommonPart* of type *EDGE:* Compute the coinciding connexity chains of pave blocks <i>(PB1C, PB2C… PNnC)k, C=0, 1…nCs,</i> where *nCs* is the number of the connexity chains. Create common blocks <i>(CBc. C=0, 1…nCs)</i> from the chains. Attach the common blocks to the pave blocks. | *BOPAlgo_Tools::PerformCommonBlocks()* |
647 | 8 | Post-processing. Append the paves of *VNXi* into the corresponding pave blocks in terms of @ref occt_algorithms_4_4 "Pave, PaveBlock and CommonBlock" | *BOPDS_PaveBlock:: AppendExtPave()* |
648 | 9 | Split common blocks CBc by the paves. | *BOPDS_DS:: UpdateCommonBlock()* |
649 | 10 | Append Edge/Edge interferences in the DS. | *BOPDS_DS::AddInterf()* |
651 The example of coinciding chains of pave blocks is given in the image:
653 @figure{/user_guides/boolean_operations/images/operations_image019.png,"Coinciding chains of pave blocks",420}
655 * The pairs of coincided pave blocks are: <i>(PB11, PB12), (PB11, PB13), (PB12, PB13), (PB21, PB22), (PB21, PB23), (PB22, PB23).</i>
656 * The pairs produce two chains: <i>(PB11, PB12, PB13)</i> and <i>(PB21, PB22, PB23).</i>
658 @subsection occt_algorithms_5_6 Compute Vertex/Face Interferences
660 The input data for this step is the DS after computing Edge/Edge interferences.
662 | No | Contents | Implementation |
663 | :---- | :--- | :---- |
664 | 1 | Initialize array of Vertex/Face interferences | *BOPAlgo_PaveFiller::PerformVF()* |
665 | 2 | Access to the pairs of interfered shapes <i>(nVi, nFj)k, k=0, 1…nk,</i> where *nVi* is DS index of the vertex *Vi*, *nFj* is DS index of the edge *Fj* and *nk* is the number of pairs. | *BOPDS_Iterator* |
666 | 3 | Compute interference See @ref occt_algorithms_3_1_3 "Vertex/Face Interference" | *BOPInt_Context::ComputeVF()* |
667 | 4 | Append Vertex/Face interferences in the DS | *BOPDS_DS::AddInterf()* |
668 | 5 | Repeat steps 2-4 for each new vertex *VNXi (i=1, 2…,NbVNX),* where *NbVNX* is the number of vertices. | *BOPAlgo_PaveFiller::TreatVerticesEE()* |
670 @subsection occt_algorithms_5_7 Compute Edge/Face Interferences
671 The input data for this step is the DS after computing Vertex/Face Interferences.
673 | No | Contents | Implementation |
674 | :---- | :---- | :---- |
675 | 1 | Initialize array of Edge/Face interferences | *BOPAlgo_PaveFiller::PerformEF()* |
676 | 2 | Access to the pairs of interfered shapes <i>(nEi, nFj)k, k=0, 1…nk,</i> where *nEi* is DS index of edge *Ei*, *nFj* is DS index of face *Fj* and *nk* is the number of pairs. | *BOPDS_Iterator* |
677 | 3 | Initialize pave blocks for the edges involved in the interference, if it is necessary. | *BOPDS_DS::ChangePaveBlocks()* |
678 | 4 | Access to the pave blocks of interfered edge <i>(PBi1, PBi2…PBiNi)</i> for edge *Ei* | *BOPAlgo_PaveFiller::PerformEF()* |
679 | 5 | Compute shrunk data for pave blocks (in terms of @ref occt_algorithms_4_4 "Pave, PaveBlock and CommonBlock") if it is necessary. | *BOPAlgo_PaveFiller::FillShrunkData()* |
680 | 6 | Compute Edge/Face interference for pave block *PBix*, and face *nFj*. The result of the computation is a set of objects of type *IntTools_CommonPart* | *IntTools_EdgeFace* |
681 | 7.1 | For each *CommonPart* of type *VERTEX:* Create new vertices *VNi (i=1, 2…,NbVN),* where *NbVN* is the number of new vertices. Merge vertices *VNi* as follows: a) create new object *PFn* of type *BOPAlgo_PaveFiller* with its own DS; b) use new vertices *VNi (i=1, 2…,NbVN), NbVN* as arguments (in terms of *TopoDs_Shape*) of *PFn*; c) invoke method *Perform()* for *PFn*. The resulting vertices *VNXi (i=1, 2…,NbVNX)*, where *NbVNX* is the number of vertices, are obtained via mapping between *VNi* and the results of *PVn*. | *BOPTools_Tools::MakeNewVertex()* and *BOPAlgo_PaveFiller::PerformVertices1()* |
682 | 7.2 | For each *CommonPart* of type *EDGE:* Create common blocks <i>(CBc. C=0, 1…nCs)</i> from pave blocks that lie on the faces. Attach the common blocks to the pave blocks. | *BOPAlgo_Tools::PerformCommonBlocks()* |
683 | 8 | Post-processing. Append the paves of *VNXi* into the corresponding pave blocks in terms of @ref occt_algorithms_4_4 "Pave, PaveBlock and CommonBlock". | *BOPDS_PaveBlock:: AppendExtPave()* |
684 | 9 | Split pave blocks and common blocks *CBc* by the paves. | *BOPAlgo_PaveFiller::PerformVertices1()*, *BOPDS_DS:: UpdatePaveBlock()* and *BOPDS_DS:: UpdateCommonBlock()* |
685 | 10 | Append Edge/Face interferences in the DS | *BOPDS_DS::AddInterf()* |
686 | 11 | Update *FaceInfo* for all faces having EF common parts. | *BOPDS_DS:: UpdateFaceInfoIn()* |
689 @subsection occt_algorithms_5_8 Build Split Edges
691 The input data for this step is the DS after computing Edge/Face Interferences.
693 For each pave block *PB* take the following steps:
695 | No | Contents | Implementation |
696 | :--- | :--- | :--- |
697 | 1 | Get the real pave block *PBR*, which is equal to *PB* if *PB* is not a common block and to *PB<sub>1</sub>* if *PB* is a common block. *PB<sub>1</sub>* is the first pave block in the pave blocks list of the common block. See @ref occt_algorithms_4_4 "Pave, PaveBlock and CommonBlock". | *BOPAlgo_PaveFiller::MakeSplitEdges()* |
698 | 2 | Build the split edge *Esp* using the information from *DS* and *PBR*. | *BOPTools_Tools::MakeSplitEdge()* |
699 | 3 | Compute *BOPDS_ShapeInfo* contents for Esp | *BOPAlgo_PaveFiller::MakeSplitEdges()* |
700 | 4 | Append *BOPDS_ShapeInfo* contents to the DS | *BOPDS_DS::Append()* |
702 @subsection occt_algorithms_5_9 Compute Face/Face Interferences
704 The input data for this step is DS after building Split Edges.
706 | No | Contents | Implementation |
707 | :--- | :--- | :--- |
708 | 1 | Initialize array of Face/Face interferences | *BOPAlgo_PaveFiller::PerformFF()* |
709 | 2 | Access to the pairs of interfered shapes <i>(nFi, nFj)k, k=0, 1…nk,</i> where *nFi* is DS index of edge *Fi*, *nFj* is DS index of face *Fj* and *nk* is the number of pairs. | *BOPDS_Iterator* |
710 | 3 | Compute Face/Face interference | *IntTools_FaceFace* |
711 | 4 | Append Face/Face interferences in the DS. | *BOPDS_DS::AddInterf()* |
713 @subsection occt_algorithms_5_10 Build Section Edges
715 The input data for this step is the DS after computing Face/Face interferences.
717 | No | Contents | Implementation |
718 | :---- | :---- | :---- |
719 | 1 | For each Face/Face interference *nFi, nFj*, retrieve @ref occt_algorithms_4_6 "FaceInfo". Create draft vertices from intersection points *VPk (k=1, 2…, NbVP)*, where *NbVP* is the number of new vertices, and the draft vertex *VPk* is created from an intersection point if *VPk ≠ Vm (m = 0, 1, 2… NbVm)*, where *Vm* is an existing vertex for the faces *nFi* and *nF,j* (*On* or *In* in terms of *TopoDs_Shape*), *NbVm* is the number of vertices existing on faces *nFi* and *nF,j* and ≠ -- means non-coincidence in terms of @ref occt_algorithms_3_1_1 "Vertex/Vertex interference". | *BOPAlgo_PaveFiller::MakeBlocks()* |
720 | 2 | For each intersection curve *Cijk* | |
721 | 2.1 | Create paves PVc for the curve using existing vertices, i.e. vertices On or In (in terms of *FaceInfo*) for faces *nFi* and *nFj*. Append the paves *PVc* | *BOPAlgo_PaveFiller::PutPaveOnCurve()* and *BOPDS_PaveBlock::AppendExtPave()* |
722 | 2.2 | Create technological vertices *Vt*, which are the bounding points of an intersection curve (with the value of tolerance *Tol(Cijk)*). Each vertex *Vt* with parameter *Tt* on curve *Cijk* forms pave *PVt* on curve *Cijk*. Append technological paves. | *BOPAlgo_PaveFiller::PutBoundPaveOnCurve()* |
723 | 2.3 | Create pave blocks *PBk* for the curve using paves <i>(k=1, 2…, NbPB)</i>, where *NbPB* is the number of pave blocks | *BOPAlgo_PaveFiller::MakeBlocks()* |
724 | 2.4 | Build draft section edges *ESk* using the pave blocks <i>(k=1, 2…, NbES)</i>, where *NbES* is the number of draft section edges The draft section edge is created from a pave block *PBk* if *PBk* has state *In* or *On* for both faces *nFi* and *nF,j* and *PBk ≠ PBm (m=0, 1, 2… NbPBm)*, where *PBm* is an existing pave block for faces *nFi* and *nF,j* (*On* or *In* in terms of *FaceInfo*), *NbVm* is the number of existing pave blocks for faces *nFi* and *nF,j* and ≠ -- means non-coincidence (in terms of @ref occt_algorithms_3_1_3 "Vertex/Face interference"). | *BOPTools_Tools::MakeEdge()* |
725 | 3 | Intersect the draft vertices *VPk (k=1, 2…, NbVP)* and the draft section edges *ESk (k=1, 2…, NbES)*. For this: a) create new object *PFn* of type *BOPAlgo_PaveFiller* with its own DS; b) use vertices *VPk* and edges *ESk* as arguments (in terms of @ref occt_algorithms_4_1 "Arguments") of *PFn*; c) invoke method *Perform()* for *PFn*. Resulting vertices *VPXk (k=1, 2… NbVPX)* and edges *ESXk (k=1, 2… NbESX)* are obtained via mapping between *VPk, ESk* and the results of *PVn*. | *BOPAlgo_PaveFiller::PostTreatFF()* |
726 | 4 | Update face info (sections about pave blocks and vertices) | *BOPAlgo_PaveFiller::PerformFF()* |
728 @subsection occt_algorithms_5_11 Build P-Curves
729 The input data for this step is the DS after building section edges.
731 | No | Contents | Implementation |
732 | :---- | :---- | :---- |
733 | 1 | For each Face/Face interference *nFi* and *nFj* build p-Curves on *nFi* and *nFj* for each section edge *ESXk*. | *BOPAlgo_PaveFiller::MakePCurves()* |
734 | 2 | For each pave block that is common for faces *nFi* and *nFj* build p-Curves on *nFi* and *nFj*. | *BOPAlgo_PaveFiller::MakePCurves()* |
736 @subsection occt_algorithms_5_12 Process Degenerated Edges
737 The input data for this step is the DS after building P-curves.
739 | No | Contents | Implementation |
740 | :---- | :---- | :---- |
741 | | For each degenerated edge *ED* having vertex *VD* | BOPAlgo_PaveFiller::ProcessDE() |
742 | 1 | Find pave blocks *PBi (i=1,2… NbPB)*, where *NbPB* is the number of pave blocks, that go through vertex *VD*. | *BOPAlgo_PaveFiller::FindPaveBlocks()* |
743 | 2 | Compute paves for the degenerated edge *ED* using a 2D curve of *ED* and a 2D curve of *PBi*. Form pave blocks *PBDi (i=1,2… NbPBD)*, where *NbPBD* is the number of the pave blocks for the degenerated edge *ED* | *BOPAlgo_PaveFiller::FillPaves()* |
744 | 3 | Build split edges *ESDi (i=1,2…NbESD)*, where *ESD* is the number of split edges, using the pave blocks *PBDi* | *BOPAlgo_PaveFiller:: MakeSplitEdge()* |
746 @section occt_algorithms_6 General description of the Building Part
748 Building Part (BP) is used to
749 * Build the result of the operation
750 * Provide history information (in terms of <i>\::Generated(), \::Modified()</i> and <i>\::IsDeleted()</i>)
751 BP uses the DS prepared by *BOPAlgo_PaveFiller* described at chapter 5 as input data.
752 BP is implemented in the following classes:
753 * *BOPAlgo_Builder* -- for the General Fuse operator (GFA).
754 * *BOPAlgo_BOP* -- for the Boolean Operation operator (BOA).
755 * *BOPAlgo_Section* -- for the Section operator (SA).
756 * *BOPAlgo_MakerVolume* -- for the Volume Maker operator.
757 * *BOPAlgo_Splitter* -- for the Splitter operator.
758 * *BOPAlgo_CellsBuilder* -- for the Cells Builder operator.
760 @figure{/user_guides/boolean_operations/images/operations_image020.png,"Diagram for BP classes",300}
762 The class *BOPAlgo_BuilderShape* provides the interface for algorithms that have:
763 * A Shape as the result;
764 * History information (in terms of <i>\::Generated(), \::Modified()</i> and <i>\::IsDeleted()).</i>
766 @section occt_algorithms_7 General Fuse Algorithm
767 @subsection occt_algorithms_7_1 Arguments
768 The arguments of the algorithm are shapes (in terms of *TopoDS_Shape*). The main requirements for the arguments are described in @ref occt_algorithms_4 "Data Structure" chapter.
770 @subsection occt_algorithms_7_2 Results
772 During the operation argument *Si* can be split into several parts *Si1, Si2… Si1NbSp*, where *NbSp* is the number of parts. The set <i>(Si1, Si2… Si1NbSp)</i> is an image of argument *Si*.
773 * The result of the General Fuse operation is a compound. Each sub-shape of the compound corresponds to the certain argument shape S1, S2…Sn and has shared sub-shapes in accordance with interferences between the arguments.
774 * For the arguments of the type EDGE, FACE, SOLID the result contains split parts of the argument.
775 * For the arguments of the type WIRE, SHELL, COMPSOLID, COMPOUND the result contains the image of the shape of the corresponding type (i.e. WIRE, SHELL, COMPSOLID or COMPOUND).
776 The types of resulting shapes depend on the type of the corresponding argument participating in the operation. See the table below:
778 | No | Type of argument | Type of resulting shape | Comments |
779 | :--- | :---- | :--- | :--- |
780 | 1 | COMPOUND | COMPOUND | The resulting COMPOUND is built from images of sub-shapes of type COMPOUND COMPSOLID, SHELL, WIRE and VERTEX. Sets of split sub-shapes of type SOLID, FACE, EDGE. |
781 | 2 | COMPSOLID | COMPSOLID | The resulting COMPSOLID is built from split SOLIDs. |
782 | 3 | SOLID | Set of split SOLIDs | |
783 | 4 | SHELL | SHELL | The resulting SHELL is built from split FACEs |
784 | 5 | FACE | Set of split FACEs | |
785 | 6 | WIRE | WIRE | The resulting WIRE is built from split EDGEs |
786 | 7 | EDGE | Set of split EDGEs | |
787 | 8 | VERTEX | VERTEX | |
789 @subsection occt_algorithms_7_3a Options
791 The General Fuse algorithm has a set of options, which allow speeding-up the operation and improving the quality of the result:
792 * Parallel processing option allows running the algorithm in parallel mode;
793 * Fuzzy option allows setting the additional tolerance for the operation;
794 * Safe input shapes option allows preventing modification of the input shapes;
795 * Gluing option allows speeding-up the intersection of the arguments;
796 * Possibility to disable the check for the inverted solids among input shapes;
797 * Usage of Oriented Bounding Boxes in the operation;
800 For more detailed information on these options please see the @ref occt_algorithms_11a "Advanced options" section.
802 @subsection occt_algorithms_7_3b Usage
804 The following example illustrates how to use the GF algorithm:
806 #### Usage of the GF algorithm on C++ level
809 BOPAlgo_Builder aBuilder;
811 TopTools_ListOfShape aLSObjects = …; // Objects
812 aBuilder.SetArguments(aLSObjects);
814 // Setting options for GF
816 // Set parallel processing mode (default is false)
817 Standard_Boolean bRunParallel = Standard_True;
818 aBuilder.SetRunParallel(bRunParallel);
820 // Set Fuzzy value (default is Precision::Confusion())
821 Standard_Real aFuzzyValue = 1.e-5;
822 aBuilder.SetFuzzyValue(aFuzzyValue);
824 // Set safe processing mode (default is false)
825 Standard_Boolean bSafeMode = Standard_True;
826 aBuilder.SetNonDestructive(bSafeMode);
828 // Set Gluing mode for coinciding arguments (default is off)
829 BOPAlgo_GlueEnum aGlue = BOPAlgo_GlueShift;
830 aBuilder.SetGlue(aGlue);
832 // Disabling/Enabling the check for inverted solids (default is true)
833 Standard Boolean bCheckInverted = Standard_False;
834 aBuilder.SetCheckInverted(bCheckInverted);
836 // Set OBB usage (default is false)
837 Standard_Boolean bUseOBB = Standard_True;
838 aBuilder.SetUseOBB(buseobb);
840 // Perform the operation
843 // Check for the errors
844 if (aBuilder.HasErrors())
849 // Check for the warnings
850 if (aBuilder.HasWarnings())
852 // treatment of the warnings
856 // result of the operation
857 const TopoDS_Shape& aResult = aBuilder.Shape();
860 #### Usage of the GF algorithm on Tcl level
863 # prepare the arguments
865 box b2 3 4 5 10 10 10
866 box b3 5 6 7 10 10 10
868 # clear inner contents
869 bclearobjects; bcleartools;
874 # setting options for GF
876 # set parallel processing mode (default is 0)
882 # set safe processing mode (default is 0)
885 # set gluing mode (default is 0)
888 # set check for inverted (default is 1)
891 # set obb usage (default is 0)
894 # perform intersection
897 # perform GF operaton
901 @subsection occt_algorithms_7_3 Examples
903 Please, have a look at the examples, which can help to better understand the definitions.
905 @subsubsection occt_algorithms_7_3_1 Case 1: Three edges intersecting at a point
907 Let us consider three edges: *E1, E2* and *E3* that intersect in one 3D point.
909 @figure{/user_guides/boolean_operations/images/operations_image021.svg,"Three Intersecting Edges",420}
911 The result of the GFA operation is a compound containing 6 new edges: *E11, E12, E21, E22, E31*, and *E32*. These edges have one shared vertex *Vn1*.
914 * The argument edge *E1* has resulting split edges *E11* and *E12* (image of *E1*).
915 * The argument edge *E2* has resulting split edges *E21* and *E22* (image of *E2*).
916 * The argument edge *E3* has resulting split edges *E31* and *E32* (image of *E3*).
918 @subsubsection occt_algorithms_7_3_2 Case 2: Two wires and an edge
920 Let us consider two wires *W1 (Ew11, Ew12, Ew13)* and *W2 (Ew21, Ew22, Ew23)* and edge *E1*.
922 @figure{/user_guides/boolean_operations/images/operations_image022.svg,"Two wires and an edge",420}
924 The result of the GF operation is a compound consisting of 2 wires: *Wn1 (Ew11, En1, En2, En3, Ew13)* and *Wn2 (Ew21, En2, En3, En4, Ew23)* and two edges: *E11* and *E12*.
927 * The argument *W1* has image *Wn1*.
928 * The argument *W2* has image *Wn2*.
929 * The argument edge *E1* has split edges *E11* and *E12*. (image of *E1*).
930 The edges *En1, En2, En3, En4* and vertex *Vn1* are new shapes created during the operation. Edge *Ew12* has split edges *En1, En2* and *En3* and edge *Ew22* has split edges *En2, En3* and *En4*.
932 @subsubsection occt_algorithms_7_3_3 Case 3: An edge intersecting with a face
934 Let us consider edge *E1* and face *F2*:
936 @figure{/user_guides/boolean_operations/images/operations_image023.svg,"An edge intersecting with a face",420}
938 The result of the GF operation is a compound consisting of 3 shapes:
939 * Split edge parts *E11* and *E12* (image of *E1*).
940 * New face *F21* with internal edge *E12* (image of *F2*).
942 @subsubsection occt_algorithms_7_3_4 Case 4: An edge lying on a face
944 Let us consider edge *E1* and face *F2*:
946 @figure{/user_guides/boolean_operations/images/operations_image024.svg,"An edge lying on a face",420}
948 The result of the GF operation is a compound consisting of 5 shapes:
949 * Split edge parts *E11, E12* and *E13* (image of *E1*).
950 * Split face parts *F21* and *F22* (image of *F2*).
953 @subsubsection occt_algorithms_7_3_5 Case 5: An edge and a shell
955 Let us consider edge *E1* and shell *Sh2* that consists of 2 faces: *F21* and *F22*
957 @figure{/user_guides/boolean_operations/images/operations_image025.svg,"An edge and a shell",488}
959 The result of the GF operation is a compound consisting of 5 shapes:
960 * Split edge parts *E11, E12 , E13* and *E14* (image of *E1*).
961 * Image shell *Sh21* (that contains split face parts *F211, F212, F221* and *F222*).
963 @subsubsection occt_algorithms_7_3_6 Case 6: A wire and a shell
965 Let us consider wire *W1 (E1, E2, E3, E4)* and shell *Sh2 (F21, F22)*.
966 @figure{/user_guides/boolean_operations/images/operations_image026.svg,"A wire and a shell",427}
968 The result of the GF operation is a compound consisting of 2 shapes:
970 * Image wire *W11* that consists of split edge parts from wire *W1: E11, E12, E13* and *E14*.
971 * Image shell *Sh21* that contains split face parts: *F211, F212, F213, F221, F222* and *F223*.
973 @subsubsection occt_algorithms_7_3_7 Case 7: Three faces
975 Let us consider 3 faces: *F1, F2* and *F3*. @figure{/user_guides/boolean_operations/images/operations_image027.png,"Three faces",420}
977 The result of the GF operation is a compound consisting of 7 shapes:
978 * Split face parts: *Fn1, Fn2, Fn3, Fn4, Fn5, Fn6* and *Fn7*.
980 @subsubsection occt_algorithms_7_3_8 Case 8: A face and a shell
982 Let us consider shell *Sh1 (F11, F12, F13)* and face *F2*.
983 @figure{/user_guides/boolean_operations/images/operations_image028.png,"A face and a shell",420}
985 The result of the GF operation is a compound consisting of 4 shapes:
986 * Image shell *Sh11* that consists of split face parts from shell *Sh1: Fn1, Fn2, Fn3, Fn4, Fn5* and *Fn6*.
987 * Split parts of face *F2: Fn3, Fn6* and *Fn7*.
989 @subsubsection occt_algorithms_7_3_9 Case 9: A shell and a solid
991 Let us consider shell *Sh1 (F11, F12…F16)* and solid *So2*. @figure{/user_guides/boolean_operations/images/operations_image029.png,"A shell and a solid: arguments",220}
993 The result of the GF operation is a compound consisting of 2 shapes:
994 * Image shell *Sh11* consisting of split face parts of *Sh1: Fn1, Fn2 ... Fn8.*
995 * Solid *So21* with internal shell. (image of *So2*).
996 @figure{/user_guides/boolean_operations/images/operations_image030.png,"A shell and a solid: results",420}
998 @subsubsection occt_algorithms_7_3_10 Case 10: A compound and a solid
1000 Let us consider compound *Cm1* consisting of 2 solids *So11* and *So12*) and solid *So2*.
1001 @figure{/user_guides/boolean_operations/images/operations_image031.png,"A compound and a solid: arguments",220}
1003 The result of the GF operation is a compound consisting of 4 shapes:
1004 * Image compound *Cm11* consisting of split solid parts from *So11* and *So12 (Sn1, Sn2, Sn3, Sn4)*.
1005 * Split parts of solid *So2 (Sn2, Sn3, Sn5)*.
1007 @figure{/user_guides/boolean_operations/images/operations_image032.png,"A compound and a solid: results",420}
1009 @subsection occt_algorithms_7_4 Class BOPAlgo_Builder
1011 GFA is implemented in the class *BOPAlgo_Builder*.
1013 @subsubsection occt_algorithms_7_4_1 Fields
1015 The main fields of the class are described in the Table:
1019 | *myPaveFiller* | Pointer to the *BOPAlgo_PaveFiller* object |
1020 | *myDS* | Pointer to the *BOPDS_DS* object |
1021 | *myContext* | Pointer to the intersection Context |
1022 | *myImages* | The Map between the source shape and its images |
1023 | *myShapesSD* | The Map between the source shape (or split part of source shape) and the shape (or part of shape) that will be used in result due to same domain property. |
1025 @subsubsection occt_algorithms_7_4_2 Initialization
1027 The input data for this step is a *BOPAlgo_PaveFiller* object (in terms of @ref occt_algorithms_5 "Intersection") at the state after @ref occt_algorithms_5_12 "Processing of degenerated edges" with the corresponding DS.
1029 | No | Contents | Implementation |
1030 | :---- | :---- | :---- |
1031 | 1 | Check the readiness of the DS and *BOPAlgo_PaveFiller*. | *BOPAlgo_Builder::CheckData()* |
1032 | 2 | Build an empty result of type Compound. | *BOPAlgo_Builder::Prepare()* |
1034 @subsubsection occt_algorithms_7_4_3 Build Images for Vertices
1036 The input data for this step is *BOPAlgo_Builder* object after Initialization.
1038 | No | Contents | Implementation |
1039 | :--- | :--- | :--- |
1040 | 1 | Fill *myShapesSD* by SD vertices using the information from the DS. | *BOPAlgo_Builder::FillImagesVertices()* |
1042 @subsubsection occt_algorithms_7_4_4 Build Result of Type Vertex
1044 The input data for this step is *BOPAlgo_Builder* object after building images for vertices and *Type*, which is the shape type (*TopAbs_VERTEX*).
1046 | No | Contents | Implementation |
1047 | :--- | :--- | :----- |
1048 | 1 | For the arguments of type *Type*. If there is an image for the argument: add the image to the result. If there is no image for the argument: add the argument to the result. | *BOPAlgo_Builder::BuildResult()* |
1050 @subsubsection occt_algorithms_7_4_5 Build Images for Edges
1052 The input data for this step is *BOPAlgo_Builder object* after building result of type vertex.
1054 | No | Contents | Implementation |
1055 | :---- | :---- | :----- |
1056 | 1 | For all pave blocks in the DS. Fill *myImages* for the original edge *E* by split edges *ESPi* from pave blocks. In case of common blocks on edges, use edge *ESPSDj* that corresponds to the leading pave block and fill *myShapesSD* by the pairs *ESPi/ESPSDj*. | *BOPAlgo_Builder::FillImagesEdges()* |
1058 @subsubsection occt_algorithms_7_4_6 Build Result of Type Edge
1060 This step is the same as @ref occt_algorithms_7_4_4 "Building Result of Type Vertex", but for the type *Edge*.
1062 @subsubsection occt_algorithms_7_4_7 Build Images for Wires
1064 The input data for this step is:
1065 * *BOPAlgo_Builder* object after building result of type *Edge*;
1066 * Original Shape -- Wire
1067 * *Type* -- the shape type <i>(TopAbs_WIRE).</i>
1069 | No | Contents | Implementation |
1070 | :---- | :---- | :----- |
1071 | 1 | For all arguments of the type *Type*. Create a container C of the type *Type*. | *BOPAlgo_Builder::FillImagesContainers()* |
1072 | 2 | Add to C the images or non-split parts of the *Original Shape*, taking into account its orientation. | *BOPAlgo_Builder::FillImagesContainers()* *BOPTools_Tools::IsSplitToReverse()* |
1073 | 3 | Fill *myImages* for the *Original Shape* by the information above. | *BOPAlgo_Builder::FillImagesContainers()* |
1075 @subsubsection occt_algorithms_7_4_8 Build Result of Type Wire
1077 This step is the same as @ref occt_algorithms_7_4_4 "Building Result of Type Vertex" but for the type *Wire*.
1079 @subsubsection occt_algorithms_7_4_9 Build Images for Faces
1081 The input data for this step is *BOPAlgo_Builder* object after building result of type *Wire*.
1083 | No | Contents | Implementation |
1084 | :--- | :--- | :--- |
1085 | 1 | Build Split Faces for all interfered DS shapes *Fi* of type *FACE*. | |
1086 | 1.1 | Collect all edges or their images of *Fi(ESPij)*. | *BOPAlgo_Builder::BuildSplitFaces()* |
1087 | 1.2 | Impart to ESPij the orientation to be coherent with the original one. | *BOPAlgo_Builder::BuildSplitFaces()* |
1088 | 1.3 | Collect all section edges *SEk* for *Fi*. | *BOPAlgo_Builder::BuildSplitFaces()* |
1089 | 1.4 | Build split faces for *Fi (Fi1, Fi2…FiNbSp)*, where *NbSp* is the number of split parts (see @ref occt_algorithms_7_2 "Building faces from a set of edges" for more details). | *BOPAlgo_BuilderFace* |
1090 | 1.5 | Impart to <i>(Fi1, Fi2…FiNbSp)</i> the orientation coherent with the original face *Fi*. | *BOPAlgo_Builder::BuildSplitFaces()* |
1091 | 1.6 | Fill the map mySplits with *Fi/(Fi1, Fi2…FiNbSp)* | *BOPAlgo_Builder::BuildSplitFaces()* |
1092 | 2 | Fill Same Domain faces | *BOPAlgo_Builder::FillSameDomainFaces* |
1093 | 2.1 | Find and collect in the contents of *mySplits* the pairs of same domain split faces <i>(Fij, Fkl)m</i>, where *m* is the number of pairs. | *BOPAlgo_Builder::FillSameDomainFaces* *BOPTools_Tools::AreFacesSameDomain()* |
1094 | 2.2 | Compute the connexity chains 1) of same domain faces <i>(F1C, F2C… FnC)k, C=0, 1…nCs,</i> where *nCs* is the number of connexity chains. | *BOPAlgo_Builder::FillSameDomainFaces()* |
1095 | 2.3 | Fill *myShapesSD* using the chains <i>(F1C, F2C… FnC)k</i> | *BOPAlgo_Builder::FillSameDomainFaces()* |
1096 | 2.4 | Add internal vertices to split faces. | *BOPAlgo_Builder::FillSameDomainFaces()* |
1097 | 2.5 | Fill *myImages* using *myShapesSD* and *mySplits*. | *BOPAlgo_Builder::FillSameDomainFaces()* |
1100 The example of chains of same domain faces is given in the image:
1102 @figure{/user_guides/boolean_operations/images/operations_image033.svg,"Chains of same domain faces",420}
1104 * The pairs of same domain faces are: <i>(F11, F21), (F22, F31), (F41, F51) , (F41, F6)</i> and <i>(F51, F6)</i>.
1105 * The pairs produce the three chains: <i>(F11, F21), (F22, F31)</i> and <i>(F41, F51, F6)</i>.
1107 @subsubsection occt_algorithms_7_4_10 Build Result of Type Face
1108 This step is the same as @ref occt_algorithms_7_4_4 "Building Result of Type Vertex" but for the type *Face*.
1110 @subsubsection occt_algorithms_7_4_11 Build Images for Shells
1111 The input data for this step is:
1112 * *BOPAlgo_Builder* object after building result of type face;
1113 * *Original Shape* -- a Shell;
1114 * *Type* -- the type of the shape <i>(TopAbs_SHELL)</i>.
1116 The procedure is the same as for building images for wires.
1118 @subsubsection occt_algorithms_7_4_12 Build Result of Type Shell
1119 This step is the same as @ref occt_algorithms_7_4_4 "Building Result of Type Vertex" but for the type *Shell*.
1121 @subsubsection occt_algorithms_7_4_13 Build Images for Solids
1123 The input data for this step is *BOPAlgo_Builder* object after building result of type *Shell*.
1125 The following procedure is executed for all interfered DS shapes *Si* of type *SOLID*.
1127 | No | Contents | Implementation |
1128 | :--- | :--- | :--- |
1129 | 1 | Collect all images or non-split parts for all faces <i>(FSPij)</i> that have 3D state *In Si*. | *BOPAlgo_Builder::FillIn3DParts ()* |
1130 | 2 | Collect all images or non-split parts for all faces of *Si* | *BOPAlgo_Builder::BuildSplitSolids()* |
1131 | 3 | Build split solids for *Si -> (Si1, Si2…SiNbSp)*, where *NbSp* is the number of split parts (see @ref occt_algorithms_7_2 "Building faces from a set of edges" for more details) | *BOPAlgo_BuilderSolid* |
1132 | 4 | Fill the map Same Domain solids *myShapesSD* | *BOPAlgo_Builder::BuildSplitSolids()* |
1133 | 5 | Fill the map *myImages* | *BOPAlgo_Builder::BuildSplitSolids()* |
1134 | 6 | Add internal vertices to split solids | *BOPAlgo_Builder::FillInternalShapes()* |
1136 @subsubsection occt_algorithms_7_4_14 Build Result of Type Solid
1137 This step is the same as @ref occt_algorithms_7_4_4 "Building Result of Type Vertex", but for the type Solid.
1139 @subsubsection occt_algorithms_7_4_15 Build Images for Type CompSolid
1141 The input data for this step is:
1142 * *BOPAlgo_Builder* object after building result of type solid;
1143 * *Original Shape* -- a Compsolid;
1144 * *Type* -- the type of the shape <i>(TopAbs_COMPSOLID)</i>.
1146 The procedure is the same as for building images for wires.
1148 @subsubsection occt_algorithms_7_4_16 Build Result of Type Compsolid
1149 This step is the same as @ref occt_algorithms_7_4_4 "Building Result of Type Vertex", but for the type Compsolid.
1151 @subsubsection occt_algorithms_7_4_17 Build Images for Compounds
1152 The input data for this step is as follows:
1153 * *BOPAlgo_Builder* object after building results of type *compsolid*;
1154 * *Original Shape* -- a Compound;
1155 * *Type* -- the type of the shape <i>(TopAbs_COMPOUND)</i>.
1157 The procedure is the same as for building images for wires.
1159 @subsubsection occt_algorithms_7_4_18 Build Result of Type Compound
1161 This step is the same as @ref occt_algorithms_7_4_4 "Building Result of Type Vertex", but for the type Compound.
1163 @subsubsection occt_algorithms_7_4_19 Post-Processing
1164 The purpose of the step is to correct tolerances of the result to provide its validity in terms of *BRepCheck_Analyzer.*
1166 The input data for this step is a *BOPAlgo_Builder* object after building result of type compound.
1168 | No | Contents | Implementation |
1169 | :---- | :---- | :----- |
1170 | 1 | Correct tolerances of vertices on curves | *BOPTools_Tools::CorrectPointOnCurve()* |
1171 | 2 | Correct tolerances of edges on faces | *BOPTools_Tools::CorrectCurveOnSurface()* |
1174 @section occt_algorithms_8 Splitter Algorithm
1176 The Splitter algorithm allows splitting a group of arbitrary shapes by another group of arbitrary shapes.<br>
1177 It is based on the General Fuse algorithm, thus all options of the General Fuse (see @ref occt_algorithms_7_3a "GF Options") are also available in this algorithm.
1179 @subsection occt_algorithms_8_1 Arguments
1181 * The arguments of the Splitter algorithm are divided into two groups - *Objects* (shapes that will be split) and *Tools* (shapes, by which the *Objects* will be split);
1182 * The requirements for the arguments (both for *Objects* and *Tools*) are the same as for the General Fuse algorithm - there can be any number of arguments of any type in each group, but each argument should be valid and not self-interfered.
1184 @subsection occt_algorithms_8_2 Results
1186 * The result of Splitter algorithm contains only the split parts of the shapes included into the group of *Objects*;
1187 * The split parts of the shapes included only into the group of *Tools* are excluded from the result;
1188 * If there are no shapes in the group of *Tools* the result of the operation will be equivalent to the result of General Fuse operation;
1189 * The shapes can be split by other shapes from the same group (if these shapes are interfering).
1191 @subsection occt_algorithms_8_3 Usage
1193 @subsubsection occt_algorithms_8_3_1 API
1195 On the low level the Splitter algorithm is implemented in class *BOPAlgo_Splitter*. The usage of this algorithm looks as follows:
1197 BOPAlgo_Splitter aSplitter;
1198 // Setting arguments and tools
1199 TopTools_ListOfShape aLSObjects = …; // Objects
1200 TopTools_ListOfShape aLSTools = …; // Tools
1201 aSplitter.SetArguments(aLSObjects);
1202 aSplitter.SetTools(aLSTools);
1204 // Set options for the algorithm
1205 // setting options for this algorithm is similar to setting options for GF algorithm (see "GF Usage" chapter)
1208 // Perform the operation
1209 aSplitter.Perform();
1210 if (aSplitter.HasErrors()) { //check error status
1214 const TopoDS_Shape& aResult = aSplitter.Shape(); // result of the operation
1217 @subsubsection occt_algorithms_8_3_2 DRAW
1219 The command *bsplit* implements the Splitter algorithm in DRAW. Similarly to the *bbuild* command for the General Fuse algorithm, the *bsplit* command should be used after the Pave Filler is filled.
1221 # s1 s2 s3 - objects
1225 baddobjects s1 s2 s3
1231 @subsection occt_algorithms_8_4 Examples
1233 @subsubsection occt_algorithms_8_4_1 Example 1
1235 Splitting a face by the set of edges:
1238 # draw script for reproducing
1243 cylinder cyl 0 0 0 0 0 1 10
1244 mkface f cyl 0 2*pi -$height $height
1252 set ustep [expr $pi2/$nb_uedges]
1253 for {set i 0} {$i <= $pi2} {set i [expr $i + $ustep]} {
1260 set vstep [expr 2*$height/$nb_vedges]
1261 for {set i -20} {$i <= 20} {set i [expr $i + $vstep]} {
1272 <table align="center">
1274 <td>@figure{/user_guides/boolean_operations/images/bsplit_image001.png,"Arguments",160}</td>
1275 <td>@figure{/user_guides/boolean_operations/images/bsplit_image002.png,"Result",160}</td>
1279 @subsubsection occt_algorithms_8_4_2 Example 2
1281 Splitting a plate by the set of cylinders:
1284 # draw script for reproducing:
1293 for {set i 0} {$i < 101} {incr i 5} {
1294 for {set j 0} {$j < 101} {incr j 5} {
1296 ttranslate p1 $i $j -5;
1306 <table align="center">
1308 <td>@figure{/user_guides/boolean_operations/images/bsplit_image003.png,"Arguments",160}</td>
1309 <td>@figure{/user_guides/boolean_operations/images/bsplit_image004.png,"Result",160}</td>
1313 @subsubsection occt_algorithms_8_4_3 Example 3
1315 Splitting shell hull by the planes:
1316 <table align="center">
1318 <td>@figure{/user_guides/boolean_operations/images/bsplit_image005.png,"Arguments",160}</td>
1319 <td>@figure{/user_guides/boolean_operations/images/bsplit_image006.png,"Results",160}</td>
1323 @section occt_algorithms_9 Boolean Operations Algorithm
1325 @subsection occt_algorithms_9_1 Arguments
1327 * The arguments of BOA are shapes in terms of *TopoDS_Shape*. The main requirements for the arguments are described in the @ref occt_algorithms_4 "Data Structure"
1328 * There are two groups of arguments in BOA:
1329 * Objects <i>(S1=S11, S12, ...)</i>;
1330 * Tools <i>(S2=S21, S22, ...)</i>.
1331 * The following table contains the values of dimension for different types of arguments:
1333 | No | Type of Argument | Index of Type | Dimension |
1334 | :---- | :---- | :----- | :---- |
1335 | 1 | COMPOUND | 0 | One of 0, 1, 2, 3 |
1336 | 2 | COMPSOLID | 1 | 3 |
1337 | 3 | SOLID | 2 | 3 |
1338 | 4 | SHELL | 3 | 2 |
1339 | 5 | FACE | 4 | 2 |
1340 | 6 | WIRE | 5 | 1 |
1341 | 7 | EDGE | 6 | 1 |
1342 | 8 | VERTEX | 7 | 0 |
1344 * For Boolean operation Fuse all arguments should have equal dimensions.
1345 * For Boolean operation Cut the minimal dimension of *S2* should not be less than the maximal dimension of *S1*.
1346 * For Boolean operation Common the arguments can have any dimension.
1348 @subsection occt_algorithms_9_3 Results. General Rules
1350 * The result of the Boolean operation is a compound (if defined). Each sub-shape of the compound has shared sub-shapes in accordance with interferences between the arguments.
1351 * The content of the result depends on the type of the operation (Common, Fuse, Cut12, Cut21) and the dimensions of the arguments.
1352 * The result of the operation Fuse is defined for arguments *S1* and *S2* that have the same dimension value : *Dim(S1)=Dim(S2)*. If the arguments have different dimension values the result of the operation Fuse is not defined. The dimension of the result is equal to the dimension of the arguments. For example, it is impossible to fuse an edge and a face.
1353 * The result of the operation Fuse for arguments *S1* and *S2* contains the parts of arguments that have states **OUT** relative to the opposite arguments.
1354 * The result of the operation Fuse for arguments *S1* and *S2* having dimension value 3 (Solids) is refined by removing all possible internal faces to provide minimal number of solids.
1355 * The result of the operation Common for arguments *S1* and *S2* is defined for all values of the dimensions of the arguments. The result can contain shapes of different dimensions, but the minimal dimension of the result will be equal to the minimal dimension of the arguments. For example, the result of the operation Common between edges cannot be a vertex.
1356 * The result of the operation Common for the arguments *S1* and *S2* contains the parts of the argument that have states **IN** and **ON** relative to the opposite argument.
1357 * The result of the operation Cut is defined for arguments *S1* and *S2* that have values of dimensions *Dim(S2)* that should not be less than *Dim(S1)*. The result can contain shapes of different dimensions, but the minimal dimension of the result will be equal to the minimal dimension of the objects *Dim(S1)*. The result of the operation *Cut12* is not defined for other cases. For example, it is impossible to cut an edge from a solid, because a solid without an edge is not defined.
1358 * The result of the operation *Cut12* for arguments *S1* and *S2* contains the parts of argument *S1* that have state **OUT** relative to the opposite argument *S2*.
1359 * The result of the operation *Cut21* for arguments *S1* and *S2* contains the parts of argument *S2* that have state **OUT** relative to the opposite argument *S1*.
1360 * For the arguments of collection type (WIRE, SHELL, COMPSOLID) the type will be passed in the result. For example, the result of Common operation between Shell and Wire will be a compound containing Wire.
1361 * For the arguments of collection type (WIRE, SHELL, COMPSOLID) containing overlapping parts the overlapping parts passed into result will be repeated for each container from the input shapes containing such parts. The containers completely included in other containers will be avoided in the result.
1362 * For the arguments of collection type (WIRE, SHELL, COMPSOLID) the containers included into result will have the same orientation as the original containers from arguments. In case of duplication its orientation will be defined by the orientation of the first container in arguments. Each container included into result will have coherent orientation of its sub-shapes.
1363 * The result of the operation Fuse for the arguments of collection type (WIRE, SHELL) will consist of the shapes of the same collection type. The overlapping parts (EDGES/FACES) will be shared among containers, but duplicating containers will be avoided in the result. For example, the result of Fuse operation between two fully coinciding wires will be one wire, but the result of Fuse operation between two partially coinciding wires will be two wires sharing coinciding edges.
1364 * The result of the operation Fuse for the arguments of type COMPSOLID will consist of the compound containing COMPSOLIDs created from connexity blocks of fused solids.
1365 * The result of the operation Common for the arguments of collection type (WIRE, SHELL, COMPSOLID) will consist of the unique containers containing the overlapping parts. For example, the result of Common operation between two fully overlapping wires will be one wire containing all splits of edges. The number of wires in the result of Common operation between two partially overlapping wires will be equal to the number of connexity blocks of overlapping edges.
1367 @subsection occt_algorithms_9_4 Examples
1369 @subsubsection occt_algorithms_9_4_1 Case 1: Two Vertices
1371 Let us consider two interfering vertices *V1* and *V2*:
1373 @figure{/user_guides/boolean_operations/images/boolean_image001.svg,"",160}
1375 * The result of *Fuse* operation is the compound that contains new vertex *V*.
1377 @figure{/user_guides/boolean_operations/images/boolean_image002.svg,"",160}
1379 * The result of *Common* operation is a compound containing new vertex *V*.
1381 * The result of *Cut12* operation is an empty compound.
1382 * The result of *Cut21* operation is an empty compound.
1384 @subsubsection occt_algorithms_9_4_2 Case 2: A Vertex and an Edge
1386 Let us consider vertex *V1* and the edge *E2*, that intersect in a 3D point:
1388 @figure{/user_guides/boolean_operations/images/boolean_image004.png,"",230}
1390 * The result of *Fuse* operation is result is not defined because the dimension of the vertex (0) is not equal to the dimension of the edge (1).
1392 * The result of *Common* operation is a compound containing vertex *V<sub>1</sub>* as the argument *V<sub>1</sub>* has a common part with edge *E2*.
1394 @figure{/user_guides/boolean_operations/images/boolean_image005.png,"",230}
1396 * The result of *Cut12* operation is an empty compound.
1397 * The result of *Cut21* operation is not defined because the dimension of the vertex (0) is less than the dimension of the edge (1).
1399 @subsubsection occt_algorithms_9_4_3 Case 3: A Vertex and a Face
1401 Let us consider vertex *V1* and face *F2*, that intersect in a 3D point:
1403 @figure{/user_guides/boolean_operations/images/boolean_image006.png,"",230}
1405 * The result of *Fuse* operation is not defined because the dimension of the vertex (0) is not equal to the dimension of the face (2).
1407 * The result of *Common* operation is a compound containing vertex *V<sub>1</sub>* as the argument *V<sub>1</sub>* has a common part with face *F2*.
1409 @figure{/user_guides/boolean_operations/images/boolean_image007.png,"",230}
1411 * The result of *Cut12* operation is an empty compound.
1412 * The result of *Cut21* operation is not defined because the dimension of the vertex (0) is less than the dimension of the face (2).
1414 @subsubsection occt_algorithms_9_4_4 Case 4: A Vertex and a Solid
1416 Let us consider vertex *V1* and solid *S2*, that intersect in a 3D point:
1418 @figure{/user_guides/boolean_operations/images/boolean_image008.png,"",230}
1420 * The result of *Fuse* operation is not defined because the dimension of the vertex (0) is not equal to the dimension of the solid (3).
1422 * The result of *Common* operation is a compound containing vertex *V<sub>1</sub>* as the argument *V<sub>1</sub>* has a common part with solid *S2*.
1424 @figure{/user_guides/boolean_operations/images/boolean_image009.png,"",230}
1426 * The result of *Cut12* operation is an empty compound.
1427 * The result of *Cut21* operation is not defined because the dimension of the vertex (0) is less than the dimension of the solid (3).
1429 @subsubsection occt_algorithms_9_4_5 Case 5: Two edges intersecting at one point
1431 Let us consider edges *E1* and *E2* that intersect in a 3D point:
1433 @figure{/user_guides/boolean_operations/images/boolean_image010.svg,"",230}
1435 * The result of *Fuse* operation is a compound containing split parts of arguments i.e. 4 new edges *E11, E12, E21*, and *E22*. These edges have one shared vertex *Vn1*.
1437 * argument edge *E1* has resulting split edges *E11* and *E12* (image of *E1*);
1438 * argument edge *E2* has resulting split edges *E21* and *E22* (image of *E2*).
1440 @figure{/user_guides/boolean_operations/images/boolean_image011.svg,"",230}
1442 * The result of *Common* operation is an empty compound because the dimension (0) of the common part between the edges (vertex) is less than the dimension of the arguments (1).
1444 * The result of *Cut12* operation is a compound containing split parts of the argument *E1*, i.e. 2 new edges *E11* and *E12*. These edges have one shared vertex *Vn1*.
1446 In this case the argument edge *E1* has resulting split edges *E11* and *E12* (image of *E1*).
1448 @figure{/user_guides/boolean_operations/images/boolean_image012.svg,"",230}
1450 * The result of *Cut21* operation is a compound containing split parts of the argument *E2*, i.e. 2 new edges *E21* and *E12*. These edges have one shared vertex *Vn1*.
1452 In this case the argument edge *E2* has resulting split edges *E21* and *E22* (image of *E2*).
1454 @figure{/user_guides/boolean_operations/images/boolean_image013.svg,"",70}
1456 @subsubsection occt_algorithms_9_4_6 Case 6: Two edges having a common block
1458 Let us consider edges *E1* and *E2* that have a common block:
1460 @figure{/user_guides/boolean_operations/images/boolean_image014.svg,"",230}
1462 * The result of *Fuse* operation is a compound containing split parts of arguments i.e. 3 new edges *E11*, *E12* and *E22*. These edges have two shared vertices.
1464 * argument edge *E1* has resulting split edges *E11* and *E12* (image of *E1*);
1465 * argument edge *E2* has resulting split edges *E21* and *E22* (image of *E2*);
1466 * edge *E12* is common for the images of *E1* and *E2*.
1468 @figure{/user_guides/boolean_operations/images/boolean_image015.svg,"",230}
1470 * The result of *Common* operation is a compound containing split parts of arguments i.e. 1 new edge *E12*. In this case edge *E12* is common for the images of *E1* and *E2*.
1471 The common part between the edges (edge) has the same dimension (1) as the dimension of the arguments (1).
1473 @figure{/user_guides/boolean_operations/images/boolean_image016.svg,"",230}
1475 * The result of *Cut12* operation is a compound containing a split part of argument *E1*, i.e. new edge *E11*.
1477 @figure{/user_guides/boolean_operations/images/boolean_image017.svg,"",230}
1479 * The result of *Cut21* operation is a compound containing a split part of argument *E2*, i.e. new edge *E22*.
1481 @figure{/user_guides/boolean_operations/images/boolean_image018.svg,"",230}
1484 @subsubsection occt_algorithms_9_4_7 Case 7: An Edge and a Face intersecting at a point
1486 Let us consider edge *E1* and face *F2* that intersect at a 3D point:
1488 @figure{/user_guides/boolean_operations/images/boolean_image019.png,"",230}
1490 * The result of *Fuse* operation is not defined because the dimension of the edge (1) is not equal to the dimension of the face (2).
1492 * The result of *Common* operation is an empty compound because the dimension (0) of the common part between the edge and face (vertex) is less than the dimension of the arguments (1).
1494 * The result of *Cut12* operation is a compound containing split parts of the argument *E1*, i.e. 2 new edges *E11* and *E12*.
1496 In this case the argument edge *E1* has no common parts with the face *F2* so the whole image of *E1* is in the result.
1498 @figure{/user_guides/boolean_operations/images/boolean_image020.png,"",230}
1500 * The result of *Cut21* operation is not defined because the dimension of the edge (1) is less than the dimension of the face (2).
1502 @subsubsection occt_algorithms_9_4_8 Case 8: A Face and an Edge that have a common block
1504 Let us consider edge *E1* and face *F2* that have a common block:
1506 @figure{/user_guides/boolean_operations/images/boolean_image021.png,"",230}
1508 * The result of *Fuse* operation is not defined because the dimension of the edge (1) is not equal to the dimension of the face (2).
1510 * The result of *Common* operation is a compound containing a split part of the argument *E1*, i.e. new edge *E12*.
1512 In this case the argument edge *E1* has a common part with face *F2* so the corresponding part of the image of *E1* is in the result. The yellow square is not a part of the result. It only shows the place of *F2*.
1514 @figure{/user_guides/boolean_operations/images/boolean_image022.png,"",230}
1516 * The result of *Cut12* operation is a compound containing split part of the argument *E1*, i.e. new edge *E11*.
1518 In this case the argument edge *E1* has a common part with face *F2* so the corresponding part is not included into the result. The yellow square is not a part of the result. It only shows the place of F2.
1520 @figure{/user_guides/boolean_operations/images/boolean_image023.png,"",230}
1522 * The result of *Cut21* operation is not defined because the dimension of the edge (1) is less than the dimension of the face (2).
1524 @subsubsection occt_algorithms_9_4_9 Case 9: An Edge and a Solid intersecting at a point
1526 Let us consider edge *E1* and solid *S2* that intersect at a point:
1528 @figure{/user_guides/boolean_operations/images/boolean_image024.png,"",230}
1530 * The result of *Fuse* operation is not defined because the dimension of the edge (1) is not equal to the dimension of the solid (3).
1532 * The result of *Common* operation is a compound containing a split part of the argument *E1*, i.e. new edge *E12*.
1534 In this case the argument edge *E1* has a common part with solid *S2* so the corresponding part of the image of *E1* is in the result. The yellow square is not a part of the result. It only shows the place of *S2*.
1536 @figure{/user_guides/boolean_operations/images/boolean_image025.png,"",230}
1538 * The result of *Cut12* operation is a compound containing split part of the argument *E1*, i.e. new edge *E11*.
1540 In this case the argument edge *E1* has a common part with solid *S2* so the corresponding part is not included into the result. The yellow square is not a part of the result. It only shows the place of *S2*.
1542 @figure{/user_guides/boolean_operations/images/boolean_image071.png,"",230}
1544 * The result of *Cut21* operation is not defined because the dimension of the edge (1) is less than the dimension of the solid (3).
1546 @subsubsection occt_algorithms_9_4_10 Case 10: An Edge and a Solid that have a common block
1548 Let us consider edge *E1* and solid *S2* that have a common block:
1550 @figure{/user_guides/boolean_operations/images/boolean_image072.png,"",230}
1552 * The result of *Fuse* operation is not defined because the dimension of the edge (1) is not equal to the dimension of the solid (3).
1554 * The result of *Common* operation is a compound containing a split part of the argument *E1*, i.e. new edge *E12*.
1556 In this case the argument edge *E1* has a common part with solid *S2* so the corresponding part of the image of *E1* is in the result. The yellow square is not a part of the result. It only shows the place of *S2*.
1558 @figure{/user_guides/boolean_operations/images/boolean_image073.png,"",230}
1560 * The result of *Cut12* operation is a compound containing split part of the argument *E1*, i.e. new edge *E11*.
1562 In this case the argument edge *E1* has a common part with solid *S2* so the corresponding part is not included into the result. The yellow square is not a part of the result. It only shows the place of *S2*.
1564 @figure{/user_guides/boolean_operations/images/boolean_image026.png,"",230}
1566 * The result of *Cut21* operation is not defined because the dimension of the edge (1) is less than the dimension of the solid (3).
1568 @subsubsection occt_algorithms_9_4_11 Case 11: Two intersecting faces
1570 Let us consider two intersecting faces *F1* and *F2*:
1572 @figure{/user_guides/boolean_operations/images/boolean_image027.png,"",230}
1574 * The result of *Fuse* operation is a compound containing split parts of arguments i.e. 2 new faces *F11* and *F21*. These faces have one shared edge *En1*.
1576 @figure{/user_guides/boolean_operations/images/boolean_image028.png,"",230}
1579 * The result of *Common* operation is an empty compound because the dimension (1) of the common part between *F1* and *F2* (edge) is less than the dimension of arguments (2).
1581 * The result of *Cut12* operation is a compound containing split part of the argument *F1*, i.e. new face *F11*.
1583 @figure{/user_guides/boolean_operations/images/boolean_image029.png,"",230}
1585 * The result of *Cut21* operation is a compound containing split parts of the argument *F2*, i.e. 1 new face *F21*.
1587 @figure{/user_guides/boolean_operations/images/boolean_image030.png,"",127}
1589 @subsubsection occt_algorithms_9_4_12 Case 12: Two faces that have a common part
1591 Let us consider two faces *F1* and *F2* that have a common part:
1593 @figure{/user_guides/boolean_operations/images/boolean_image031.png,"",230}
1595 * The result of *Fuse* operation is a compound containing split parts of arguments, i.e. 3 new faces: *F11*, *F12* and *F22*. These faces are shared through edges In this case:
1596 * the argument edge *F1* has resulting split faces *F11* and *F12* (image of *F1*)
1597 * the argument face *F2* has resulting split faces *F12* and *F22* (image of *F2*)
1598 * the face *F12* is common for the images of *F1* and *F2*.
1600 @figure{/user_guides/boolean_operations/images/boolean_image032.png,"",230}
1602 * The result of *Common* operation is a compound containing split parts of arguments i.e. 1 new face *F12*.
1603 In this case: face *F12* is common for the images of *F1* and *F2*.
1604 The common part between the faces (face) has the same dimension (2) as the dimension of the arguments (2).
1607 @figure{/user_guides/boolean_operations/images/boolean_image033.png,"",230}
1609 * The result of *Cut12* operation is a compound containing split part of the argument *F1*, i.e. new face *F11*.
1611 @figure{/user_guides/boolean_operations/images/boolean_image034.png,"",230}
1613 * The result of *Cut21* operation is a compound containing split parts of the argument *F2*, i.e. 1 new face *F21*.
1615 @figure{/user_guides/boolean_operations/images/boolean_image035.png,"",230}
1617 @subsubsection occt_algorithms_9_4_13 Case 13: Two faces that have a common edge
1619 Let us consider two faces *F1* and *F2* that have a common edge:
1621 @figure{/user_guides/boolean_operations/images/boolean_image036.png,"",230}
1623 * The result of *Fuse* operation is a compound containing split parts of arguments, i.e. 2 new faces: *F11* and *F21*. These faces have one shared edge *En1*.
1625 @figure{/user_guides/boolean_operations/images/boolean_image037.png,"",230}
1627 * The result of *Common* operation is an empty compound because the dimension (1) of the common part between *F1* and *F2* (edge)is less than the dimension of the arguments (2)
1629 * The result of *Cut12* operation is a compound containing split part of the argument *F1*, i.e. new face *F11*. The vertices are shown just to clarify the fact that the edges are spitted.
1631 @figure{/user_guides/boolean_operations/images/boolean_image038.png,"",230}
1633 * The result of *Cut21* operation is a compound containing split parts of the argument *F2*, i.e. 1 new face *F21*. The vertices are shown just to clarify the fact that the edges are spitted.
1635 @figure{/user_guides/boolean_operations/images/boolean_image039.png,"",230}
1637 @subsubsection occt_algorithms_9_4_14 Case 14: Two faces that have a common vertex
1639 Let us consider two faces *F1* and *F2* that have a common vertex:
1641 @figure{/user_guides/boolean_operations/images/boolean_image040.png,"",230}
1643 * The result of *Fuse* operation is a compound containing split parts of arguments, i.e. 2 new faces: *F11* and *F21*. These faces have one shared vertex *Vn1*.
1645 @figure{/user_guides/boolean_operations/images/boolean_image041.png,"",230}
1647 * The result of *Common* operation is an empty compound because the dimension (0) of the common part between *F1* and *F2* (vertex) is less than the dimension of the arguments (2)
1649 * The result of *Cut12* operation is a compound containing split part of the argument *F1*, i.e. new face *F11*.
1651 @figure{/user_guides/boolean_operations/images/boolean_image042.png,"",230}
1653 * The result of *Cut21* operation is a compound containing split parts of the argument *F2*, i.e. 1 new face *F21*.
1655 @figure{/user_guides/boolean_operations/images/boolean_image043.png,"",230}
1658 @subsubsection occt_algorithms_9_4_15 Case 15: A Face and a Solid that have an intersection curve.
1660 Let us consider face *F1* and solid *S2* that have an intersection curve:
1662 @figure{/user_guides/boolean_operations/images/boolean_image044.png,"",230}
1664 * The result of *Fuse* operation is not defined because the dimension of the face (2) is not equal to the dimension of the solid (3).
1666 * The result of *Common* operation is a compound containing split part of the argument *F1*. In this case the argument face *F1* has a common part with solid *S2*, so the corresponding part of the image of *F1* is in the result. The yellow contour is not a part of the result. It only shows the place of *S2*.
1668 @figure{/user_guides/boolean_operations/images/boolean_image045.png,"",230}
1670 * The result of *Cut12* operation is a compound containing split part of the argument *F1*. In this case argument face *F1* has a common part with solid *S2* so the corresponding part is not included into the result. The yellow contour is not a part of the result. It only shows the place of *S2*.
1672 @figure{/user_guides/boolean_operations/images/boolean_image046.png,"",230}
1674 * The result of *Cut21* operation is is not defined because the dimension of the face (2) is less than the dimension of the solid (3).
1676 @subsubsection occt_algorithms_9_4_16 Case 16: A Face and a Solid that have overlapping faces.
1678 Let us consider face *F1* and solid *S2* that have overlapping faces:
1680 @figure{/user_guides/boolean_operations/images/boolean_image047.png,"",230}
1682 * The result of *Fuse* operation is not defined because the dimension of the face (2) is not equal to the dimension of the solid (3).
1684 * The result of *Common* operation is a compound containing split part of the argument *F1*. In this case the argument face *F1* has a common part with solid *S2*, so the corresponding part of the image of *F1* is included in the result. The yellow contour is not a part of the result. It only shows the place of *S2*.
1686 @figure{/user_guides/boolean_operations/images/boolean_image048.png,"",230}
1688 * The result of *Cut12* operation is a compound containing split part of the argument *F1*. In this case argument face *F1* has a common part with solid *S2* so the corresponding part is not included into the result. The yellow contour is not a part of the result. It only shows the place of *S2*.
1690 @figure{/user_guides/boolean_operations/images/boolean_image049.png,"",230}
1692 * The result of *Cut21* operation is is not defined because the dimension of the face (2) is less than the dimension of the solid (3).
1695 @subsubsection occt_algorithms_9_4_17 Case 17: A Face and a Solid that have overlapping edges.
1697 Let us consider face *F1* and solid *S2* that have overlapping edges:
1699 @figure{/user_guides/boolean_operations/images/boolean_image050.png,"",230}
1701 * The result of *Fuse* operation is not defined because the dimension of the face (2) is not equal to the dimension of the solid (3).
1703 * The result of *Common* operation is an empty compound because the dimension (1) of the common part between *F1* and *S2* (edge) is less than the lower dimension of the arguments (2).
1705 * The result of *Cut12* operation is a compound containing split part of the argument *F1*. In this case argument face *F1* has a common part with solid *S2* so the corresponding part is not included into the result. The yellow contour is not a part of the result. It only shows the place of *S2*.
1707 @figure{/user_guides/boolean_operations/images/boolean_image051.png,"",230}
1709 * The result of *Cut21* operation is is not defined because the dimension of the face (2) is less than the dimension of the solid (3).
1711 @subsubsection occt_algorithms_9_4_18 Case 18: A Face and a Solid that have overlapping vertices.
1713 Let us consider face *F1* and solid *S2* that have overlapping vertices:
1715 @figure{/user_guides/boolean_operations/images/boolean_image052.png,"",230}
1717 * The result of *Fuse* operation is not defined because the dimension of the face (2) is not equal to the dimension of the solid (3).
1719 * The result of *Common* operation is an empty compound because the dimension (1) of the common part between *F1* and *S2* (vertex) is less than the lower dimension of the arguments (2).
1721 * The result of *Cut12* operation is a compound containing split part of the argument *F1*. In this case argument face *F1* has a common part with solid *S2* so the corresponding part is not included into the result. The yellow contour is not a part of the result. It only shows the place of *S2*.
1723 @figure{/user_guides/boolean_operations/images/boolean_image053.png,"",230}
1725 * The result of *Cut21* operation is is not defined because the dimension of the face (2) is less than the dimension of the solid (3).
1727 @subsubsection occt_algorithms_9_4_19 Case 19: Two intersecting Solids.
1729 Let us consider two intersecting solids *S1* and *S2*:
1731 @figure{/user_guides/boolean_operations/images/boolean_image054.png,"",230}
1733 * The result of *Fuse* operation is a compound composed from the split parts of arguments *S11, S12* and *S22* <i>(Cut12, Common, Cut21)</i>. All inner webs are removed, so the result is one new solid *R*.
1735 @figure{/user_guides/boolean_operations/images/boolean_image055.png,"",230}
1737 * The result of *Common* operation is a compound containing split parts of arguments i.e. one new solid *S12*. In this case solid *S12* is common for the images of *S1* and *S2*. The common part between the solids (solid) has the same dimension (3) as the dimension of the arguments (3). The yellow contour is not a part of the result. It only shows the place of *S1*.
1739 @figure{/user_guides/boolean_operations/images/boolean_image056.png,"",176}
1741 * The result of *Cut12* operation is a compound containing split part of the argument *S1*, i.e. 1 new solid *S11*.
1743 @figure{/user_guides/boolean_operations/images/boolean_image057.png,"",230}
1745 * The result of *Cut21* operation is a compound containing split part of the argument *S2*, i.e. 1 new solid *S21*.
1747 @figure{/user_guides/boolean_operations/images/boolean_image058.png,"",230}
1749 @subsubsection occt_algorithms_9_4_20 Case 20: Two Solids that have overlapping faces.
1751 Let us consider two solids *S1* and *S2* that have a common part on face:
1753 @figure{/user_guides/boolean_operations/images/boolean_image059.png,"",230}
1755 * The result of *Fuse* operation is a compound composed from the split parts of arguments *S11, S12* and *S22* <i>(Cut12, Common, Cut21)</i>. All inner webs are removed, so the result is one new solid *R*.
1757 @figure{/user_guides/boolean_operations/images/boolean_image060.png,"",230}
1759 * The result of *Common* operation is an empty compound because the dimension (2) of the common part between *S1* and *S2* (face) is less than the lower dimension of the arguments (3).
1761 * The result of *Cut12* operation is a compound containing split part of the argument *S1*, i.e. 1 new solid *S11*.
1763 @figure{/user_guides/boolean_operations/images/boolean_image061.png,"",230}
1765 * The result of *Cut21* operation is a compound containing split part of the argument *S2*, i.e. 1 new solid *S21*.
1766 @figure{/user_guides/boolean_operations/images/boolean_image062.png,"",230}
1769 @subsubsection occt_algorithms_9_4_21 Case 21: Two Solids that have overlapping edges.
1771 Let us consider two solids *S1* and *S2* that have overlapping edges:
1773 @figure{/user_guides/boolean_operations/images/boolean_image063.png,"",230}
1775 * The result of *Fuse* operation is a compound composed from the split parts of arguments i.e. 2 new solids *S11* and *S21*. These solids have one shared edge *En1*.
1777 @figure{/user_guides/boolean_operations/images/boolean_image064.png,"",230}
1779 * The result of *Common* operation is an empty compound because the dimension (1) of the common part between *S1* and *S2* (edge) is less than the lower dimension of the arguments (3).
1781 * The result of *Cut12* operation is a compound containing split part of the argument *S1*. In this case
1782 argument *S1* has a common part with solid *S2* so the corresponding part is not included into the result.
1784 @figure{/user_guides/boolean_operations/images/boolean_image065.png,"",230}
1786 * The result of *Cut21* operation is a compound containing split part of the argument *S2*. In this case
1787 argument *S2* has a common part with solid *S1* so the corresponding part is not included into the result.
1789 @figure{/user_guides/boolean_operations/images/boolean_image066.png,"",230}
1791 @subsubsection occt_algorithms_9_4_22 Case 22: Two Solids that have overlapping vertices.
1793 Let us consider two solids *S1* and *S2* that have overlapping vertices:
1795 @figure{/user_guides/boolean_operations/images/boolean_image067.png,"",230}
1797 * The result of *Fuse* operation is a compound composed from the split parts of arguments i.e. 2 new solids *S11* and *S21*. These solids share *Vn1*.
1799 @figure{/user_guides/boolean_operations/images/boolean_image068.png,"",230}
1801 * The result of *Common* operation is an empty compound because the dimension (0) of the common part between *S1* and *S2* (vertex) is less than the lower dimension of the arguments (3).
1803 * The result of *Cut12* operation is a compound containing split part of the argument *S1*.
1805 @figure{/user_guides/boolean_operations/images/boolean_image069.png,"",230}
1807 * The result of *Cut21* operation is a compound containing split part of the argument *S2*.
1809 @figure{/user_guides/boolean_operations/images/boolean_image070.png,"",230}
1811 @subsubsection occt_algorithms_9_4_23 Case 23: A Shell and a Wire cut by a Solid.
1813 Let us consider Shell *Sh* and Wire *W* as the objects and Solid *S* as the tool:
1815 @figure{/user_guides/boolean_operations/images/boolean_image136.png,"",230}
1817 * The result of *Fuse* operation is not defined as the dimension of the arguments is not the same.
1819 * The result of *Common* operation is a compound containing the parts of the initial Shell and Wire common for the Solid. The new Shell and Wire are created from the objects.
1821 @figure{/user_guides/boolean_operations/images/boolean_image137.png,"",230}
1823 * The result of *Cut12* operation is a compound containing new Shell and Wire split from the arguments *Sh* and *W*. In this case they have a common part with solid *S* so the corresponding part is not included into the result.
1825 @figure{/user_guides/boolean_operations/images/boolean_image138.png,"",230}
1827 * The result of *Cut21* operation is not defined as the objects have a lower dimension than the tool.
1829 @subsubsection occt_algorithms_9_4_24 Case 24: Two Wires that have overlapping edges.
1831 Let us consider two Wires that have overlapping edges, *W1* is the object and *W2* is the tool:
1833 @figure{/user_guides/boolean_operations/images/boolean_image139.png,"",230}
1835 * The result of *Fuse* operation is a compound containing two Wires, which share an overlapping edge. The new Wires are created from the objects:
1837 @figure{/user_guides/boolean_operations/images/boolean_image140.png,"",230}
1839 * The result of *Common* operation is a compound containing one Wire consisting of an overlapping edge. The new Wire is created from the objects:
1841 @figure{/user_guides/boolean_operations/images/boolean_image141.png,"",230}
1843 * The result of *Cut12* operation is a compound containing a wire split from object *W1*. Its common part with *W2* is not included into the result.
1845 @figure{/user_guides/boolean_operations/images/boolean_image142.png,"",230}
1847 * The result of *Cut21* operation is a compound containing a wire split from *W2*. Its common part with *W1* is not included into the result.
1849 @figure{/user_guides/boolean_operations/images/boolean_image143.png,"",230}
1852 @subsection occt_algorithms_9_5 Class BOPAlgo_BOP
1854 BOA is implemented in the class *BOPAlgo_BOP*. The main fields of this class are described in the Table:
1858 | *myOperation* | The type of the Boolean operation (Common, Fuse, Cut) |
1859 | *myTools* | The tools |
1860 | *myDims[2]* | The values of the dimensions of the arguments |
1861 | *myRC* | The draft result (shape) |
1863 The main steps of the *BOPAlgo_BOP* are the same as of @ref occt_algorithms_7_4 "BOPAlgo_Builder" except for some aspects described in the next paragraphs.
1865 @subsection occt_algorithms_9_6 Building Draft Result
1867 The input data for this step is as follows:
1868 * *BOPAlgo_BOP* object after building result of type *Compound*;
1869 * *Type* of the Boolean operation.
1871 | No | Contents | Implementation |
1872 | :---- | :----- | :----- |
1873 | 1 | For the Boolean operation *Fuse* add to *myRC* all images of arguments. | *BOPAlgo_BOP::BuildRC()* |
1874 | 2 | For the Boolean operation *Common* or *Cut* add to *myRC* all images of argument *S1* that are *Common* for the Common operation and are *Not Common* for the Cut operation | *BOPAlgo_BOP::BuildRC()* |
1876 @subsection occt_algorithms_9_7 Building the Result
1878 The input data for this step is as follows:
1879 * *BOPAlgo_BOP* object the state after building draft result.
1881 | No | Contents | Implementation |
1882 | :---- | :---- | :------ |
1883 | 1 | For the Type of the Boolean operation Common, Cut with any dimension and operation Fuse with *myDim[0] < 3* | |
1884 | 1.1 | Find containers (WIRE, SHELL, COMPSOLID) in the arguments | *BOPAlgo_BOP:: BuildShape()* |
1885 | 1.2 | Make connexity blocks from splits of each container that are in *myRC* | *BOPTools_Tools::MakeConnexityBlocks()* |
1886 | 1.3 | Build the result from shapes made from the connexity blocks | *BOPAlgo_BOP:: BuildShape()* |
1887 | 1.4 | Add the remaining shapes from *myRC* to the result | *BOPAlgo_BOP:: BuildShape()* |
1888 | 2 | For the Type of the Boolean operation Fuse with *myDim[0] = 3* | |
1889 | 2.1 | Find internal faces <i>(FWi)</i> in *myRC* | *BOPAlgo_BOP::BuildSolid()* |
1890 | 2.2 | Collect all faces of *myRC* except for internal faces <i>(FWi) -> SFS</i> | *BOPAlgo_BOP::BuildSolid ()* |
1891 | 2.3 | Build solids <i>(SDi)</i> from *SFS*. | *BOPAlgo_BuilderSolid* |
1892 | 2.4 | Add the solids <i>(SDi)</i> to the result | |
1894 @section occt_algorithms_10a Section Algorithm
1896 @subsection occt_algorithms_10a_1 Arguments
1898 The arguments of BOA are shapes in terms of *TopoDS_Shape*. The main requirements for the arguments are described in the Algorithms.
1900 @subsection occt_algorithms_10a_2 Results and general rules
1901 * The result of Section operation is a compound. Each sub-shape of the compound has shared sub-shapes in accordance with interferences between the arguments.
1902 * The result of Section operation contains shapes that have dimension that is less then 2 i.e. vertices and edges.
1903 * The result of Section operation contains standalone vertices if these vertices do not belong to the edges of the result.
1904 * The result of Section operation contains vertices and edges of the arguments (or images of the arguments) that belong to at least two arguments (or two images of the arguments).
1905 * The result of Section operation contains Section vertices and edges obtained from Face/Face interferences.
1906 * The result of Section operation contains vertices that are the result of interferences between vertices and faces.
1907 * The result of Section operation contains edges that are the result of interferences between edges and faces (Common Blocks),
1909 @subsection occt_algorithms_10a_3 Examples
1911 @subsubsection occt_algorithms_10a_3_1 Case 1: Two Vertices
1913 Let us consider two interfering vertices: *V1* and *V2*.
1915 @figure{/user_guides/boolean_operations/images/boolean_image080.png,"",131}
1917 The result of *Section* operation is the compound that contains a new vertex *V*.
1919 @figure{/user_guides/boolean_operations/images/boolean_image081.png,"",128}
1921 @subsubsection occt_algorithms_10a_3_2 Case 1: Case 2: A Vertex and an Edge
1923 Let us consider vertex *V1* and the edge *E2*, that intersect in a 3D point:
1925 @figure{/user_guides/boolean_operations/images/boolean_image082.png,"",230}
1927 The result of *Section* operation is the compound that contains vertex *V1*.
1929 @figure{/user_guides/boolean_operations/images/boolean_image083.png,"",230}
1931 @subsubsection occt_algorithms_10a_3_3 Case 1: Case 2: A Vertex and a Face
1933 Let us consider vertex *V1* and face *F2*, that intersect in a 3D point:
1935 @figure{/user_guides/boolean_operations/images/boolean_image084.png,"",230}
1937 The result of *Section* operation is the compound that contains vertex *V1*.
1939 @figure{/user_guides/boolean_operations/images/boolean_image085.png,"",230}
1941 @subsubsection occt_algorithms_10a_3_4 Case 4: A Vertex and a Solid
1943 Let us consider vertex *V1* and solid *Z2*. The vertex *V1* is inside the solid *Z2*.
1945 @figure{/user_guides/boolean_operations/images/boolean_image086.png,"",230}
1947 The result of *Section* operation is an empty compound.
1949 @subsubsection occt_algorithms_10a_3_5 Case 5: Two edges intersecting at one point
1951 Let us consider edges *E1* and *E2*, that intersect in a 3D point:
1953 @figure{/user_guides/boolean_operations/images/boolean_image087.png,"",230}
1955 The result of *Section* operation is the compound that contains a new vertex *Vnew*.
1957 @figure{/user_guides/boolean_operations/images/boolean_image088.png,"",230}
1959 @subsubsection occt_algorithms_10a_3_6 Case 6: Two edges having a common block
1961 Let us consider edges *E1* and *E2*, that have a common block:
1963 @figure{/user_guides/boolean_operations/images/boolean_image089.png,"",230}
1965 The result of *Section* operation is the compound that contains a new edge *Enew*.
1967 @figure{/user_guides/boolean_operations/images/boolean_image090.png,"",230}
1969 @subsubsection occt_algorithms_10a_3_7 Case 7: An Edge and a Face intersecting at a point
1971 Let us consider edge *E1* and face *F2*, that intersect at a 3D point:
1973 @figure{/user_guides/boolean_operations/images/boolean_image091.png,"",230}
1975 The result of *Section* operation is the compound that contains a new vertex *Vnew*.
1977 @figure{/user_guides/boolean_operations/images/boolean_image092.png,"",230}
1979 @subsubsection occt_algorithms_10a_3_8 Case 8: A Face and an Edge that have a common block
1981 Let us consider edge *E1* and face *F2*, that have a common block:
1983 @figure{/user_guides/boolean_operations/images/boolean_image093.png,"",230}
1985 The result of *Section* operation is the compound that contains new edge *Enew*.
1987 @figure{/user_guides/boolean_operations/images/boolean_image094.png,"",230}
1990 @subsubsection occt_algorithms_10a_3_9 Case 9: An Edge and a Solid intersecting at a point
1992 Let us consider edge *E1* and solid *Z2*, that intersect at a point:
1994 @figure{/user_guides/boolean_operations/images/boolean_image095.png,"",230}
1996 The result of *Section* operation is the compound that contains a new vertex *Vnew*.
1998 @figure{/user_guides/boolean_operations/images/boolean_image096.png,"",230}
2000 @subsubsection occt_algorithms_10a_3_10 Case 10: An Edge and a Solid that have a common block
2002 Let us consider edge *E1* and solid *Z2*, that have a common block at a face:
2004 @figure{/user_guides/boolean_operations/images/boolean_image097.png,"",230}
2006 The result of *Section* operation is the compound that contains a new edge *Enew*.
2008 @figure{/user_guides/boolean_operations/images/boolean_image098.png,"",230}
2010 @subsubsection occt_algorithms_10a_3_11 Case 11: Two intersecting faces
2012 Let us consider two intersecting faces *F1* and *F2*:
2014 @figure{/user_guides/boolean_operations/images/boolean_image099.png,"",230}
2016 The result of *Section* operation is the compound that contains a new edge *Enew*.
2018 @figure{/user_guides/boolean_operations/images/boolean_image100.png,"",230}
2020 @subsubsection occt_algorithms_10a_3_12 Case 12: Two faces that have a common part
2022 Let us consider two faces *F1* and *F2* that have a common part:
2024 @figure{/user_guides/boolean_operations/images/boolean_image133.png,"",230}
2026 The result of *Section* operation is the compound that contains 4 new edges.
2028 @figure{/user_guides/boolean_operations/images/boolean_image134.png,"",230}
2030 @subsubsection occt_algorithms_10a_3_13 Case 13: Two faces that have overlapping edges
2032 Let us consider two faces *F1* and *F2* that have a overlapping edges:
2034 @figure{/user_guides/boolean_operations/images/boolean_image101.png,"",230}
2036 The result of *Section* operation is the compound that contains a new edge *Enew*.
2038 @figure{/user_guides/boolean_operations/images/boolean_image102.png,"",230}
2040 @subsubsection occt_algorithms_10a_3_14 Case 14: Two faces that have overlapping vertices
2042 Let us consider two faces *F1* and *F2* that have overlapping vertices:
2044 @figure{/user_guides/boolean_operations/images/boolean_image103.png,"",230}
2046 The result of *Section* operation is the compound that contains a new vertex *Vnew*.
2048 @figure{/user_guides/boolean_operations/images/boolean_image104.png,"",230}
2050 @subsubsection occt_algorithms_10a_3_15 Case 15: A Face and a Solid that have an intersection curve
2052 Let us consider face *F1* and solid *Z2* that have an intersection curve:
2054 @figure{/user_guides/boolean_operations/images/boolean_image105.png,"",230}
2056 The result of *Section* operation is the compound that contains new edges.
2058 @figure{/user_guides/boolean_operations/images/boolean_image106.png,"",230}
2060 @subsubsection occt_algorithms_10a_3_16 Case 16: A Face and a Solid that have overlapping faces.
2062 Let us consider face *F1* and solid *Z2* that have overlapping faces:
2064 @figure{/user_guides/boolean_operations/images/boolean_image107.png,"",230}
2066 The result of *Section* operation is the compound that contains new edges
2068 @figure{/user_guides/boolean_operations/images/boolean_image108.png,"",230}
2070 @subsubsection occt_algorithms_10a_3_17 Case 17: A Face and a Solid that have overlapping edges.
2072 Let us consider face *F1* and solid *Z2* that have a common part on edge:
2074 @figure{/user_guides/boolean_operations/images/boolean_image109.png,"",230}
2076 The result of *Section* operation is the compound that contains a new edge *Enew*.
2078 @figure{/user_guides/boolean_operations/images/boolean_image110.png,"",230}
2080 @subsubsection occt_algorithms_10a_3_18 Case 18: A Face and a Solid that have overlapping vertices.
2082 Let us consider face *F1* and solid *Z2* that have overlapping vertices:
2084 @figure{/user_guides/boolean_operations/images/boolean_image111.png,"",230}
2086 The result of *Section* operation is the compound that contains a new vertex *Vnew*.
2088 @figure{/user_guides/boolean_operations/images/boolean_image112.png,"",230}
2090 @subsubsection occt_algorithms_10a_3_19 Case 19: Two intersecting Solids
2092 Let us consider two intersecting solids *Z1* and *Z2*:
2093 @figure{/user_guides/boolean_operations/images/boolean_image113.png,"",230}
2095 The result of *Section* operation is the compound that contains new edges.
2096 @figure{/user_guides/boolean_operations/images/boolean_image114.png,"",230}
2098 @subsubsection occt_algorithms_10a_3_20 Case 20: Two Solids that have overlapping faces
2100 Let us consider two solids *Z1* and *Z2* that have a common part on face:
2101 @figure{/user_guides/boolean_operations/images/boolean_image115.png,"",230}
2103 The result of *Section* operation is the compound that contains new edges.
2104 @figure{/user_guides/boolean_operations/images/boolean_image116.png,"",230}
2106 @subsubsection occt_algorithms_10a_3_21 Case 21: Two Solids that have overlapping edges
2108 Let us consider two solids *Z1* and *Z2* that have overlapping edges:
2109 @figure{/user_guides/boolean_operations/images/boolean_image117.png,"",230}
2111 The result of *Section* operation is the compound that contains a new edge *Enew*.
2112 @figure{/user_guides/boolean_operations/images/boolean_image118.png,"",230}
2114 @subsubsection occt_algorithms_10a_3_22 Case 22: Two Solids that have overlapping vertices
2116 Let us consider two solids *Z1* and *Z2* that have overlapping vertices:
2117 @figure{/user_guides/boolean_operations/images/boolean_image119.png,"",230}
2119 The result of *Section* operation is the compound that contains a new vertex *Vnew*.
2120 @figure{/user_guides/boolean_operations/images/boolean_image120.png,"",230}
2122 @subsection occt_algorithms_10a_4 Class BOPAlgo_Section
2124 SA is implemented in the class *BOPAlgo_Section*. The class has no specific fields.
2125 The main steps of the *BOPAlgo_Section* are the same as of *BOPAlgo_Builder* except for the following steps:
2127 * Build Images for Wires;
2128 * Build Result of Type Wire;
2129 * Build Images for Faces;
2130 * Build Result of Type Face;
2131 * Build Images for Shells;
2132 * Build Result of Type Shell;
2133 * Build Images for Solids;
2134 * Build Result of Type Solid;
2135 * Build Images for Type CompSolid;
2136 * Build Result of Type CompSolid;
2137 * Build Images for Compounds;
2138 Some aspects of building the result are described in the next paragraph
2140 @subsection occt_algorithms_10a_5 Building the Result
2142 | No | Contents | Implementation |
2143 | :---- | :---- | :------ |
2144 | 1 | Build the result of the operation using all information contained in *FaceInfo*, Common Block, Shared entities of the arguments, etc. | *BOPAlgo_Section:: BuildSection()* |
2146 @section occt_algorithms_10b Volume Maker Algorithm
2148 The Volume Maker algorithm has been designed for building the elementary volumes (solids) from a set of connected, intersecting, or nested shapes. The algorithm can also be useful for splitting solids into parts, or constructing new solid(s) from set of intersecting or connected faces or shells.
2149 The algorithm creates only closed solids. In general case the result solids are non-manifold: fragments of the input shapes (wires, faces) located inside the solids are added as internal sub-shapes to these solids.
2150 But the algorithm allows preventing the addition of the internal for solids parts into result. In this case the result solids will be manifold and not contain any internal parts. However, this option does not prevent from the occurrence of the internal edges or vertices in the faces.<br>
2151 Non-closed faces, free wires etc. located outside of any solid are always excluded from the result.
2153 The Volume Maker algorithm is implemented in the class BOPAlgo_MakerVolume. It is based on the General Fuse (GF) algorithm. All the options of the GF algorithm (see @ref occt_algorithms_7_3a "GF Options") are also available in this algorithm.
2155 The requirements for the arguments are the same as for the arguments of GF algorithm - they could be of any type, but each argument should be valid and not self-interfered.
2157 The algorithm allows disabling the calculation of intersections among the arguments. In this case the algorithm will run much faster, but the user should guarantee that the arguments do not interfere with each other, otherwise the result will be invalid (e.g. contain unexpected parts) or empty.
2158 This option is useful e.g. for building a solid from the faces of one shell or from the shapes that have already been intersected.
2160 @subsection occt_algorithms_10b_1 Usage
2163 The usage of the algorithm on the API level:
2165 BOPAlgo_MakerVolume aMV;
2166 // Set the arguments
2167 TopTools_ListOfShape aLS = …; // arguments
2168 aMV.SetArguments(aLS);
2170 // Set options for the algorithm
2171 // setting options for this algorithm is similar to setting options for GF algorithm (see "GF Usage" chapter)
2173 // Additional option of the algorithm
2174 Standard_Boolean bAvoidInternalShapes = Standard_False; // Set to True to exclude from the result any shapes internal to the solids
2175 aMV.SetAvoidInternalShapes(bAvoidInternalShapes);
2177 // Perform the operation
2179 if (aMV.HasErrors()) { //check error status
2183 const TopoDS_Shape& aResult = aMV.Shape(); // result of the operation
2187 To use the algorithm in Draw the command mkvolume has been implemented. The usage of this command is following:
2189 Usage: mkvolume r b1 b2 ... [-c] [-ni] [-ai]
2191 -c - use this option to have input compounds considered as set of separate arguments (allows passing multiple arguments as one compound);
2192 -ni - use this option to disable the intersection of the arguments;
2193 -ai - use this option to avoid internal for solids shapes in the result.
2196 @subsection occt_algorithms_10b_2 Examples
2199 Creation of 9832 solids from sphere and set of 63 planes:
2201 <table align="center">
2203 <td>@figure{/user_guides/boolean_operations/images/mkvolume_image001.png,"Arguments",200}</td>
2204 <td>@figure{/user_guides/boolean_operations/images/mkvolume_image002.png,"Results",200}</td>
2209 Creating compartments on a ship defined by hull shell and a set of planes. The ship is divided on compartments by five transverse bulkheads and a deck – six compartments are created:
2211 <table align="center">
2213 <td>@figure{/user_guides/boolean_operations/images/mkvolume_image003.png,"Arguments",200}</td>
2214 <td>@figure{/user_guides/boolean_operations/images/mkvolume_image004.png,"Results",200}</td>
2218 @section occt_algorithms_10c_Cells Cells Builder algorithm
2220 The Cells Builder algorithm is an extension of the General Fuse algorithm. The result of General Fuse algorithm contains all split parts of the arguments. The Cells Builder algorithm provides means to specify if any given split part of the arguments (referred to as Cell) can be taken or avoided in the result.
2222 The possibility of selecting any Cell allows combining any possible result and gives the Cells Builder algorithm a very wide sphere of application - from building the result of any Boolean operation to building the result of any application-specific operation.
2224 The algorithm builds Cells only once and then just reuses them for combining the result. This gives this algorithm the performance advantage over Boolean operations, which always rebuild the splits to obtain the desirable result.
2226 Thus, the Cells Builder algorithm can be especially useful for simulating Boolean expressions, i.e. a sequence of Boolean operations on the same arguments. Instead of performing many Boolean operations it allows getting the final result in a single operation. The Cells Builder will also be beneficial to obtain the results of different Boolean operations on the same arguments - Cut and Common, for example.
2228 The Cells Builder algorithm also provides the possibility to remove any internal boundaries between splits of the same type, i.e. to fuse any same-dimensional parts added into the result and to keep any other parts as separate. This possibility is implemented through the Cells material approach: to remove the boundary between two Cells, both Cells should be assigned with the same material ID. However, if the same material ID has been assigned to the Cells of different dimension, the removal of the internal boundaries for that material will not be performed. Currently, such case is considered a limitation for the algorithm.
2230 The algorithm can also create containers from the connected Cells added into result - WIRES from Edges, SHELLS from Faces and COMPSOLIDS from Solids.
2232 @subsection occt_algorithms_10c_Cells_1 Usage
2234 The algorithm has been implemented in the *BOPAlgo_CellsBuilder* class.
2236 Cells Builder is based on the General Fuse algorithm. Thus all options of the General Fuse algorithm (see @ref occt_algorithms_7_3a "GF Options") are also available in this algorithm.
2238 The requirements for the input shapes are the same as for General Fuse - each argument should be valid in terms of *BRepCheck_Analyzer* and *BOPAlgo_ArgumentAnalyzer*.
2240 The result of the algorithm is a compound containing the selected parts of the basic type (VERTEX, EDGE, FACE or SOLID). The default result is an empty compound. It is possible to add any Cell by using the methods *AddToRessult()* and *AddAllToResult()*. It is also possible to remove any part from the result by using methods *RemoveFromResult()* and *RemoveAllFromResult()*. The method *RemoveAllFromResult()* is also suitable for clearing the result.
2242 The Cells that should be added/removed to/from the result are defined through the input shapes containing the parts that should be taken *(ShapesToTake)* and the ones containing parts that should be avoided (ShapesToAvoid).
2243 To be taken into the result the part must be IN all shapes from *ShapesToTake* and OUT of all shapes from *ShapesToAvoid*.
2245 To remove Internal boundaries, it is necessary to set the same material to the Cells, between which the boundaries should be removed, and call the method *RemoveInternalBoundaries()*.
2246 The material should not be equal to 0, as this is the default material ID. The boundaries between Cells with this material ID will not be removed. The same Cell cannot be added with different materials.
2247 It is also possible to remove the boundaries when the result is combined. To do this, it is necessary to set the material for parts (not equal to 0) and set the flag *bUpdate* to TRUE.
2248 If the same material ID has been set for parts of different dimension, the removal of internal boundaries for this material will not be performed.
2250 It is possible to create typed Containers from the parts added into result by using method *MakeContainers()*. The type of the containers will depend on the type of the input shapes: WIRES for EDGE, SHELLS for FACES and COMPSOLIDS for SOLIDS. The result will be a compound containing containers.
2253 Here is the example of the algorithm use on the API level:
2255 BOPAlgo_CellsBuilder aCBuilder;
2256 // Set the arguments
2257 TopTools_ListOfShape aLS = …; // arguments
2258 aCBuilder.SetArguments(aLS);
2260 // Set options for the algorithm
2261 // setting options for this algorithm is similar to setting options for GF algorithm (see "GF Usage" chapter)
2264 aCBuilder.Perform(); // build splits of all arguments (GF)
2265 if (aCBuilder.HasErrors()) { // check error status
2269 // collecting of the cells into result
2270 const TopoDS_Shape& anEmptyRes = aCBuilder.Shape(); // empty result, as nothing has been added yet
2271 const TopoDS_Shape& anAllCells = aCBuilder.GetAllParts(); //all split parts
2273 TopTools_ListOfShape aLSToTake = ...; // parts of these arguments will be taken into result
2274 TopTools_ListOfShape aLSToAvoid = ...; // parts of these arguments will not be taken into result
2276 Standard_Integer iMaterial = 1; // defines the material for the cells
2277 Standard_Boolean bUpdate = Standard_False; // defines whether to update the result right now or not
2279 aCBuilder.AddToResult(aLSToTake, aLSToAvoid, iMaterial, bUpdate);
2280 aCBuilder.RemoveInternalBoundaries(); // removing of the boundaries
2281 TopoDS_Shape aResult = aCBuilder.Shape(); // the result
2282 // removing from result
2283 aCBuilder.AddAllToResult();
2284 aCBuilder.RemoveFromResult(aLSToTake, aLSToAvoid);
2285 aResult = aCBuilder.Shape(); // the result
2290 The following set of new commands has been implemented to run the algorithm in DRAW Test Harness:
2292 bcbuild : Initialization of the Cells Builder. Use: *bcbuild r*
2293 bcadd : Add parts to result. Use: *bcadd r s1 (0,1) s2 (0,1) ... [-m material [-u]]*
2294 bcaddall : Add all parts to result. Use: *bcaddall r [-m material [-u]]*
2295 bcremove : Remove parts from result. Use: *bcremove r s1 (0,1) s2 (0,1) ...*
2296 bcremoveall : Remove all parts from result. Use: *bcremoveall*
2297 bcremoveint : Remove internal boundaries. Use: *bcremoveint r*
2298 bcmakecontainers : Make containers from the parts added to result. Use: *bcmakecontainers r*
2301 Here is the example of the algorithm use on the DRAW level:
2306 ttranslate s1 0 0 10
2307 ttranslate s2 20 0 10
2308 ttranslate s3 10 0 0
2309 bclearobjects; bcleartools
2310 baddobjects s1 s2 s3
2312 # rx will contain all split parts
2314 # add to result the part that is common for all three spheres
2315 bcadd res s1 1 s2 1 s3 1 -m 1
2316 # add to result the part that is common only for first and third spheres
2317 bcadd res s1 1 s2 0 s3 1 -m 1
2318 # remove internal boundaries
2322 @subsection occt_algorithms_10c_Cells_2 Examples
2324 The following simple example illustrates the possibilities of the algorithm working on a cylinder and a sphere intersected by a plane:
2329 plane p 0 0 20 1 0 0
2330 mkface f p -25 30 -17 17
2333 @figure{/user_guides/boolean_operations/images/cells_algorithm_001.png,"Arguments",160}
2343 #### 1. Common for all arguments
2347 bcadd res c 1 s 1 f 1
2350 @figure{/user_guides/boolean_operations/images/cells_algorithm_002.png,"The result of COMMON operation",126}
2352 #### 2. Common between cylinder and face
2359 @figure{/user_guides/boolean_operations/images/cells_algorithm_003.png,"The result of COMMON operation between cylinder and face",90}
2361 #### 3. Common between cylinder and sphere
2368 @figure{/user_guides/boolean_operations/images/cells_algorithm_004.png,"The result of COMMON operation between cylinder and sphere",120}
2370 #### 4. Fuse of cylinder and sphere
2379 @figure{/user_guides/boolean_operations/images/cells_algorithm_005.png,"The result of FUSE operation between cylinder and sphere",160}
2381 #### 5. Parts of the face inside solids - FUSE(COMMON(f, c), COMMON(f, s))
2385 bcadd res f 1 s 1 -m 1
2386 bcadd res f 1 c 1 -m 1
2389 @figure{/user_guides/boolean_operations/images/cells_algorithm_006_1.png,"Parts of the face inside solids",160}
2395 @figure{/user_guides/boolean_operations/images/cells_algorithm_006_2.png,"Unified parts of the face inside solids",160}
2397 #### 6. Part of the face outside solids
2401 bcadd res f 1 c 0 s 0
2404 @figure{/user_guides/boolean_operations/images/cells_algorithm_007.png,"Part of the face outside solids",160}
2406 #### 7. Fuse operation (impossible using standard Boolean Fuse operation)
2412 bcadd res f 1 c 0 s 0
2416 @figure{/user_guides/boolean_operations/images/cells_algorithm_008.png,"Fuse operation",160}
2419 These examples may last forever. To define any new operation, it is just necessary to define, which Cells should be taken and which should be avoided.
2422 @section occt_algorithms_10 Algorithm Limitations
2424 The chapter describes the problems that are considered as Algorithm limitations. In most cases an Algorithm failure is caused by a combination of various factors, such as self-interfered arguments, inappropriate or ungrounded values of the argument tolerances, adverse mutual position of the arguments, tangency, etc.
2426 A lot of failures of GFA algorithm can be caused by bugs in low-level algorithms: Intersection Algorithm, Projection Algorithm, Approximation Algorithm, Classification Algorithm, etc.
2427 * The Intersection, Projection and Approximation Algorithms are mostly used at the Intersection step. Their bugs directly cause wrong section results (i.e. incorrect section edges, section points, missing section edges or micro edges). It is not possible to obtain a correct final result of the GFA if a section result is wrong.
2428 * The Projection Algorithm is used at the Intersection step. The purpose of Projection Algorithm is to compute 2D curves on surfaces. Wrong results here lead to incorrect or missing faces in the final GFA result.
2429 * The Classification Algorithm is used at the Building step. The bugs in the Classification Algorithm lead to errors in selecting shape parts (edges, faces, solids) and ultimately to a wrong final GFA result.
2431 The description below illustrates some known GFA limitations. It does not enumerate exhaustively all problems that can arise in practice. Please, address cases of Algorithm failure to the OCCT Maintenance Service.
2434 @subsection occt_algorithms_10_1 Arguments
2436 @subsubsection occt_algorithms_10_1_1 Common requirements
2438 Each argument should be valid (in terms of *BRepCheck_Analyzer*), or conversely, if the argument is considered as non-valid (in terms of *BRepCheck_Analyzer*), it cannot be used as an argument of the algorithm.
2440 The class *BRepCheck_Analyzer* is used to check the overall validity of a shape. In OCCT a Shape (or its sub-shapes) is considered valid if it meets certain criteria. If the shape is found as invalid, it can be fixed by tools from *ShapeAnalysis, ShapeUpgrade* and *ShapeFix* packages.
2442 However, it is important to note that class *BRepCheck_Analyzer* is just a tool that can have its own problems; this means that due to a specific factor(s) this tool can sometimes provide a wrong result.
2444 Let us consider the following example:
2446 The Analyzer checks distances between couples of 3D check-points <i>(Pi, PSi)</i> of edge *E* on face *F*. Point *Pi* is obtained from the 3D curve (at the parameter *ti*) of the edge. *PSi* is obtained from 2D curve (at the parameter *ti*) of the edge on surface *S* of face *F*. To be valid the distance should be less than *Tol(E)* for all couples of check-points. The number of these check-points is a predefined value (e.g. 23).
2448 Let us consider the case when edge *E* is recognized valid (in terms of *BRepCheck_Analyzer*).
2450 Further, after some operation, edge *E* is split into two edges *E1* and *E2*. Each split edge has the same 3D curve and 2D curve as the original edge *E*.
2452 Let us check *E1* (or E2). The Analyzer again checks the distances between the couples of check-points points <i>(Pi, PSi)</i>. The number of these check-points is the same constant value (23), but there is no guarantee that the distances will be less than *Tol(E)*, because the points chosen for *E1* are not the same as for *E*.
2454 Thus, if *E1* is recognized by the Analyzer as non-valid, edge *E* should also be non-valid. However *E* has been recognized as valid. Thus the Analyzer gives a wrong result for *E*.
2456 The fact that the argument is a valid shape (in terms of *BRepCheck_Analyzer*) is a necessary but insufficient requirement to produce a valid result of the Algorithms.
2458 @subsubsection occt_algorithms_10_1_3 Pure self-interference
2460 The argument should not be self-interfered, i.e. all sub-shapes of the argument that have geometrical coincidence through any topological entities (vertices, edges, faces) should share these entities.
2462 #### Example 1: Compound of two edges
2463 The compound of two edges *E1* and *E2* is a self-interfered shape and cannot be used as the argument of the Algorithms.
2465 @figure{/user_guides/boolean_operations/images/operations_image036.svg,"Compound of two edges",230}
2467 #### Example 2: Self-interfered Edge
2468 The edge *E* is a self-interfered shape and cannot be used as an argument of the Algorithms.
2470 @figure{/user_guides/boolean_operations/images/operations_image037.svg,"Self-interfered Edge",140}
2472 #### Example 3: Self-interfered Face
2473 The face *F* is a self-interfered shape and cannot be used as an argument of the Algorithms.
2475 @figure{/user_guides/boolean_operations/images/operations_image038.svg,"Self-interfered Face",230}
2477 #### Example 4: Face of Revolution
2478 The face *F* has been obtained by revolution of edge *E* around line *L*.
2480 @figure{/user_guides/boolean_operations/images/operations_image039a.png,"Face of Revolution: Arguments",230}
2481 @figure{/user_guides/boolean_operations/images/operations_image039b.png,"Face of Revolution: Result",230}
2483 In spite of the fact that face *F* is valid (in terms of *BRepCheck_Analyzer*) it is a self-interfered shape and cannot be used as the argument of the Algorithms.
2485 @subsubsection occt_algorithms_10_1_4 Self-interferences due to tolerances
2486 #### Example 1: Non-closed Edge
2488 Let us consider edge *E* based on a non-closed circle. @figure{/user_guides/boolean_operations/images/operations_image040.png,"Edge based on a non-closed circle",230}
2490 The distance between the vertices of *E* is *D=0.69799*. The values of the tolerances *Tol(V1)=Tol(V2)=0.5*.
2491 @figure{/user_guides/boolean_operations/images/operations_image041.png,"Distance and Tolerances",230}
2493 In spite of the fact that the edge *E* is valid in terms of *BRepCheck_Analyzer*, it is a self-interfered shape because its vertices are interfered. Thus, edge *E* cannot be used as an argument of the Algorithms.
2495 #### Example 2: Solid containing an interfered vertex
2497 Let us consider solid *S* containing vertex V. @figure{/user_guides/boolean_operations/images/operations_image042.png,"Solid containing an interfered vertex",230}
2499 The value of tolerance Tol(V)= 50.000075982061.
2501 @figure{/user_guides/boolean_operations/images/operations_image043.png,"Tolerance",230}
2503 In spite of the fact that solid *S* is valid in terms of *BRepCheck_Analyzer* it is a self-interfered shape because vertex *V* is interfered with a lot of sub-shapes from *S* without any topological connection with them. Thus solid *S* cannot be used as an argument of the Algorithms.
2505 @subsubsection occt_algorithms_10_1_5 Parametric representation
2506 The parameterization of some surfaces (cylinder, cone, surface of revolution) can be the cause of limitation.
2508 #### Example 1: Cylindrical surface
2509 The parameterization range for cylindrical surface is:
2511 @figure{/user_guides/boolean_operations/images/boolean_image135.png,"",230}
2513 The range of *U* coordinate is always restricted while the range of *V* coordinate is non-restricted.
2515 Let us consider a cylinder-based *Face 1* with radii *R=3* and *H=6*.
2517 @figure{/user_guides/boolean_operations/images/operations_image044.png,"Face 1",230}
2519 @figure{/user_guides/boolean_operations/images/operations_image045.png,"P-Curves for Face 1",230}
2521 Let us also consider a cylinder-based *Face 2* with radii *R=3000* and *H=6000* (resulting from scaling Face 1 with scale factor *ScF=1000*).
2523 @figure{/user_guides/boolean_operations/images/operations_image046.png,"Face 2",230}
2525 @figure{/user_guides/boolean_operations/images/operations_image047.png,"P-Curves for Face 2",230}
2527 Please, pay attention to the Zoom value of the Figures.
2529 It is obvious that starting with some value of *ScF*, e.g. *ScF>1000000*, all sloped p-Curves on *Face 2* will be almost vertical. At least, there will be no difference between the values of angles computed by standard C Run-Time Library functions, such as *double acos(double x)*. The loss of accuracy in computation of angles can cause failure of some BP sub-algorithms, such as building faces from a set of edges or building solids from a set of faces.
2532 @subsubsection occt_algorithms_10_1_6 Using tolerances of vertices to fix gaps
2534 It is possible to create shapes that use sub-shapes of lower order to avoid gaps in the tolerance-based data model.
2536 Let us consider the following example:
2538 @figure{/user_guides/boolean_operations/images/operations_image048.png,"Example",230}
2540 * Face *F* has two edges *E1* and *E2* and two vertices, the base plane is <i>{0,0,0, 0,0,1}</i>;
2541 * Edge *E1* is based on line <i>{0,0,0, 1,0,0}, Tol(E1) = 1.e-7; </i>
2542 * Edge *E2* is based on line <i>{0,1,0, 1,0,0}, Tol(E2) = 1.e-7;</i>
2543 * Vertex *V1*, point <i>{0,0.5,0}, Tol(V1) = 1;</i>
2544 * Vertex *V2*, point <i>{10,0.5,0}, Tol(V2) = 1;</i>
2545 * Face *F* is valid (in terms of *BRepCheck_Analyzer*).
2547 The values of tolerances *Tol(V1)* and *Tol(V2)* are big enough to fix the gaps between the ends of the edges, but the vertices *V1* and *V2* do not contain any information about the trajectories connecting the corresponding ends of the edges. Thus, the trajectories are undefined. This will cause failure of some sub-algorithms of BP. For example, the sub-algorithms for building faces from a set of edges use the information about all edges connected in a vertex. The situation when a vertex has several pairs of edges such as above will not be solved in a right way.
2550 @subsection occt_algorithms_11_1 Intersection problems
2551 @subsubsection occt_algorithms_11_1_1 Pure intersections and common zones
2553 #### Example: Intersecting Edges
2555 Let us consider the intersection between two edges:
2556 * *E1* is based on a line: <i>{0,-10,0, 1,0,0}, Tol(E1)=2.</i>
2557 * *E2* is based on a circle: <i>{0,0,0, 0,0,1}, R=10, Tol(E2)=2.</i>
2559 @figure{/user_guides/boolean_operations/images/operations_image049.png,"Intersecting Edges",320}
2561 The result of pure intersection between *E1* and *E2* is vertex *Vx {0,-10,0}*.
2563 The result of intersection taking into account tolerances is the common zone *CZ* (part of 3D-space where the distance between the curves is less than or equals to the sum of edge tolerances.
2565 The Intersection Part of Algorithms uses the result of pure intersection *Vx* instead of *CZ* for the following reasons:
2566 * The Algorithms do not produce Common Blocks between edges based on underlying curves of explicitly different type (e.g. Line / Circle). If the curves have different types, the rule of thumb is that the produced result is of type **vertex**. This rule does not work for non-analytic curves (Bezier, B-Spline) and their combinations with analytic curves.
2567 * The algorithm of intersection between two surfaces *IntPatch_Intersection* does not compute *CZ* of the intersection between curves and points. So even if *CZ* were computed by Edge/Edge intersection algorithm, its result could not be treated by Face/Face intersection algorithm.
2569 @subsubsection occt_algorithms_11_2_2 Tolerances and inaccuracies
2571 The following limitations result from modeling errors or inaccuracies.
2573 #### Example: Intersection of planar faces
2575 Let us consider two planar rectangular faces *F1* and *F2*.
2577 The intersection curve between the planes is curve *C12*. The curve produces a new intersection edge *EC12*. The edge goes through vertices *V1* and *V2* thanks to big tolerance values of vertices *Tol(V1)* and *Tol(V2)*. So, two straight edges *E12* and *EC12* go through two vertices, which is impossible in this case.
2579 @figure{/user_guides/boolean_operations/images/operations_image050.svg,"Intersecting Faces",320}
2582 The problem cannot be solved in general, because the length of *E12* can be infinite and the values of *Tol(V1)* and *Tol(V2)* theoretically can be infinite too.
2584 In a particular case the problem can be solved in several ways:
2585 * Reduce, if possible, the values of *Tol(V1)* and *Tol(V2)* (refinement of *F1*).
2586 * Analyze the value of *Tol(EC12)* and increase *Tol(EC12)* to get a common part between the edges *EC12* and *E12*. Then the common part will be rejected as there is an already existing edge *E12* for face *F1*.
2588 It is easy to see that if *C12* is slightly above the tolerance spheres of *V1* and *V2* the problem does not appear.
2590 #### Example: Intersection of two edges
2592 Let us consider two edges *E1* and *E2*, which have common vertices *V1* and *V2*. The edges *E1* and *E2* have 3D-curves *C1* and *C2. Tol(E1)=1.e<sup>-7</sup>, Tol(E2)=1.e<sup>-7</sup>.*
2594 *C1* practically coincides in 3D with *C2*. The value of deflection is *Dmax* (e.g. *Dmax=1.e<sup>-6</sup>*).
2596 @figure{/user_guides/boolean_operations/images/operations_image051.svg,"Intersecting Edges",420}
2598 The evident and prospective result should be the Common Block between *E1* and *E2*. However, the result of intersection differs.
2600 @figure{/user_guides/boolean_operations/images/operations_image052.svg,"Result of Intersection",420}
2602 The result contains three new vertices *Vx1, Vx2* and *Vx3*, 8 new edges <i>(V1, Vx1, Vx2, Vx3, V2)</i> and no Common Blocks. This is correct due to the source data: *Tol(E1)=1.e<sup>-7</sup>, Tol(E2)=1.e<sup>-7</sup>* and <i>Dmax=1.e<sup>-6</sup></i>.
2604 In this particular case the problem can be solved by several ways:
2605 * Increase, if possible, the values *Tol(E1)* and *Tol(E2)* to get coincidence in 3D between *E1* and *E2* in terms of tolerance.
2606 * Replace *E1* by a more accurate model.
2608 The example can be extended from 1D (edges) to 2D (faces).
2610 @figure{/user_guides/boolean_operations/images/operations_image053.svg,"Intersecting Faces",420}
2612 The comments and recommendations are the same as for 1D case above.
2615 @subsubsection occt_algorithms_11_2_3 Acquired Self-interferences
2616 #### Example 1: Vertex and edge
2618 Let us consider vertex *V1* and edge *E2*.
2620 @figure{/user_guides/boolean_operations/images/operations_image054.svg,"Vertex and Edge",171}
2622 Vertex *V1* interferes with vertices *V12* and *V22*.
2623 So vertex *V21* should interfere with vertex *V22*, which is impossible because vertices *V21* and *V22* are the vertices of edge *E2*, thus *V21* is not equal to *V22*.
2625 The problem cannot be solved in general, because the length can be as small as possible to provide validity of *E2* (in the extreme case: *Length (E2) = Tol(V21) + Tol(V22) + e,* where *e-> 0*).
2627 In a particular case the problem can be solved by refinement of arguments, i.e. by decreasing the values of *Tol(V21)*, *Tol(V22)* and *Tol(V1)*.
2629 #### Example 2: Vertex and wire
2631 Let us consider vertex *V2* and wire consisting of edges *E11* and *E12*.
2633 @figure{/user_guides/boolean_operations/images/operations_image055.svg,"Vertex and Wire",200}
2635 The arguments themselves are not self-intersected.
2636 Vertex *V2* interferes with edges *E11* and *E12*. Thus, edge *E11* should interfere with edge *E22*, but it is impossible because edges *E11* and *E12* cannot interfere by the condition.
2638 The cases when a non-self-interfered argument (or its sub-shapes) become interfered due to the intersections with other arguments (or their sub-shapes) are considered as limitations for the Algorithms.
2640 @section occt_algorithms_11a Advanced Options
2642 The previous chapters describe so called Basic Operations. Most of tasks can be solved using Basic Operations. Nonetheless, there are cases that can not be solved straightforwardly by Basic Operations. The tasks are considered as limitations of Basic Operations.
2644 The chapter is devoted to Advanced Options. In some cases the usage of Advanced Options allows overcoming the limitations, improving the quality of the result of operations, robustness and performance of the operators themselves.
2646 @subsection occt_algorithms_11a_1 Fuzzy Boolean Operation
2648 Fuzzy Boolean operation is the option of Basic Operations such as General Fuse, Splitting, Boolean, Section, Maker Volume and Cells building operations, in which additional user-specified tolerance is used. This option allows operators to handle robustly cases of touching and near-coincident, misaligned entities of the arguments.
2650 The Fuzzy option is useful on the shapes with gaps or embeddings between the entities of these shapes, which are not covered by the tolerance values of these entities. Such shapes can be the result of modeling mistakes, or translating process, or import from other systems with loss of precision, or errors in some algorithms.
2652 Most likely, the Basic Operations will give unsatisfactory results on such models. The result may contain unexpected and unwanted small entities, faulty entities (in terms of *BRepCheck_Analyzer*), or there can be no result at all.
2654 With the Fuzzy option it is possible to get the expected result -- it is just necessary to define the appropriate value of fuzzy tolerance for the operation. To define that value it is necessary to measure the value of the gap (or the value of embedding depth) between the entities of the models, slightly increase it (to make the shifted entities coincident in terms of their tolerance plus the additional one) and pass it to the algorithm.
2656 Fuzzy option is included in interface of Intersection Part (class *BOPAlgo_PaveFiller*) and application programming interface (class *BRepAlgoAPI_BooleanOperation*)
2658 @subsubsection occt_algorithms_11a_1_1 Examples
2659 The following examples demonstrate the advantages of usage Fuzzy option operations over the Basic Operations in typical situations.
2663 In this example the cylinder (shown in yellow and transparent) is subtracted from the box (shown in red). The cylinder is shifted by 5e<sup>-5</sup> relatively to the box along its axis (the distance between rear faces of the box and cylinder is 5e<sup>-5</sup>).
2665 @figure{/user_guides/boolean_operations/images/boolean_image121.png,"",240}
2667 The following results are obtained using Basic Operations and the Fuzzy ones with the fuzzy value 5e<sup>-5</sup>:
2669 @figure{/user_guides/boolean_operations/images/boolean_image122.png,"Result of CUT operation obtained with Basic Operations",240}
2671 @figure{/user_guides/boolean_operations/images/boolean_image123.png,"Result of CUT operation obtained with Fuzzy Option",240}
2673 In this example Fuzzy option allows eliminating a very thin part of the result shape produced by Basic algorithm due to misalignment of rear faces of the box and the cylinder.
2677 In this example two boxes are fused. One of them has dimensions 10*10*10, and the other is 10*10.000001*10.000001 and adjacent to the first one. There is no gap in this case as the surfaces of the neighboring faces coincide, but one box is slightly greater than the other.
2679 @figure{/user_guides/boolean_operations/images/boolean_image124.png,"",240}
2681 The following results are obtained using Basic Operations and the Fuzzy ones with the fuzzy value 1e<sup>-6</sup>:
2683 @figure{/user_guides/boolean_operations/images/boolean_image125.png,"Result of CUT operation obtained with Basic Operations",240}
2685 @figure{/user_guides/boolean_operations/images/boolean_image126.png,"Result of CUT operation obtained with Fuzzy Option",240}
2687 In this example Fuzzy option allows eliminating an extremely narrow face in the result produced by Basic operation.
2691 In this example the small planar face (shown in orange) is subtracted from the big one (shown in yellow). There is a gap 1e<sup>-5</sup> between the edges of these faces.
2693 @figure{/user_guides/boolean_operations/images/boolean_image127.png,"",240}
2695 The following results are obtained using Basic Operations and the Fuzzy ones with the fuzzy value 1e<sup>-5</sup>:
2697 @figure{/user_guides/boolean_operations/images/boolean_image128.png,"Result of CUT operation obtained with Basic Operations",240}
2699 @figure{/user_guides/boolean_operations/images/boolean_image129.png,"Result of CUT operation obtained with Fuzzy Option",240}
2701 In this example Fuzzy options eliminated a pin-like protrusion resulting from the gap between edges of the argument faces.
2705 In this example the small edge is subtracted from the big one. The edges are overlapping not precisely, with max deviation between them equal to 5.28004e<sup>-5</sup>. We will use 6e<sup>-5</sup> value for Fuzzy option.
2707 @figure{/user_guides/boolean_operations/images/boolean_image130.png,"",240}
2709 The following results are obtained using Basic Operations and the Fuzzy ones with the fuzzy value 6e<sup>-5</sup>:
2711 @figure{/user_guides/boolean_operations/images/boolean_image131.png,"Result of CUT operation obtained with Basic Operations",240}
2713 @figure{/user_guides/boolean_operations/images/boolean_image132.png,"Result of CUT operation obtained with Fuzzy Option",240}
2715 This example stresses not only the validity, but also the performance issue. The usage of Fuzzy option with the appropriate value allows processing the case much faster than with the pure Basic operation. The performance gain for the case is 45 (Processor: Intel(R) Core(TM) i5-3450 CPU @ 3.10 GHz).
2717 @subsection occt_algorithms_11a_2 Gluing Operation
2719 The Gluing operation is the option of the Basic Operations such as General Fuse, Splitting, Boolean, Section, Maker Volume and Cells building operations.
2720 It has been designed to speed up the computation of the interferences 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.
2722 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:
2724 @figure{/user_guides/boolean_operations/images/glue_options_image002.png,"Intersecting faces",240}
2726 There are two possibilities of overlapping shapes:
2727 * 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. The following picture illustrates such shapes:
2729 @figure{/user_guides/boolean_operations/images/glue_options_image001.png,"Partially coinciding faces",240}
2731 * 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.
2733 @figure{/user_guides/boolean_operations/images/glue_options_image003.png,"Full coinciding faces of the boxes",240}
2735 Thus, there are two possible options - for full and partial coincidence of the shapes.
2737 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.
2739 The performance improvement in gluing mode is achieved by excluding the most time consuming computations and in some case can go up to 90%:
2740 * Exclude computation of FACE/FACE intersections for partial coincidence;
2741 * Exclude computation of VERTEX/FACE, EDGE/FACE and FACE/FACE intersections for full coincidence.
2743 By setting the Gluing option for the operation user should guarantee that the arguments are really coinciding. The algorithm does not check this itself. Setting inappropriate option for the operation is likely to lead to incorrect result.
2745 @subsubsection occt_algorithms_11a_2_1 Usage
2747 The Gluing option is an enumeration implemented in BOPAlgo_GlueEnum.hxx:
2748 * BOPAlgo_GlueOff - default value for the algorithms, Gluing is switched off;
2749 * BOPAlgo_GlueShift - Glue option for shapes with partial coincidence;
2750 * BOPAlgo_GlueFull - Glue option for shapes with full coincidence.
2753 For setting the Gluing options for the algorithm it is just necessary to call the SetGlue(const BOPAlgo_Glue) method with appropriate value:
2755 BOPAlgo_Builder aGF;
2758 // setting the gluing option to speed up intersection of the arguments
2759 aGF.SetGlue(BOPAlgo_GlueShift)
2765 For setting the Gluing options in DRAW it is necessary to call the <i>bglue</i> command with appropriate value:
2766 * 0 - default value, Gluing is off;
2767 * 1 - for partial coincidence;
2768 * 2 - for full coincidence
2774 @subsubsection occt_algorithms_11a_2_2 Examples
2775 #### Case1 - Fusing the 64 bspline boxes into one solid
2777 @figure{/user_guides/boolean_operations/images/glue_options_image004.png,"BSpline Boxes with partial coincidence",240}
2779 Performance improvement from using the GlueShift option in this case is about 70 percent.
2781 #### Case2 - Sewing faces of the shape after reading from IGES
2783 @figure{/user_guides/boolean_operations/images/glue_options_image005.png,"Faces with coinciding but not shared edges",240}
2785 Performance improvement in this case is also about 70 percent.
2787 @subsection occt_algorithms_11a_3 Safe processing mode
2789 The safe processing mode is the advanced option in Boolean Operation component. This mode can be applied to all Basic operations such as General Fuse, Splitting, Boolean, Section, Maker Volume, Cells building.
2790 This option allows keeping the input arguments untouched. In other words, switching this option on prevents the input arguments from any modification such as tolerance increase, addition of the P-Curves on edges, etc.
2792 The option can be very useful for implementation of the Undo/Redo mechanism in the applications and allows performing the operation many times without changing the inputs.
2794 By default the safe processing option is switched off for the algorithms. Enabling this option might slightly decrease the performance of the operation, because instead of the modification of some entity it will be necessary to create the copy of this entity and modify it. However, this degradation should be very small because the copying is performed only in case of necessity.
2796 The option is also available in the Intersection algorithm - *BOPAlgo_PaveFiller*. To perform several different operations on the same arguments, the safe processing mode can be enabled in PaveFiller, prepared only once and then used in operations. It is enough to set this option to PaveFiller only and all algorithms taking this PaveFiller will also work in the safe mode.
2798 @subsubsection occt_algorithms_11a_3_1 Usage
2802 To enable/disable the safe processing mode for the algorithm, it is necessary to call *SetNonDestructive()* method with the appropriate value:
2804 BOPAlgo_Builder aGF;
2807 // enabling the safe processing mode to prevent modification of the input shapes
2808 aGF.SetNonDestructive(Standard_True);
2814 To enable the safe processing mode for the operation in DRAW, it is necessary to call the <i>bnondestructive</i> command with the appropriate value:
2815 * 0 - default value, the safe mode is switched off;
2816 * 1 - the safe mode will be switched on.
2822 @subsection occt_algorithms_11a_4 How to disable check of input solids for inverted status
2824 By default, all input solids are checked for inverted status, i.e. the solids are classified to understand if they are holes in the space (negative volumes) or normal solids (positive volumes). The possibility to disable the check of the input solids for inverted status is the advanced option in Boolean Operation component. This option can be applied to all Basic operations, such as General Fuse, Splitting, Boolean, Section, Maker Volume and Cells building.
2825 This option allows avoiding time-consuming classification of the input solids and processing them in the same way as positive volumes, saving up to 10 percent of time on the cases with a big number of input solids.
2827 The classification should be disabled only if the user is sure that there are no negative volumes among the input solids, otherwise the result may be invalid.
2829 @subsubsection occt_algorithms_11a_4_1 Usage
2833 To enable/disable the classification of the input solids it is necessary to call *SetCheckInverted()* method with the appropriate value:
2835 BOPAlgo_Builder aGF;
2838 // disabling the classification of the input solid
2839 aGF.SetCheckInverted(Standard_False);
2845 To enable/disable the classification of the solids in DRAW, it is necessary to call *bcheckinverted* command with the appropriate value:
2846 * 0 - disabling the classification;
2847 * 1 - default value, enabling the classification.
2853 @subsection occt_algorithms_11a_5_obb Usage of Oriented Bounding Boxes
2855 Since Oriented Bounding Boxes are usually much tighter than Axes Aligned Bounding Boxes (for more information on OBB see the @ref occt_modat_6 "Bounding boxes" chapter of Modeling data User guide) its usage can significantly speed-up the intersection stage of the operation by reducing the number of interfering objects.
2857 @subsubsection occt_algorithms_11a_5_obb_1 Usage
2860 To enable/disable the usage of OBB in the operation it is necessary to call the *SetUseOBB()* method with the approriate value:
2862 BOPAlgo_Builder aGF;
2865 // Enabling the usage of OBB in the operation
2866 aGF.SetUseOBB(Standard_True);
2872 To enable/disable the usage of OBB in the operation in DRAW it is necessary to call the *buseobb* command with the approriate value:
2873 * 0 - disabling the usage of OBB;
2874 * 1 - enabling the usage of OBB.
2879 @section occt_algorithms_ers Errors and warnings reporting system
2881 The chapter describes the Error/Warning reporting system of the algorithms in the Boolean Component.
2883 The errors and warnings are collected in the instance of the class *Message_Report* maintained as a field by common base class of Boolean operation algorithms *BOPAlgo_Options*.
2885 The error is reported in for problems which cannot be treated and cause the algorithm to fail.
2886 In this case the result of the operation will be incorrect or incomplete or there will be no result at all.
2888 The warnings are reported for the problems which can be potentially handled or ignored and thus do not cause the algorithms to stop their work (but probably affect the result).
2890 All possible errors and warnings that can be set by the algorithm are listed in its header file.
2891 The complete list of errors and warnings that can be generated by Boolean operations is defined in *BOPAlgo_Alerts.hxx*.
2893 Use method *HasErrors()* to check for presence of error; method *HasError()* can be used to check for particular error.
2894 Methods *DumpErrors()* outputs textual description of collected errors into the stream.
2895 Similar methods *HasWarnings()*, *HasWarning()*, and *DumpWarnings()* are provided for warnings.
2897 Note that messages corresponding to errors and warnings are defined in resource file *BOPAlgo.msg*.
2898 These messages can be localized; for that put translated version to separate file and load it in the application by call to *Message_MsgFile::Load()* .
2900 Here is the example of how to use this system:
2902 BOPAlgo_PaveFiller aPF;
2903 aPF.SetArguments(...);
2905 if (aPF.HasErrors()) {
2906 aPF.DumpErrors(std::cerr);
2908 if (aPF.HasError(STANDARD_TYPE(BOPAlgo_AlertNullInputShapes)) {
2911 if (aPF.HasWarning(STANDARD_TYPE(BOPAlgo_AlertTooSmallEdge)) {
2918 DRAW commands executing Boolean operations output errors and warnings generated by these operations in textual form.
2919 Additional option allows saving shapes for which warnings have been generated, as DRAW variables.
2920 To activate this option, run command *bdrawwarnshapes* with argument 1 (or with 0 to deactivate):
2925 After setting this option and running an algorithm the result will look as follows:
2927 Warning: The interfering vertices of the same argument: ws_1_1 ws_1_2
2928 Warning: The positioning of the shapes leads to creation of small edges without valid range: ws_2_1
2932 @section occt_algorithms_history History Information
2934 All operations in Boolean Component support @ref occt_modalg_hist "History information". This chapter describes how the History is filled for these operations.
2936 Additionally to Vertices, Edges and Faces the history is also available for the Solids.
2938 The rules for filling the History information about Deleted and Modified shapes are the same as for the API algorithms.
2940 Only the rules for Generated shapes require clarification.
2941 In terms of the algorithms in Boolean Component the shape from the arguments can have Generated shapes only if these new shapes
2942 have been obtained as a result of pure intersection (not overlapping) of this shape with any other shapes from arguments. Thus, the Generated shapes are always:
2943 * VERTICES created from the intersection points and may be Generated from edges and faces only;
2944 * EDGES created from the intersection edges and may be Generated from faces only.
2946 So, only EDGES and FACES could have information about Generated shapes. For all other types of shapes the list of Generated shapes will be empty.
2948 @subsection occt_algorithms_history_ex Examples
2950 Here are some examples illustrating the History information.
2952 @subsubsection occt_algorithms_history_ex_del Deleted shapes
2954 The result of CUT operation of two overlapping planar faces (see the example below) does not contain any parts from the tool face. Thus, the tool face is considered as Deleted.
2955 If the faces are not fully coinciding, the result must contain some parts of the object face. In this case object face will be considered as not deleted.
2956 But if the faces are fully coinciding, the result must be empty, and both faces will be considered as Deleted.
2958 Example of the overlapping faces:
2962 mkface f1 p -10 10 -10 10
2963 mkface f2 p 0 20 -10 10
2972 savehistory cut_hist
2973 isdeleted cut_hist f1
2976 isdeleted cut_hist f2
2980 @subsubsection occt_algorithms_history_ex_modif Modified shapes
2982 In the FUSE operation of two edges intersecting in one point (see the example below), both edges will be split by the intersection point. All these splits will be contained in the result.
2983 Thus, each of the input edges will be Modified into its two splits.
2984 But in the CUT operation on the same edges, the tool edge will be Deleted from the result and, thus, will not have any Modified shapes.
2986 Example of the intersecting edges:
3003 savehistory fuse_hist
3005 modified m1 fuse_hist e1
3009 modified m2 fuse_hist e2
3016 savehistory cut_hist
3018 modified m1 cut_hist e1
3022 modified m2 cut_hist e2
3023 # The shape has not been modified
3027 @subsubsection occt_algorithms_history_gen Generated shapes
3029 Two intersecting edges will both have the intersection vertices Generated from them.
3031 As for the operation with intersecting faces, consider the following example:
3034 plane p1 0 0 0 0 0 1
3035 mkface f1 p1 -10 10 -10 10
3037 plane p2 0 0 0 1 0 0
3038 mkface f2 p2 -10 10 -10 10
3049 savehistory fuse_hist
3051 generated gf1 fuse_hist f1
3055 generated gf2 fuse_hist f2
3060 # common operation - result is empty
3063 savehistory com_hist
3065 generated gf1 com_hist f1
3066 # No shapes were generated from the shape
3068 generated gf2 com_hist f2
3069 # No shapes were generated from the shape
3073 @section occt_algorithms_simplification BOP result simplification
3075 The API algorithms implementing Boolean Operations provide possibility to simplify the result shape by unification of the connected tangential edges and faces.
3076 This simplification is performed by the method *SimplifyResult* which is implemented in the class *BRepAlgoAPI_BuilderAlgo* (General Fuse operation).
3077 It makes it available for users of the classes *BRepAlgoAPI_BooleanOperation* (all Boolean Operations) and *BRepAlgoAPI_Splitter* (split operation).
3079 The simplification is performed by the means of *ShapeUpgrade_UnifySameDom* algorithm. The result of operation is overwritten with the simplified result.
3081 The simplification is performed without creation of the Internal shapes, i.e. shapes connections will never be broken. It is performed on the whole result shape.
3082 Thus, if the input shapes contained connected tangent edges or faces unmodified during the operation they will also be unified.
3084 History of the simplification is merged into the main history of operation, thus it will be accounted when asking for Modified, Generated and Deleted shapes.
3086 Some options of the main operation are passed into the Unifier:
3087 - Fuzzy tolerance of the operation is given to the Unifier as the linear tolerance.
3088 - Non destructive mode here controls the safe input mode in Unifier.
3090 For controlling this possibility in DRAW the command **bsimplify** has been implemented. Please see the @ref occt_draw_bop_options "Boolean Operations options" chapter in draw user guide.
3093 @subsection occt_algorithms_simplification_examples Examples
3095 Here is the simple example of simplification of the result of Fuse operation of two boxes:
3101 box b2 3 7 0 10 10 15
3110 <table align="center">
3112 <td>@figure{/user_guides/boolean_operations/images/bop_simple_001.png, "Not simplified result", 420}</td>
3113 <td>@figure{/user_guides/boolean_operations/images/bop_simple_002.png, "Simplified result", 420}</td>
3118 @section occt_algorithms_11b Usage
3120 The chapter contains some examples of the OCCT Boolean Component usage. The usage is possible on two levels: C++ and Tcl.
3122 @subsection occt_algorithms_11b_1 Package BRepAlgoAPI
3124 The package *BRepAlgoAPI* provides the Application Programming Interface of the Boolean Component.
3126 The package consists of the following classes:
3127 * *BRepAlgoAPI_Algo* -- the root class that provides the interface for algorithms.
3128 * *BRepAlgoAPI_BuilderAlgo* -- the class API level of General Fuse algorithm.
3129 * *BRepAlgoAPI_Splitter* -- the class API level of the Splitter algorithm.
3130 * *BRepAlgoAPI_BooleanOperation* -- the root class for the classes *BRepAlgoAPI_Fuse*. *BRepAlgoAPI_Common*, *BRepAlgoAPI_Cut* and *BRepAlgoAPI_Section*.
3131 * *BRepAlgoAPI_Fuse* -- the class provides Boolean fusion operation.
3132 * *BRepAlgoAPI_Common* -- the class provides Boolean common operation.
3133 * *BRepAlgoAPI_Cut* -- the class provides Boolean cut operation.
3134 * *BRepAlgoAPI_Section* -- the class provides Boolean section operation.
3136 @figure{/user_guides/boolean_operations/images/operations_image065.png,"Diagram of BRepAlgoAPI package",420}
3138 The detailed description of the classes can be found in the corresponding .hxx files. The examples are below in this chapter.
3140 @subsection occt_algorithms_11b_2 Package BOPTest
3141 The package *BOPTest* provides the usage of the Boolean Component on Tcl level. The method *BOPTest::APICommands* contains corresponding Tcl commands:
3143 * *bapibuild* -- for General Fuse Operator;
3144 * *bapisplit* -- for Splitter Operator;
3145 * *bapibop* -- for Boolean Operator and Section Operator.
3147 The examples of how to use the commands are below in this chapter.
3149 @subsubsection occt_algorithms_11b_2_1 Case 1. General Fuse operation
3151 The following example illustrates how to use General Fuse operator:
3156 #include <TopoDS_Shape.hxx>
3157 #include <TopTools_ListOfShape.hxx>
3158 #include <BRepAlgoAPI_BuilderAlgo.hxx>
3160 BRepAlgoAPI_BuilderAlgo aBuilder;
3162 // prepare the arguments
3163 TopTools_ListOfShape& aLS=…;
3165 // set the arguments
3166 aBuilder.SetArguments(aLS);
3168 // Set options for the algorithm
3169 // setting options on this level is similar to setting options to GF algorithm on low level (see "GF Usage" chapter)
3172 // run the algorithm
3174 if (aBuilder.HasErrors()) {
3175 // an error treatment
3179 // result of the operation aR
3180 const TopoDS_Shape& aR=aBuilder.Shape();
3188 # prepare the arguments
3190 box b2 3 4 5 10 10 10
3191 box b3 5 6 7 10 10 10
3193 # clear inner contents
3194 bclearobjects; bcleartools;
3197 baddobjects b1 b2 b3
3199 # set options for the algorithm (see "GF Usage" chapter)
3203 # r is the result of the operation
3207 @subsubsection occt_algorithms_11b_2_2 Case 2. Splitting operation
3209 The following example illustrates how to use the Splitter operator:
3214 #include <TopoDS_Shape.hxx>
3215 #include <TopTools_ListOfShape.hxx>
3216 #include <BRepAlgoAPI_Splitter.hxx>
3218 BRepAlgoAPI_BuilderAlgo aSplitter;
3220 // prepare the arguments
3222 TopTools_ListOfShape& aLSObjects = … ;
3224 TopTools_ListOfShape& aLSTools = … ;
3226 // set the arguments
3227 aSplitter.SetArguments(aLSObjects);
3228 aSplitter.SetTools(aLSTools);
3230 // Set options for the algorithm
3231 // setting options for this algorithm is similar to setting options for GF algorithm (see "GF Usage" chapter)
3234 // run the algorithm
3236 // check error status
3237 if (aSplitter.HasErrors()) {
3241 // result of the operation aResult
3242 const TopoDS_Shape& aResult = aSplitter.Shape();
3248 # prepare the arguments
3251 box b2 7 0 0 10 10 10
3254 plane p 10 5 5 0 1 0
3255 mkface f p -20 20 -20 20
3257 # clear inner contents
3258 bclearobjects; bcleartools;
3265 # set options for the algorithm (see "GF Usage" chapter)
3269 # r is the result of the operation
3273 @subsubsection occt_algorithms_11b_2_3 Case 3. Common operation
3275 The following example illustrates how to use Common operation:
3280 #include <TopoDS_Shape.hxx>
3281 #include <TopTools_ListOfShape.hxx>
3282 #include < BRepAlgoAPI_Common.hxx>
3284 Standard_Boolean bRunParallel;
3285 Standard_Real aFuzzyValue;
3286 BRepAlgoAPI_Common aBuilder;
3288 // perpare the arguments
3289 TopTools_ListOfShape& aLS=…;
3290 TopTools_ListOfShape& aLT=…;
3292 bRunParallel=Standard_True;
3295 // set the arguments
3296 aBuilder.SetArguments(aLS);
3297 aBuilder.SetTools(aLT);
3299 // Set options for the algorithm
3300 // setting options for this algorithm is similar to setting options for GF algorithm (see "GF Usage" chapter)
3303 // run the algorithm
3305 if (aBuilder.HasErrors()) {
3306 // an error treatment
3310 // result of the operation aR
3311 const TopoDS_Shape& aR=aBuilder.Shape();
3319 # prepare the arguments
3321 box b2 7 0 4 10 10 10
3322 box b3 14 0 0 10 10 10
3324 # clear inner contents
3325 bclearobjects; bcleartools;
3331 # set options for the algorithm (see "GF Usage" chapter)
3335 # r is the result of the operation
3336 # 0 means Common operation
3340 @subsubsection occt_algorithms_11b_2_4 Case 4. Fuse operation
3342 The following example illustrates how to use Fuse operation:
3347 #include <TopoDS_Shape.hxx>
3348 #include <TopTools_ListOfShape.hxx>
3349 #include < BRepAlgoAPI_Fuse.hxx>
3351 Standard_Boolean bRunParallel;
3352 Standard_Real aFuzzyValue;
3353 BRepAlgoAPI_Fuse aBuilder;
3355 // perpare the arguments
3356 TopTools_ListOfShape& aLS=…;
3357 TopTools_ListOfShape& aLT=…;
3359 bRunParallel=Standard_True;
3362 // set the arguments
3363 aBuilder.SetArguments(aLS);
3364 aBuilder.SetTools(aLT);
3366 // Set options for the algorithm
3367 // setting options for this algorithm is similar to setting options for GF algorithm (see "GF Usage" chapter)
3370 // run the algorithm
3372 if (aBuilder.HasErrors()) {
3373 // an error treatment
3377 // result of the operation aR
3378 const TopoDS_Shape& aR=aBuilder.Shape();
3386 # prepare the arguments
3388 box b2 7 0 4 10 10 10
3389 box b3 14 0 0 10 10 10
3391 # clear inner contents
3392 bclearobjects; bcleartools;
3398 # set options for the algorithm (see "GF Usage" chapter)
3402 # r is the result of the operation
3403 # 1 means Fuse operation
3407 @subsubsection occt_algorithms_11b_2_5 Case 5. Cut operation
3409 The following example illustrates how to use Cut operation:
3414 #include <TopoDS_Shape.hxx>
3415 #include <TopTools_ListOfShape.hxx>
3416 #include < BRepAlgoAPI_Cut.hxx>
3418 Standard_Boolean bRunParallel;
3419 Standard_Real aFuzzyValue;
3420 BRepAlgoAPI_Cut aBuilder;
3422 // perpare the arguments
3423 TopTools_ListOfShape& aLS=…;
3424 TopTools_ListOfShape& aLT=…;
3426 bRunParallel=Standard_True;
3429 // set the arguments
3430 aBuilder.SetArguments(aLS);
3431 aBuilder.SetTools(aLT);
3433 // Set options for the algorithm
3434 // setting options for this algorithm is similar to setting options for GF algorithm (see "GF Usage" chapter)
3437 // run the algorithm
3439 if (aBuilder.HasErrors()) {
3440 // an error treatment
3444 // result of the operation aR
3445 const TopoDS_Shape& aR=aBuilder.Shape();
3453 # prepare the arguments
3455 box b2 7 0 4 10 10 10
3456 box b3 14 0 0 10 10 10
3458 # clear inner contents
3459 bclearobjects; bcleartools;
3465 # set options for the algorithm (see "GF Usage" chapter)
3469 # r is the result of the operation
3470 # 2 means Cut operation
3475 @subsubsection occt_algorithms_11b_2_6 Case 6. Section operation
3477 The following example illustrates how to use Section operation:
3482 #include <TopoDS_Shape.hxx>
3483 #include <TopTools_ListOfShape.hxx>
3484 #include < BRepAlgoAPI_Section.hxx>
3486 Standard_Boolean bRunParallel;
3487 Standard_Real aFuzzyValue;
3488 BRepAlgoAPI_Section aBuilder;
3490 // perpare the arguments
3491 TopTools_ListOfShape& aLS=…;
3492 TopTools_ListOfShape& aLT=…;
3494 bRunParallel=Standard_True;
3497 // set the arguments
3498 aBuilder.SetArguments(aLS);
3499 aBuilder.SetTools(aLT);
3501 // Set options for the algorithm
3502 // setting options for this algorithm is similar to setting options for GF algorithm (see "GF Usage" chapter)
3505 // run the algorithm
3507 if (aBuilder.HasErrors()) {
3508 // an error treatment
3512 // result of the operation aR
3513 const TopoDS_Shape& aR=aBuilder.Shape();
3521 # prepare the arguments
3523 box b2 3 4 5 10 10 10
3524 box b3 5 6 7 10 10 10
3526 # clear inner contents
3527 bclearobjects; bcleartools;
3533 # set options for the algorithm (see "GF Usage" chapter)
3537 # r is the result of the operation
3538 # 4 means Section operation