0026874: Implementation of the Partition operator in OCCT
[occt.git] / dox / user_guides / boolean_operations / boolean_operations.md
1 Boolean Operations {#occt_user_guides__boolean_operations}
2 =========================
3
4 @tableofcontents
5
6 @section occt_algorithms_1 Introduction
7
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:
9
10 * General Fuse Operator (GFA), 
11 * Boolean Operator (BOA), 
12 * Section Operator (SA), 
13 * Partition Operator (PA). 
14
15 GFA is the base algorithm for BOA, PA, SA.
16
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.
18
19
20 @section occt_algorithms_2 Overview 
21
22 @subsection occt_algorithms_2_1 Operators
23
24 @subsubsection occt_algorithms_2_1_1 Boolean operator
25
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*.
27
28 The operator can be represented as:
29
30 <i>R<sub>B</sub>=B<sub>j</sub> (G<sub>1</sub>, G<sub>2</sub>),</i>      
31
32 where:
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.
39
40
41 **Note** There is an operation *Cut21*, which is an extension for forward Cut operation, i.e <i>Cut21=Cut(G2, G1)</i>.
42
43 For more details see @ref occt_algorithms_9 "Boolean Operations Algorithm" section.
44
45 @subsubsection occt_algorithms_2_1_2 General Fuse operator
46
47 The General fuse operator can be applied to an arbitrary number of arguments in terms of *TopoDS_Shape*.
48
49 The GFA operator can be represented as:
50
51 <i>R<sub>GF</sub> = GF (S<sub>1</sub>, S<sub>2</sub> ... S<sub>n</sub>), </i>   
52
53 where
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.
57
58 The result of the Boolean operator, *R<sub>B</sub>*, can be obtained from *R<sub>GF</sub>*.
59
60 For example, for two arguments *S<sub>1</sub>* and *S<sub>2</sub>* the result *R<sub>GF</sub>* is
61
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>   
63
64 @figure{/user_guides/boolean_operations/images/operations_image001.svg,  "Operators"}
65
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>
71
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>
73
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.
75
76 For more details see @ref occt_algorithms_7 "General Fuse Algorithm" section.
77
78 @subsubsection occt_algorithms_2_1_3 Partition operator 
79
80 The Partition operator can be applied to an arbitrary number of arguments in terms of *TopoDS_Shape*. The arguments are divided on two groups: Objects, Tools. The result of PA contains all parts belonging to the Objects but does not contain the parts that belongs to the Tools only.
81
82 The PA operator can be represented as follows:
83
84 <i>R<sub>PA</sub>=PA (G<sub>1</sub>, G<sub>2</sub>),</i>
85 where:
86 * <i>R<sub>PA</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.
91
92 The result *R<sub>PA</sub>* can be obtained from *R<sub>GF</sub>* .
93
94 For example, for two arguments *S<sub>1</sub>* and  *S<sub>2</sub>* the result *R<sub>PA</sub>* is
95
96 <i>R<sub>PA</sub>=PA(S<sub>1</sub>,S<sub>2</sub>)=S<sub>p1</sub>+S<sub>p12</sub>.</i>      
97
98 In case when all arguments of the PA are Objects (no Tools), the result of PA is equivalent to the result of GFA. 
99
100 For example, when *G<sub>1</sub>* consists of shapes *S<sub>1</sub>* and *S<sub>2</sub>* the result of  *R<sub>PA</sub>* is
101
102 <i>R<sub>PA</sub>=PA(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>
103
104 The fact that the *R<sub>GF</sub>* contains the components of *R<sub>PA</sub>* allows considering GFA as the general case of PA. Thus, it is possible to implement PA as a subclass of GFA.
105
106 For more details see @ref occt_algorithms_8 "Partition Algorithm" section.
107
108 @subsubsection occt_algorithms_2_1_4 Section operator
109
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.
116
117 For more details see @ref occt_algorithms_10a "Section Algorithm" section.
118
119 @subsection occt_algorithms_2_2 Parts of algorithms 
120
121 GFA, BOA, PA 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.
122
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.
126
127 As it follows from the definition of operator results, the main differences between GFA, BOA, PA and SA are in the Building Part. The Intersection Part is the same for the algorithms.
128
129 @section occt_algorithms_3 Terms and Definitions
130
131 This chapter provides the background terms and definitions that are necessary to understand how the algorithms work. 
132
133 @subsection occt_algorithms_3_1 Interferences
134
135 There are two groups of interferences.
136
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:**
138 * Vertex/Vertex,
139 * Vertex/Edge,
140 * Vertex/Face,
141 * Edge/Edge, 
142 * Edge/Face and 
143 * Face/Face.
144
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:
146 * Vertex/Solid, 
147 * Edge/Solid, 
148 * Face/Solid and 
149 * Solid/Solid.
150
151 @subsubsection occt_algorithms_3_1_1 Vertex/Vertex interference
152
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)*.
154
155 @figure{/user_guides/boolean_operations/images/operations_image002.svg,  "Vertex/vertex interference"}
156
157 The result is a new vertex *Vn* with 3D point *Pn* and tolerance value <i>Tol(Vn)</i>. 
158
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>.
160
161 @subsubsection occt_algorithms_3_1_2    Vertex/Edge interference
162
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)*.
164
165 @figure{/user_guides/boolean_operations/images/operations_image003.svg,  "Vertex/edge interference"}
166
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>; 
168
169 and parameter *t<sub>i</sub>* of the projected point *PPi* on 3D curve *Cj* of edge *Ej*.
170
171 @subsubsection occt_algorithms_3_1_3    Vertex/Face interference
172
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)*. 
174
175 @figure{/user_guides/boolean_operations/images/operations_image004.svg,  "Vertex/face interference"}
176
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>
178
179 and parameters <i>u<sub>i</sub>, v<sub>i</sub></i> of the projected point *PPi* on surface *Sj* of face *Fj*.
180
181 @subsubsection occt_algorithms_3_1_4    Edge/Edge interference
182
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. 
184
185 Let us examine two cases:
186
187 In  the first case two edges have one or several common parts of 3D curves in terms of tolerance.
188
189 @figure{/user_guides/boolean_operations/images/operations_image005.svg,  "Edge/edge interference: common parts"}
190
191 The results are: 
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*. 
194
195 In the second case two edges have one or several common points in terms of tolerance.
196
197 @image html /user_guides/boolean_operations/images/operations_image006.svg  "Edge/edge interference: common points"
198 @image latex /user_guides/boolean_operations/images/operations_image006.svg  "Edge/edge interference: common points"
199
200 The result is a new vertex *Vn* with 3D point *Pn* and tolerance value *Tol(Vn)*.
201
202 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
204 * Parameter *t<sub>i</sub>* of *Pi* for the 3D curve *Ci*.
205 * Parameter *t<sub>j</sub>* of *Pj* for the 3D curve *Cj*.
206
207 @subsubsection occt_algorithms_3_1_5    Edge/Face interference
208
209 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
211 Let us examine two cases:
212
213 In the first case Edge *Ei* and Face *Fj* have one or several common parts in terms of tolerance. 
214
215 @figure{/user_guides/boolean_operations/images/operations_image007.svg, "Edge/face interference: common parts"}
216
217 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
219 In the second case Edge *Ei* and Face *Fj* have one or several common points in terms of tolerance.
220
221 @figure{/user_guides/boolean_operations/images/operations_image008.svg,  "Edge/face interference: common points"}
222
223 The result is a new vertex *Vn* with 3D point *Pn* and tolerance value *Tol(Vn)*. 
224
225 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
227 *       Parameter *t<sub>i</sub>* of *Pi* for the 3D curve *Ci*.
228 *       Parameters *u<sub>i</sub>* and *v<sub>i</sub>* of the projected point *PPi* on the surface *Sj* of the face *Fj*.
229
230 @subsubsection occt_algorithms_3_1_6    Face/Face Interference
231
232 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
234 @figure{/user_guides/boolean_operations/images/operations_image009.svg,  "Face/face interference: common curves"}
235
236 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
238 @figure{/user_guides/boolean_operations/images/operations_image010.svg, "Face/face interference: common points"}
239
240 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
242 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
244 * Parameters *u<sub>j</sub>*, *v<sub>j</sub>* belong to point *PPj* projected on surface *Sj* of face *Fj*.
245 * Parameters *u<sub>i</sub>* and *v<sub>i</sub>* belong to point *PPi* projected on surface *Si* of face *Fi*. 
246
247 @subsubsection occt_algorithms_3_1_7    Vertex/Solid Interference
248
249 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
251 @figure{/user_guides/boolean_operations/images/operations_image060.png,  "Vertex/Solid Interference"}
252
253 @subsubsection occt_algorithms_3_1_8 Edge/Soild Interference
254
255 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
257 @figure{/user_guides/boolean_operations/images/operations_image061.png,  "Edge/Solid Interference"}
258
259 @subsubsection occt_algorithms_3_1_9 Face/Soild Interference
260
261 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
263 @figure{/user_guides/boolean_operations/images/operations_image062.png,  "Face/Solid Interference"} 
264
265 @subsubsection occt_algorithms_3_1_10  Solid/Soild Interference
266
267 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
269 @figure{/user_guides/boolean_operations/images/operations_image063.png,  "Solid/Solid Interference"} 
270
271
272 @subsubsection occt_algorithms_3_1_11 Computation Order
273
274 The interferences between shapes are computed on the basis of increasing of the dimension value of the shape in the following order: 
275 * Vertex/Vertex, 
276 * Vertex/Edge, 
277 * Edge/Edge, 
278 * Vertex/Face, 
279 * Edge/Face, 
280 * Face/Face, 
281 * Vertex/Solid,
282 * Edge/Solid,
283 * Face/Solid,
284 * Solid/Solid.
285
286 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
288 @subsubsection occt_algorithms_3_1_12   Results
289
290 * The result of the interference is a shape that can be either interfered shape itself (or its part) or a new shape.
291 * 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.
292 * The result of the interference splits the source shapes on the parts each time as it can do that.
293
294 @subsection occt_algorithms_3_2 Paves
295
296 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
298 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
300 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.
301 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
303 @figure{/user_guides/boolean_operations/images/operations_image011.svg,  "Paves"}
304
305 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
307 The usage of paves allows binding of the vertex to the curve (or any structure that contains a curve: edge, intersection curve).
308
309
310 @subsection occt_algorithms_3_3 Pave Blocks
311
312 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
314 A pave block *PBi* is a part of the object (edge, intersection curve) between neighboring paves. 
315
316 @figure{/user_guides/boolean_operations/images/operations_image012.svg, "Pave Blocks"}
317
318 Any finite source edge *E* has at least one pave block that contains two paves *PVb* and *PVe*:
319 * Pave *PVb* corresponds to the vertex *Vb* with minimal parameter <i>t<sub>b</sub></i> on the curve of the edge.
320 * Pave *PVe* corresponds to the vertex *Ve* with maximal parameter <i>t<sub>e</sub></i> on the curve of the edge.
321
322 @subsection occt_algorithms_3_4 Shrunk Range
323
324 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)*:
325 * In case of edge, the tolerance value is the tolerance of the edge.
326 * In case of intersection curve, the tolerance value is obtained from an intersection algorithm.
327
328 @figure{/user_guides/boolean_operations/images/operations_image013.svg, "Shrunk Range"}
329
330 The theoretical parametric range of the pave block is <i>[t1C, t2C]</i>.
331
332 The positions of the vertices *V1* and *V2* of the pave block can be different. The positions are determined by the following conditions:
333 ~~~~
334 Distance (P1, P1c) is equal or less than Tol(V1) + Tol(C)
335 Distance (P2, P2c) is equal or less than Tol(V2) + Tol(C)
336 ~~~~
337 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
339 The shrunk range of the pave block is the part of 3D curve that can interfere with other shapes.
340
341 @subsection occt_algorithms_3_5 Common Blocks
342
343 The interferences of the type Edge/Edge, Edge/Face produce results as common parts.
344
345 In case of Edge/Edge interference the common parts are pave blocks that have different base edges. 
346
347 @figure{/user_guides/boolean_operations/images/operations_image014.svg, "Common Blocks: Edge/Edge interference"}
348
349 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*.
350         
351
352 In case of Edge/Face interference the common parts are pave blocks lying on a face(s).
353
354 @figure{/user_guides/boolean_operations/images/operations_image015.svg, "Common Blocks: Edge/Face interference"}
355
356 If the pave blocks *PBi* geometrically coincide with a face *Fj*, the pave blocks form common block *CB*.
357
358 In general case a common block *CB* contains:
359 * Pave blocks *PBi (i=0,1,2, 3… NbPB)*.
360 * A set of faces *Fj (j=0,1... NbF), NbF* -- number of faces.
361
362
363 @subsection occt_algorithms_3_6 FaceInfo
364
365 The structure *FaceInfo* contains the following information:
366 * Pave blocks that have state **In** for the face;
367 * Vertices that have state **In** for the face;
368 * Pave blocks that have state **On** for the face;
369 * Vertices that have state **On** for the face;
370 * Pave blocks built up from intersection curves for the face;
371 * Vertices built up from intersection points for the face.
372
373 @figure{/user_guides/boolean_operations/images/operations_image016.svg,  "Face Info"}
374
375 In the figure, for face *F1*:
376 * Pave blocks that have state **In** for the face: *PB<sub>in1</sub>*.
377 * Vertices that have state **In** for the face: *V<sub>in1</sub>*.
378 * 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>*.
379 * Vertices that have state **On** for the face: *V1, V2, V3, V4, V5, V6*.
380 * Pave blocks built up from intersection curves for the face: *PB<sub>sc1</sub>*.
381 * Vertices built up from intersection points for the face: none
382
383
384 @section occt_algorithms_4 Data Structure
385
386 Data Structure (DS) is used to:
387 * Store information about input data and intermediate results;
388 * Provide the access to the information;
389 * Provide the links between the chunks of information.
390
391 This information includes:
392 * Arguments;
393 * Shapes;
394 * Interferences;
395 * Pave Blocks;
396 * Common Blocks.
397
398 Data Structure is implemented in the class *BOPDS_DS*.
399
400 @subsection occt_algorithms_4_1 Arguments
401
402 The arguments are shapes (in terms of *TopoDS_Shape*):
403 * Number of arguments is unlimited.
404 * Each argument is a valid shape (in terms of *BRepCheck_Analyzer*).
405 * Each argument can be of one of the following types (see the Table):
406
407 | No    | Type  | Index of Type |
408 | :----- | :----- | :----- |
409 | 1     | COMPOUND      | 0 |
410 | 2     | COMPSOLID     | 1 |
411 | 3     | SOLID | 2 |
412 | 4     | SHELL | 3 |
413 | 5     | FACE  | 4 |
414 | 6     | WIRE  | 5 | 
415 | 7     | EDGE  | 6 | 
416 | 8     | VERTEX | 7 | 
417
418 * The argument of type *0 (COMPOUND)* can include any number of shapes of an arbitrary type (0, 1…7).
419 * 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.
420 * 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*). 
421 * The faces or edges of the arguments should have underlying geometry with continuity that is not less than C1.
422
423 @subsection occt_algorithms_4_2 Shapes
424
425 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).
426 The structure *BOPDS_ShapeInfo* has the following contents:
427
428
429 | Name  | Contents |
430 | :-------- | :----- |
431 | *myShape* |   Shape itself |
432 | *myType* |    Type of shape |
433 | *myBox* |     3D bounding box of the shape |
434 | *mySubShapes* | List of DS indices of sub-shapes |
435 | *myReference* | Storage for some auxiliary information |
436 | *myFlag* | Storage for some auxiliary information |
437
438 @subsection occt_algorithms_4_3 Interferences 
439
440 The information about interferences is stored in the instances of classes that are inherited from class <i>BOPDS_Interf</i>. 
441
442 | Name  | Contents |
443 | :----- | :----- | 
444 | *BOPDS_Interf* |      Root class for interference |
445 | *Index1*      | DS index of the shape 1 |
446 | *Index2*      | DS index of the shape 2 |
447 | *BOPDS_InterfVV* | Storage for Vertex/Vertex interference |
448 | *BOPDS_InterfVE* | Storage for Vertex/Edge interference |
449 | *myParam* | The value of parameter of the point of the vertex on the curve of the edge |
450 | *BOPDS_InterfVF* | Storage for Vertex/Face interference |
451 | *myU, myV* |  The value of parameters of the point of the vertex on the surface of the face |
452 | *BOPDS_InterfEE* | Storage for Edge/Edge interference |
453 | *myCommonPart* | Common part (in terms of *IntTools_CommonPart* ) |
454 | *BOPDS_InterfEF* | Storage for Edge/Face interference |
455 | *myCommonPart*        | Common part (in terms of *IntTools_CommonPart* ) | 
456 | *BOPDS_InterfFF* | Storage for Face/Face interference |
457 | *myTolR3D, myTolR2D* | The value of tolerances of curves (points) reached in 3D and 2D |
458 | *myCurves* | Intersection Curves (in terms of *BOPDS_Curve*) |
459 | *myPoints* | Intersection Points (in terms of *BOPDS_Point*) |
460 | *BOPDS_InterfVZ* | Storage for Vertex/Solid interference |
461 | *BOPDS_InterfEZ* | Storage for Edge/Solid interference |
462 | *BOPDS_InterfFZ* | Storage for Face/Solid interference |
463 | *BOPDS_InterfZZ* | Storage for Solid/Solid interference | 
464
465
466
467
468
469 The Figure shows inheritance diagram for *BOPDS_Interf* classes.
470
471 @figure{/user_guides/boolean_operations/images/operations_image017.svg,  "BOPDS_Interf classes"}
472
473
474 @subsection occt_algorithms_4_4 Pave, PaveBlock and CommonBlock
475
476 The information about the pave is stored in objects of type *BOPDS_Pave*.
477
478 | Name | Contents |
479 | :--- | :------ |
480 | *BOPDS_Pave*  | |
481 | *myIndex* |   DS index of the vertex |
482 | *myParam* |   Value of the parameter of the 3D point of vertex on curve. |
483
484 The information about pave blocks is stored in objects of type *BOPDS_PaveBlock*.
485
486 | Name  | Contents |
487 | :--- | :------ |
488 | *BOPDS_PaveBlock*     | |
489 | *myEdge* | DS index of the edge produced from the pave block |
490 | *myOriginalEdge* | DS index of the source edge |
491 | *myPave1* | Pave 1 (in terms of *BOPDS_Pave*) |
492 | *myPave2* | Pave 2 (in terms of *BOPDS_Pave*) |
493 | *myExtPaves* | The list of paves (in terms of *BOPDS_Pave*) that is used to store paves lying inside the pave block during intersection process |
494 | *myCommonBlock* | The reference to common block (in terms of *BOPDS_CommonBlock*) if  the pave block is a common block |
495 | *myShrunkData* | The shrunk range of the pave block |
496
497 * 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>.
498 * 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
500 The information about common block is stored in objects of type *BOPDS_CommonBlock*.
501
502 | Name  | Contents |
503 | :---- | :------ |
504 | *BOPDS_CommonBlock* | |       
505 | *myPaveBlocks* | The list of pave blocks that are common in terms of @ref occt_algorithms_3_5 "Common Blocks" |
506 | *myFaces* | The list of DS indices of the faces, on which the pave blocks lie. |
507
508
509 @subsection occt_algorithms_4_5 Points and Curves
510 The information about intersection point is stored in objects of type *BOPDS_Point*. 
511
512 | Name  | Contents |
513 | :---- | :----- |
514 | *BOPDS_Point* | |     
515 | *myPnt* |     3D point |
516 | *myPnt2D1* |  2D point on the face1 |
517 | *myPnt2D2* | 2D point on the face2 |
518
519 The information about intersection curve is stored in objects of type *BOPDS_Curve*.
520
521 | Name  | Contents |
522 | :---- | :----- | 
523 | *BOPDS_Curve* | |
524 | *myCurve* | The intersection curve (in terms of *IntTools_Curve* ) |
525 | *myPaveBlocks* | The list of pave blocks that belong to the curve | 
526 | *myBox* | The bounding box of the curve (in terms of *Bnd_Box* ) |
527
528 @subsection occt_algorithms_4_6 FaceInfo
529 The information about *FaceInfo* is stored in a structure *BOPDS_FaceInfo*. 
530 The structure *BOPDS_FaceInfo* has the following contents.
531
532 | Name  | Contents |
533 | :---- | :----- |
534 | *BOPDS_FaceInfo* | |  
535 | *myPaveBlocksIn* | Pave blocks that have state In for the face |
536 | *myVerticesIn* | Vertices that have state In for the face | 
537 | *myPaveBlocksOn* | Pave blocks that have state On for the face |
538 | *myVerticesOn* | Vertices that have state On for the face | 
539 | *myPaveBlocksSc* | Pave blocks built up from intersection curves for the face |
540 | *myVerticesSc* | Vertices built up from intersection points for the face +
541
542 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
544 @section occt_algorithms_5      Intersection Part
545
546 Intersection Part (IP) is used to
547 * Initialize the Data Structure;
548 * Compute interferences between the arguments (or their sub-shapes);
549 * Compute same domain vertices, edges;
550 * Build split edges;
551 * Build section edges;
552 * Build p-curves;
553 * Store all obtained information in DS.
554
555 IP is implemented in the class *BOPAlgo_PaveFiller*.
556
557 @figure{/user_guides/boolean_operations/images/operations_image064.svg,  "Diagram for Class BOPAlgo_PaveFiller"}
558
559 @subsection occt_algorithms_5_1a Class BOPAlgo_Algo
560 The class *BOPAlgo_Algo* provides the base interface for all algorithms to provide the possibility to:
561 * Get Error status;
562 * Get Warning status;
563 * Turn on/off the parallel processing
564 * Break the operations by user request
565 * Check data;
566 * Check the result;
567 * Set the appropriate memory allocator. 
568
569 The description provided in the next paragraphs is coherent with the implementation of the method *BOPAlgo_PaveFiller::Perform()*.
570
571 @subsection occt_algorithms_5_1 Initialization
572 The input data for the step is the Arguments. The description of initialization step is shown in the Table.
573
574 | No    | Contents |    Implementation |
575 | :--- | :----- | :----- |
576 | 1     | Initialization the array of shapes (in terms of @ref occt_algorithms_4_2 "Shapes"). Filling the array of shapes. | *BOPDS_DS::Init()* |
577 | 2     | Initialization the array pave blocks (in terms of @ref occt_algorithms_4_4 "Pave, PaveBlock, CommonBlock") | *BOPDS_DS::Init()* |
578 | 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* |
579 | 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* |
580
581
582 @subsection occt_algorithms_5_2 Compute Vertex/Vertex Interferences
583
584 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 :
585
586
587 | No | Contents | Implementation |
588 | :--- | :---- | :----- | 
589 | 1 | Initialize array of Vertex/Vertex interferences. | *BOPAlgo_PaveFiller::PerformVV()* |
590 | 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* |
591 | 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()* |
592 | 4     | Build new vertices from the chains *VNc. C=0, 1…nCs.* |     *BOPAlgo_PaveFiller::PerformVV()* |
593 | 5     | Append new vertices in DS. |  *BOPDS_DS::Append()* |
594 | 6     | Append same domain vertices in DS. | *BOPDS_DS::AddShapeSD()* |
595 | 7 | Append Vertex/Vertex interferences  in DS. | *BOPDS_DS::AddInterf()* |
596
597 * 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> 
598 * These pairs produce two chains: <i>(nV11, nV12, nV13, nV14, nV15)</i> and <i>(nV21, nV22, nV23);</i>
599 * Each chain is used to create a new vertex,  *VN1* and *VN2*, correspondingly.
600
601 The example of connexity chains of interfered vertices is given in the image:
602
603 @figure{/user_guides/boolean_operations/images/operations_image018.svg, "Connexity chains of interfered vertices"}
604
605
606 @subsection occt_algorithms_5_3 Compute Vertex/Edge Interferences
607
608 The input data for this step is the DS after computing Vertex/Vertex interferences.
609
610 | No | Contents | Implementation  | 
611 | :--- | :--- | :--- |
612 | 1     | Initialize array of Vertex/Edge interferences | *BOPAlgo_PaveFiller::PerformVE()* |
613 | 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* |
614 | 3     | Compute paves. See  @ref occt_algorithms_3_1_2 "Vertex/Edge Interference" | *BOPInt_Context::ComputeVE()* | 
615 | 4     | Initialize pave blocks for the edges *Ej* involved in the interference | *BOPDS_DS:: ChangePaveBlocks()* |
616 | 5     | Append the paves into the pave blocks in terms of @ref occt_algorithms_4_4 "Pave, PaveBlock and CommonBlock" | *BOPDS_PaveBlock:: AppendExtPave()* |
617 | 6     | Append Vertex/Edge interferences in DS | *BOPDS_DS::AddInterf()* |
618
619 @subsection occt_algorithms_5_4 Update Pave Blocks
620 The input data for this step is the DS after computing Vertex/Edge Interferences.
621
622 | No | Contents | Implementation | 
623 | :--- | :---- | :--- | 
624 | 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()* | 
625
626 @subsection occt_algorithms_5_5 Compute Edge/Edge Interferences
627
628 The input data for this step is the DS after updating Pave Blocks. 
629
630 | No | Contents | Implementation  | 
631 | :---- | :---- | :----- | 
632 | 1 | Initialize array of Edge/Edge interferences | *BOPAlgo_PaveFiller::PerformEE()* |
633 | 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* |
634 | 3     | Initialize pave blocks for the edges involved in the interference, if it is necessary. |      *BOPDS_DS:: ChangePaveBlocks()* |
635 | 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()* |
636 | 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()* |
637 | 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* |
638 | 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()* |
639 | 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()* |
640 | 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()* |
641 | 9     | Split common blocks CBc by the paves. | *BOPDS_DS:: UpdateCommonBlock()* |
642 | 10 | Append Edge/Edge interferences in the DS. |      *BOPDS_DS::AddInterf()* |
643
644 The example of coinciding chains of pave blocks is given in the image:
645
646 @figure{/user_guides/boolean_operations/images/operations_image019.png,  "Coinciding chains of pave blocks"}
647
648 * The pairs of coincided pave blocks are: <i>(PB11, PB12), (PB11, PB13), (PB12, PB13), (PB21, PB22), (PB21, PB23), (PB22, PB23).</i>
649 * The pairs produce  two chains: <i>(PB11, PB12, PB13)</i> and <i>(PB21, PB22, PB23).</i>
650
651 @subsection occt_algorithms_5_6 Compute Vertex/Face Interferences
652
653 The input data for this step is the DS after computing Edge/Edge interferences.
654
655 | No | Contents | Implementation  |
656 | :---- | :--- | :---- |
657 | 1     | Initialize array of Vertex/Face interferences | *BOPAlgo_PaveFiller::PerformVF()* |
658 | 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* |
659 | 3     | Compute interference  See  @ref occt_algorithms_3_1_3 "Vertex/Face Interference" | *BOPInt_Context::ComputeVF()* |
660 | 4     | Append Vertex/Face interferences in the DS |  *BOPDS_DS::AddInterf()* |
661 | 5     | Repeat steps 2-4 for each new vertex *VNXi (i=1, 2…,NbVNX),* where *NbVNX* is the number of vertices. | *BOPAlgo_PaveFiller::TreatVerticesEE()* |
662
663 @subsection occt_algorithms_5_7 Compute Edge/Face Interferences
664 The input data for this step is the DS after computing Vertex/Face Interferences. 
665
666 | No | Contents | Implementation |
667 | :---- | :---- | :---- | 
668 | 1     | Initialize array of Edge/Face interferences | *BOPAlgo_PaveFiller::PerformEF()* |
669 | 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* |
670 | 3     | Initialize pave blocks for the edges involved in the interference, if it is necessary. | *BOPDS_DS::ChangePaveBlocks()* |
671 | 4     | Access to the pave blocks of interfered edge <i>(PBi1, PBi2…PBiNi)</i> for edge *Ei*        | *BOPAlgo_PaveFiller::PerformEF()* |
672 | 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()* |
673 | 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* |
674 | 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()* |
675 | 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()* |
676 | 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()* |
677 | 9     | Split pave blocks and common blocks *CBc* by the paves. |     *BOPAlgo_PaveFiller::PerformVertices1()*, *BOPDS_DS:: UpdatePaveBlock()* and *BOPDS_DS:: UpdateCommonBlock()* |
678 | 10 | Append Edge/Face interferences in the DS | *BOPDS_DS::AddInterf()* |
679 | 11 | Update *FaceInfo*  for all faces having EF common parts. | *BOPDS_DS:: UpdateFaceInfoIn()* |
680
681
682 @subsection occt_algorithms_5_8 Build Split Edges
683
684 The input data for this step is the DS after computing Edge/Face Interferences.
685
686 For each pave block *PB* take the following steps: 
687         
688 | No | Contents | Implementation |
689 | :--- | :--- | :--- | 
690 | 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()* | 
691 | 2     | Build the split edge *Esp* using the information from *DS* and *PBR*. | *BOPTools_Tools::MakeSplitEdge()* |
692 | 3     | Compute *BOPDS_ShapeInfo* contents for Esp | *BOPAlgo_PaveFiller::MakeSplitEdges()* |
693 | 4     | Append *BOPDS_ShapeInfo* contents to the DS | *BOPDS_DS::Append()* |
694
695 @subsection occt_algorithms_5_9 Compute Face/Face Interferences
696
697 The input data for this step is DS after building Split Edges. 
698
699 | No | Contents | Implementation |
700 | :--- | :--- | :--- | 
701 | 1 | Initialize array of Face/Face interferences | *BOPAlgo_PaveFiller::PerformFF()* |
702 | 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* |
703 | 3     | Compute Face/Face interference | *IntTools_FaceFace* |
704 | 4     | Append Face/Face interferences in the DS. | *BOPDS_DS::AddInterf()* |
705
706 @subsection occt_algorithms_5_10        Build Section Edges
707
708 The input data for this step is the DS after computing Face/Face interferences.
709
710 | No | Contents | Implementation  |
711 | :---- | :---- | :---- |
712 | 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()* |
713 | 2     | For each intersection curve *Cijk* | |        
714 | 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()* |
715 | 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()* |
716 | 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()* |
717 | 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()* |
718 | 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()* |
719 | 4     | Update face info (sections about pave blocks and vertices) | *BOPAlgo_PaveFiller::PerformFF()* |
720
721 @subsection occt_algorithms_5_11 Build P-Curves
722 The input data for this step is the DS after building section edges.
723
724 | No | Contents | Implementation |
725 | :---- | :---- | :---- |
726 | 1     | For each Face/Face interference *nFi* and *nFj* build p-Curves on *nFi* and *nFj* for each section edge *ESXk*. |     *BOPAlgo_PaveFiller::MakePCurves()* |
727 | 2     | For each pave block that is common for faces *nFi* and *nFj* build p-Curves on *nFi* and *nFj*. |     *BOPAlgo_PaveFiller::MakePCurves()* |
728
729 @subsection occt_algorithms_5_12        Process Degenerated Edges
730 The input data for this step is the DS  after building P-curves.
731
732 | No | Contents | Implementation |
733 | :---- | :---- | :---- |
734 | | For each degenerated edge *ED* having vertex *VD* | BOPAlgo_PaveFiller::ProcessDE() |
735 | 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()* |
736 | 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()* |
737 | 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()* |
738
739 @section occt_algorithms_6      General description of the Building Part
740
741 Building Part (BP) is used to 
742 * Build the result of the operation 
743 * Provide history information (in terms of <i>\::Generated(), \::Modified()</i> and <i>\::IsDeleted()</i>)
744 BP uses the DS prepared by *BOPAlgo_PaveFiller* described at chapter 5 as input data.
745 BP is implemented in the following classes:
746 * *BOPAlgo_Builder* -- for the General Fuse operator  (GFA).
747 * *BOPAlgo_BOP* -- for the Boolean Operation operator   (BOA).
748 * *BOPAlgo_Section* -- for the Section operator  (SA).
749
750 @figure{/user_guides/boolean_operations/images/operations_image020.svg, "Diagram for BP classes"}
751
752 The class *BOPAlgo_BuilderShape* provides the interface for algorithms that have:
753 * A Shape as the result;
754 * History information (in terms of <i>\::Generated(), \::Modified()</i> and <i>\::IsDeleted()).</i>
755
756 @section occt_algorithms_7      General Fuse Algorithm
757 @subsection occt_algorithms_7_1 Arguments
758 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.
759
760 @subsection occt_algorithms_7_2 Results
761
762 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*.
763 * 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.
764 * For the arguments of the type EDGE, FACE, SOLID the result contains split parts of the argument.
765 * 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).
766 The types of resulting shapes depend on the type of the corresponding argument participating in the operation. See the table below:
767
768 | No | Type of argument | Type of resulting shape | Comments |
769 | :--- | :---- | :--- | :--- |
770 | 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. | 
771 | 2     | COMPSOLID     | COMPSOLID     | The resulting COMPSOLID is built from split SOLIDs. |
772 | 3     | SOLID | Set of split SOLIDs | |
773 | 4     | SHELL | SHELL | The resulting SHELL is built from split FACEs |
774 | 5     | FACE  | Set of split FACEs | |
775 | 6     | WIRE | WIRE | The resulting WIRE is built from split EDGEs |
776 | 7     | EDGE  | Set of split EDGEs    | |
777 | 8     | VERTEX | VERTEX | |
778
779 @subsection occt_algorithms_7_3 Examples
780
781 Please, have a look at the examples, which can help to better understand the definitions.
782
783 @subsubsection occt_algorithms_7_3_1    Case 1: Three edges intersecting at a point 
784
785 Let us consider three edges: *E1, E2* and *E3* that intersect in one 3D point.
786
787 @figure{/user_guides/boolean_operations/images/operations_image021.svg, "Three Intersecting Edges"}
788
789 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*.
790
791 In this case:
792 * The argument edge *E1* has resulting split edges *E11* and *E12* (image of *E1*).
793 * The argument edge *E2* has resulting split edges *E21* and *E22* (image of *E2*).
794 * The argument edge *E3* has resulting split edges *E31* and *E32* (image of *E3*).
795
796 @subsubsection occt_algorithms_7_3_2 Case 2: Two wires and an edge
797
798 Let us consider two wires *W1 (Ew11, Ew12, Ew13)* and *W2 (Ew21, Ew22, Ew23)* and edge *E1*.
799
800 @figure{/user_guides/boolean_operations/images/operations_image022.svg,  "Two wires and an edge"}
801
802 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*. 
803
804 In this case :
805 * The argument *W1* has image *Wn1*.
806 * The argument *W2* has image *Wn2*.
807 * The argument edge *E1* has split edges *E11* and *E12*. (image of *E1*).
808 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*.
809
810 @subsubsection occt_algorithms_7_3_3 Case 3: An edge intersecting with a face
811
812 Let us consider edge *E1* and face *F2*:
813
814 @figure{/user_guides/boolean_operations/images/operations_image023.svg,  "An edge intersecting with a face"}
815
816 The result of the GF operation is a compound consisting of 3 shapes: 
817 * Split edge parts *E11* and *E12* (image of *E1*).
818 * New face *F21* with internal edge *E12* (image of *F2*).
819
820 @subsubsection occt_algorithms_7_3_4 Case 4: An edge lying on a face
821
822 Let us consider edge *E1* and face *F2*:
823
824 @figure{/user_guides/boolean_operations/images/operations_image024.svg,  "An edge lying on a face"}
825
826 The result of the GF operation is a compound consisting of 5 shapes: 
827 * Split edge parts *E11, E12* and *E13* (image of *E1*).
828 * Split face parts  *F21* and *F22* (image of *F2*).
829
830
831 @subsubsection occt_algorithms_7_3_5 Case 5: An edge and a shell
832
833 Let us consider edge *E1* and shell *Sh2* that consists of 2 faces: *F21* and *F22*
834
835 @figure{/user_guides/boolean_operations/images/operations_image025.svg, "An edge and a shell"}
836
837 The result of the GF operation is a compound consisting of 5 shapes: 
838 * Split edge parts *E11, E12 , E13* and *E14* (image of *E1*).
839 * Image shell *Sh21* (that contains split face parts  *F211, F212, F221* and *F222*).
840
841 @subsubsection occt_algorithms_7_3_6 Case 6: A wire and a shell
842
843 Let us consider  wire *W1 (E1, E2, E3, E4)* and  shell *Sh2 (F21, F22)*. 
844 @figure{/user_guides/boolean_operations/images/operations_image026.svg,  "A wire and a shell"}
845
846 The result of the GF operation is a compound consisting of 2 shapes: 
847
848 * Image wire *W11* that consists of split edge parts from wire *W1: E11, E12, E13* and *E14*.
849 * Image shell *Sh21* that contains split face parts: *F211, F212, F213, F221, F222* and *F223*.
850
851 @subsubsection occt_algorithms_7_3_7 Case 7: Three faces
852
853 Let us consider 3 faces: *F1, F2* and *F3*. @figure{/user_guides/boolean_operations/images/operations_image027.png,  "Three faces"}
854
855 The result of the GF operation is a compound consisting of 7 shapes:
856 * Split face parts: *Fn1, Fn2, Fn3, Fn4, Fn5, Fn6* and *Fn7*.
857
858 @subsubsection occt_algorithms_7_3_8 Case 8: A face and a shell
859
860 Let us consider shell *Sh1 (F11, F12, F13)* and face *F2*.
861 @figure{/user_guides/boolean_operations/images/operations_image028.png,  "A face and a shell"}
862
863 The result of the GF operation is a compound consisting of 4 shapes:
864 * Image shell *Sh11* that consists of split face parts from shell *Sh1: Fn1, Fn2, Fn3, Fn4, Fn5* and *Fn6*.
865 * Split parts of face *F2: Fn3, Fn6* and *Fn7*.
866
867 @subsubsection occt_algorithms_7_3_9 Case 9: A shell and a solid
868
869 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"}
870
871 The result of the GF operation is a compound consisting of 2 shapes:
872 * Image shell *Sh11* consisting of split face parts of *Sh1: Fn1, Fn2 ... Fn8.*
873 * Solid *So21* with internal shell. (image of *So2*).
874 @figure{/user_guides/boolean_operations/images/operations_image030.png,  "A shell and a solid: results"}
875
876 @subsubsection occt_algorithms_7_3_10 Case 10: A compound and a solid
877
878 Let us consider compound *Cm1* consisting of 2 solids *So11* and *So12*) and solid *So2*.
879 @figure{/user_guides/boolean_operations/images/operations_image031.png, "A compound and a solid: arguments"}
880
881 The result of the GF operation is a compound consisting of 4 shapes:
882 * Image compound *Cm11* consisting of split solid parts from *So11* and *So12 (Sn1, Sn2, Sn3, Sn4)*.
883 * Split parts of solid *So2 (Sn2, Sn3, Sn5)*.
884
885 @figure{/user_guides/boolean_operations/images/operations_image032.png, "A compound and a solid: results"}
886
887 @subsection occt_algorithms_7_4 Class BOPAlgo_Builder
888
889 GFA is implemented in the class *BOPAlgo_Builder*.
890
891 @subsubsection occt_algorithms_7_4_1 Fields
892
893 The main fields of the class are described in the Table: 
894
895 | Name | Contents |
896 | :---- | :---- |
897 | *myPaveFiller* |      Pointer to the *BOPAlgo_PaveFiller* object |
898 | *myDS* |      Pointer to the *BOPDS_DS* object |
899 | *myContext* | Pointer to the intersection Context |
900 | *myImages* | The Map between the source shape and its images | 
901 | *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. |
902
903 @subsubsection occt_algorithms_7_4_2 Initialization
904
905 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.
906
907 | No | Contents | Implementation |
908 | :---- | :---- | :---- |
909 | 1     | Check the readiness of the DS and *BOPAlgo_PaveFiller*. | *BOPAlgo_Builder::CheckData()* | 
910 | 2     | Build an empty result of type Compound. | *BOPAlgo_Builder::Prepare()* |
911
912 @subsubsection occt_algorithms_7_4_3 Build Images for Vertices
913
914 The input data for this step is *BOPAlgo_Builder* object  after Initialisation.
915
916 | No | Contents | Implementation  |
917 | :--- | :--- | :--- | 
918 | 1     | Fill *myShapesSD*  by SD vertices using the information from the DS. |        *BOPAlgo_Builder::FillImagesVertices()* |
919
920 @subsubsection occt_algorithms_7_4_4 Build Result of Type Vertex
921
922 The input data for this step is *BOPAlgo_Builder* object  after building images for vertices and *Type*, which is the shape type (*TopAbs_VERTEX*).
923
924 | No | Contents | Implementation |
925 | :--- | :--- | :----- |
926 | 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()* |
927
928 @subsubsection occt_algorithms_7_4_5 Build Images for Edges
929
930 The input data for this step is *BOPAlgo_Builder object* after building result of type vertex.
931
932 | No | Contents | Implementation |
933 | :---- | :---- | :----- | 
934 | 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()* |
935
936 @subsubsection occt_algorithms_7_4_6 Build Result of Type Edge
937
938 This step is the same as @ref occt_algorithms_7_4_4 "Building Result of Type Vertex", but for the type *Edge*.
939
940 @subsubsection occt_algorithms_7_4_7 Build Images for Wires
941
942 The input data for this step is: 
943 * *BOPAlgo_Builder* object after building result of type *Edge*;
944 * Original Shape -- Wire
945 * *Type* -- the shape type <i>(TopAbs_WIRE).</i>
946
947 | No | Contents | Implementation |
948 | :---- | :---- | :----- | 
949 | 1     | For all arguments of the type *Type*. Create a container C of the type *Type*. | *BOPAlgo_Builder::FillImagesContainers()* |
950 | 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()* |
951 | 3     | Fill *myImages*  for the *Original Shape* by the information above. | *BOPAlgo_Builder::FillImagesContainers()* | 
952
953 @subsubsection occt_algorithms_7_4_8    Build Result of Type Wire
954
955 This step is the same as @ref occt_algorithms_7_4_4 "Building Result of Type Vertex" but for the type *Wire*.
956
957 @subsubsection occt_algorithms_7_4_9    Build Images for Faces
958
959 The input data for this step is *BOPAlgo_Builder* object after building result of type *Wire*.
960  
961 | No | Contents | Implementation |
962 | :--- | :--- | :--- |
963 | 1     | Build Split Faces     for all interfered DS shapes *Fi* of type *FACE*. | |   
964 | 1.1 | Collect all edges or their images of *Fi(ESPij)*. |     *BOPAlgo_Builder::BuildSplitFaces()* |
965 | 1.2 | Impart to ESPij the orientation to be coherent with the original one. | *BOPAlgo_Builder::BuildSplitFaces()* |
966 | 1.3 | Collect all section edges *SEk* for *Fi*. | *BOPAlgo_Builder::BuildSplitFaces()* |
967 | 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* | 
968 | 1.5 | Impart to <i>(Fi1, Fi2…FiNbSp)</i> the orientation coherent with the original face *Fi*. | *BOPAlgo_Builder::BuildSplitFaces()* | 
969 | 1.6 | Fill the map mySplits with *Fi/(Fi1, Fi2…FiNbSp)* | *BOPAlgo_Builder::BuildSplitFaces()* |
970 | 2 | Fill Same Domain faces | *BOPAlgo_Builder::FillSameDomainFaces* | 
971 | 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()* |
972 | 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()* | 
973 | 2.3 | Fill *myShapesSD* using the chains <i>(F1C, F2C… FnC)k</i> |  *BOPAlgo_Builder::FillSameDomainFaces()* |
974 | 2.4 | Add internal vertices to split faces. | *BOPAlgo_Builder::FillSameDomainFaces()* |
975 | 2.5 | Fill *myImages* using *myShapesSD* and *mySplits*.      | *BOPAlgo_Builder::FillSameDomainFaces()* |
976
977
978 The example of chains of same domain faces is given in the image:
979
980 @figure{/user_guides/boolean_operations/images/operations_image033.svg,  "Chains of same domain faces"}
981
982 * The pairs of same domain faces are: <i>(F11, F21), (F22, F31), (F41, F51) , (F41, F6)</i> and <i>(F51, F6)</i>.
983 * The pairs produce the three chains: <i>(F11, F21), (F22, F31)</i> and <i>(F41, F51, F6)</i>.
984
985 @subsubsection occt_algorithms_7_4_10   Build Result of Type Face
986 This step is the same as @ref occt_algorithms_7_4_4 "Building Result of Type Vertex" but for the type *Face*.
987
988 @subsubsection occt_algorithms_7_4_11   Build Images for Shells
989 The input data for this step is:
990 * *BOPAlgo_Builder* object  after building result of type face;
991 * *Original Shape* -- a Shell;
992 * *Type* -- the type of the shape <i>(TopAbs_SHELL)</i>.
993
994 The procedure is the same as for building images for wires. 
995
996 @subsubsection occt_algorithms_7_4_12   Build Result of Type Shell
997 This step is the same as @ref occt_algorithms_7_4_4 "Building Result of Type Vertex" but for the type *Shell*.
998
999 @subsubsection occt_algorithms_7_4_13 Build Images for Solids
1000
1001 The input data for this step is *BOPAlgo_Builder* object after building result of type *Shell*. 
1002
1003 The following procedure is executed for all interfered DS shapes *Si* of type *SOLID*.  
1004
1005 | No | Contents | Implementation | 
1006 | :--- | :--- | :--- | 
1007 | 1     | Collect all images or non-split parts for all faces <i>(FSPij)</i> that have 3D state *In Si*. | *BOPAlgo_Builder::FillIn3DParts ()* | 
1008 | 2     | Collect all images or non-split parts for all faces of *Si* | *BOPAlgo_Builder::BuildSplitSolids()* |
1009 | 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* |
1010 | 4     | Fill the map Same Domain solids *myShapesSD* | *BOPAlgo_Builder::BuildSplitSolids()* |
1011 | 5     | Fill the map *myImages* |  *BOPAlgo_Builder::BuildSplitSolids()* |
1012 | 6     | Add internal vertices to split solids | *BOPAlgo_Builder::FillInternalShapes()* |
1013
1014 @subsubsection occt_algorithms_7_4_14 Build Result of Type Solid
1015 This step is the same as @ref occt_algorithms_7_4_4 "Building Result of Type Vertex", but for the type Solid.
1016
1017 @subsubsection occt_algorithms_7_4_15 Build Images for Type CompSolid
1018
1019 The input data for this step is:
1020 * *BOPAlgo_Builder* object after building result of type solid;
1021 * *Original Shape* -- a Compsolid;
1022 * *Type* -- the type of the shape <i>(TopAbs_COMPSOLID)</i>.
1023
1024 The procedure is the same as for building images for wires. 
1025
1026 @subsubsection occt_algorithms_7_4_16 Build Result of Type Compsolid
1027 This step is the same as @ref occt_algorithms_7_4_4 "Building Result of Type Vertex", but for the type Compsolid.
1028
1029 @subsubsection occt_algorithms_7_4_17 Build Images for Compounds
1030 The input data for this step is as follows:
1031 * *BOPAlgo_Builder* object after building results of type *compsolid*;
1032 * *Original Shape* -- a Compound;
1033 * *Type* -- the type of the shape <i>(TopAbs_COMPOUND)</i>.
1034
1035 The procedure is the same as for building images for wires. 
1036
1037 @subsubsection occt_algorithms_7_4_18 Build Result of Type Compound
1038
1039 This step is the same as @ref occt_algorithms_7_4_4 "Building Result of Type Vertex", but for the type Compound.
1040
1041 @subsubsection occt_algorithms_7_4_19 Post-Processing
1042 The purpose of the step is to correct tolerances of the result to provide its validity in terms of *BRepCheck_Analyzer.*
1043
1044 The input data for this step is a *BOPAlgo_Builder* object after building result of type compound.
1045
1046 | No |  Contents | Implementation  |
1047 | :---- | :---- | :----- |
1048 | 1     | Correct tolerances of vertices on curves | *BOPTools_Tools::CorrectPointOnCurve()* |
1049 | 2     | Correct tolerances of edges on faces | *BOPTools_Tools::CorrectCurveOnSurface()* |
1050
1051
1052 @section occt_algorithms_8  Partition Algorithm
1053
1054 The Partition algorithm is a General Fuse (GF) based algorithm. It provides means to split the group of an arbitrary number of shapes of an arbitrary dimension by the other group of an arbitrary number of shapes of an arbitrary dimension.
1055 All the options of the GF algorithm, such as Fuzzy mode, safe mode, parallel mode, gluing mode and history support are also available in this algorithm.
1056
1057 @subsection occt_algorithms_8_1 Arguments
1058
1059 * The arguments of the Partition algorithms are divided on two groups - *Objects* and *Tools*;
1060 * The requirements for the arguments (both for *Objects* and *Tools*) are the same as for General Fuse algorithm - there could be any number of arguments of any type, but each argument should be valid and not self-interfered.
1061
1062 @subsection occt_algorithms_8_2 Results
1063
1064 * The result of Partition algorithm is similar to the result of General Fuse algorithm, but it contains only the split parts of the shapes included into the group of *Objects*;
1065 * Splits parts of the shapes included only into group of *Tools* are excluded from the result;
1066 * 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.
1067
1068 @subsection occt_algorithms_8_3 Usage
1069
1070 @subsubsection occt_algorithms_8_3_1 API
1071
1072 On the low level the Partition algorithm is implemented in the class *BOPAlgo_Splitter*. The usage of this algorithm looks as follows:
1073 ~~~~~
1074 BOPAlgo_Splitter aSplitter;
1075 BOPCol_ListOfShape aLSObjects = …; // Objects
1076 BOPCol_ListOfShape aLSTools = …; // Tools
1077 Standard_Boolean bRunParallel = Standard_False; /* parallel or single mode (the default value is FALSE)*/
1078 Standard_Real aTol = 0.0; /* fuzzy option (default value is 0)*/
1079 Standard_Boolean bSafeMode = Standard_False; /* protect or not the arguments from modification*/
1080 BOPAlgo_Glue aGlue = BOPAlgo_GlueOff; /* Glue option to speed up intersection of the arguments*/
1081 // setting arguments
1082 aSplitter.SetArguments(aLSObjects);
1083 aSplitter.SetTools(aLSTools);
1084 // setting options
1085 aSplitter.SetRunParallel(bRunParallel);
1086 aSplitter.SetFuzzyValue(aTol);
1087 aSplitter.SetNonDestructive(bSafeMode);
1088 aSplitter.SetGlue(aGlue);
1089 //
1090 aSplitter.Perform(); //perform the operation
1091 if (aSplitter.ErrorStatus()) { //check error status
1092   return;
1093 }
1094 //
1095 const TopoDS_Shape& aResult = aSplitter.Shape(); // result of the operation
1096 ~~~~~
1097
1098 @subsubsection occt_algorithms_8_3_2 DRAW
1099
1100 For the usage of the Partition algorithm in DRAW the command *bsplit* is implemented. Similarly to the *bbuild* command (for the usage of the General Fuse algorithm) the *bsplit* command should be used after the Pave Filler is filled.
1101 ~~~~~
1102 # s1 s2 s3 - objects
1103 # t1 t2 t3 - tools
1104 bclearobjects
1105 bcleartools
1106 baddobjects s1 s2 s3
1107 baddtools t1 t2 t3
1108 bfillds
1109 bsplit result
1110 ~~~~~
1111
1112 @subsection occt_algorithms_8_4 Examples
1113
1114 @subsubsection occt_algorithms_8_4_1 Example 1
1115
1116 Splitting face by the set of edges:
1117
1118 ~~~~
1119 # draw script for reproducing
1120 bclearobjects
1121 bcleartools
1122
1123 set height 20
1124 cylinder cyl 0 0 0 0 0 1 10
1125 mkface f cyl 0 2*pi -$height $height
1126 baddobjects f
1127
1128 # create tool edges
1129 compound edges
1130
1131 set nb_uedges 10
1132 set pi2 [dval 2*pi]
1133 set ustep [expr $pi2/$nb_uedges]
1134 for {set i 0} {$i <= $pi2} {set i [expr $i + $ustep]} {
1135   uiso c cyl $i
1136   mkedge e c -25 25
1137   add e edges
1138 }
1139
1140 set nb_vedges 10
1141 set vstep [expr 2*$height/$nb_vedges]
1142 for {set i -20} {$i <= 20} {set i [expr $i + $vstep]} {
1143   viso c cyl $i
1144   mkedge e c
1145   add e edges
1146 }
1147 baddctools edges
1148
1149 bfillds
1150 bsplit result
1151 ~~~~
1152
1153 <table align="center">
1154 <tr>
1155   <td>@figure{/user_guides/boolean_operations/images/bsplit_image001.png, "Arguments"}</td>
1156   <td>@figure{/user_guides/boolean_operations/images/bsplit_image002.png, "Result"}</td>
1157 </tr>
1158 </table>
1159
1160 @subsubsection occt_algorithms_8_4_2 Example 2
1161
1162 Splitting plate by the set of cylinders:
1163
1164 ~~~~
1165 # draw script for reproducing:
1166 bclearobjects
1167 bcleartools
1168
1169 box plate 100 100 1
1170 baddobjects plate
1171
1172 pcylinder p 1 11
1173 compound cylinders
1174 for {set i 0} {$i < 101} {incr i 5} {
1175   for {set j 0} {$j < 101} {incr j 5} {
1176     copy p p1;
1177     ttranslate p1 $i $j -5;
1178     add p1 cylinders
1179   }
1180 }
1181 baddtools cylinders
1182
1183 bfillds
1184 bsplit result
1185 ~~~~
1186
1187 <table align="center">
1188 <tr>
1189   <td>@figure{/user_guides/boolean_operations/images/bsplit_image003.png, "Arguments"}</td>
1190   <td>@figure{/user_guides/boolean_operations/images/bsplit_image004.png, "Result"}</td>
1191 </tr>
1192 </table>
1193
1194 @subsubsection occt_algorithms_8_4_3 Example 3
1195
1196 Splitting shell hull by the planes:
1197 <table align="center">
1198 <tr>
1199   <td>@figure{/user_guides/boolean_operations/images/bsplit_image005.png, "Arguments"}</td>
1200   <td>@figure{/user_guides/boolean_operations/images/bsplit_image006.png, "Results"}</td>
1201 </tr>
1202 </table>
1203
1204 @section occt_algorithms_9      Boolean Operations Algorithm
1205
1206 @subsection occt_algorithms_9_1 Arguments
1207
1208 * 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"
1209 * There are two groups of arguments in BOA:
1210         * Objects <i>(S1=S11, S12, ...)</i>;
1211         * Tools <i>(S2=S21, S22, ...)</i>.
1212 * The following table contains the values of dimension for different types of arguments:
1213
1214 | No | Type of Argument | Index of Type | Dimension |
1215 | :---- | :---- | :----- | :---- |
1216 | 1 | COMPOUND | 0 | One of 0, 1, 2, 3 |
1217 | 2     | COMPSOLID     | 1     | 3 |
1218 | 3     | SOLID | 2     | 3 |
1219 | 4     | SHELL | 3     | 2 |
1220 | 5     | FACE | 4 | 2 |
1221 | 6     | WIRE | 5 | 1 |
1222 | 7 | EDGE | 6 | 1 |
1223 | 8 | VERTEX | 7 | 0 |
1224
1225 * For Boolean operation Fuse all arguments should have equal dimensions.
1226 * For Boolean operation Cut the minimal dimension of *S2* should not be less than the maximal dimension of *S1*.
1227 * For Boolean operation Common the arguments can have any dimension.
1228
1229 @subsection occt_algorithms_9_3 Results. General Rules
1230
1231 * 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. 
1232 * The content of the result depends on the type of the operation (Common, Fuse, Cut12, Cut21) and the dimensions of the arguments. 
1233 * 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.
1234 * 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.
1235 * 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.
1236 * 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. 
1237 * 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.
1238 * 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. 
1239 * 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*.
1240 * 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*.
1241 * 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.
1242 * 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.
1243 * 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.
1244 * 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.
1245 * 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.
1246 * 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.
1247
1248 @subsection occt_algorithms_9_4 Examples
1249
1250 @subsubsection occt_algorithms_9_4_1    Case 1: Two Vertices
1251
1252 Let us consider two interfering vertices *V1* and *V2*:
1253
1254 @figure{/user_guides/boolean_operations/images/boolean_image001.svg}
1255
1256 * The result of *Fuse* operation is the compound that contains new vertex *V*.
1257
1258 @figure{/user_guides/boolean_operations/images/boolean_image002.svg}
1259
1260 * The result of *Common* operation is a compound containing new vertex *V*.
1261
1262 * The result of *Cut12* operation is an empty compound.
1263 * The result of *Cut21* operation is an empty compound.
1264
1265 @subsubsection occt_algorithms_9_4_2    Case 2: A Vertex and an Edge
1266
1267 Let us consider vertex *V1* and the edge *E2*, that intersect in a 3D point:
1268
1269 @figure{/user_guides/boolean_operations/images/boolean_image004.png}
1270
1271 * 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).
1272
1273 * 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*.
1274
1275 @figure{/user_guides/boolean_operations/images/boolean_image005.png}
1276
1277 * The result of *Cut12* operation is an empty compound.
1278 * The result of *Cut21* operation is not defined because the dimension of the vertex (0) is less than the dimension of the edge (1).
1279
1280 @subsubsection occt_algorithms_9_4_3    Case 3: A Vertex and a Face
1281
1282 Let us consider  vertex *V1* and face *F2*, that intersect in a 3D point:
1283
1284 @figure{/user_guides/boolean_operations/images/boolean_image006.png}
1285
1286 * 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).
1287
1288 * 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*.
1289
1290 @figure{/user_guides/boolean_operations/images/boolean_image007.png}
1291
1292 * The result of *Cut12* operation is an empty compound.
1293 * The result of *Cut21* operation is not defined because the dimension of the vertex (0) is less than the dimension of the face (2).
1294
1295 @subsubsection occt_algorithms_9_4_4    Case 4: A Vertex and a Solid
1296
1297 Let us consider  vertex *V1* and solid *S2*, that intersect in a 3D point:
1298
1299 @figure{/user_guides/boolean_operations/images/boolean_image008.png}
1300
1301 * 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).
1302
1303 * 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*.
1304
1305 @figure{/user_guides/boolean_operations/images/boolean_image009.png}
1306
1307 * The result of *Cut12* operation is an empty compound.
1308 * The result of *Cut21* operation is not defined because the dimension of the vertex (0) is less than the dimension of the solid (3).
1309
1310 @subsubsection occt_algorithms_9_4_5    Case 5: Two edges intersecting at one point
1311
1312 Let us consider edges *E1* and *E2* that intersect in a 3D point:
1313
1314 @figure{/user_guides/boolean_operations/images/boolean_image010.svg}
1315
1316 * 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*. 
1317 In this case: 
1318         * argument edge *E1* has resulting split edges *E11* and *E12* (image of *E1*);
1319         * argument edge *E2* has resulting split edges *E21* and *E22* (image of *E2*).
1320         
1321 @figure{/user_guides/boolean_operations/images/boolean_image011.svg}    
1322
1323 * 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).
1324
1325 * 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*. 
1326
1327 In this case the argument edge *E1* has resulting split edges *E11* and *E12* (image of *E1*).
1328
1329 @figure{/user_guides/boolean_operations/images/boolean_image012.svg}    
1330
1331 * 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*. 
1332
1333 In this case the argument edge *E2* has resulting split edges *E21* and *E22* (image of *E2*).
1334
1335 @figure{/user_guides/boolean_operations/images/boolean_image013.svg}    
1336
1337 @subsubsection occt_algorithms_9_4_6    Case 6: Two edges having a common block
1338
1339 Let us consider edges *E1* and *E2* that have a common block:
1340
1341 @figure{/user_guides/boolean_operations/images/boolean_image014.svg}
1342
1343 * 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. 
1344 In this case: 
1345         * argument edge *E1* has resulting split edges *E11* and *E12* (image of *E1*);
1346         * argument edge *E2* has resulting split edges *E21* and *E22* (image of *E2*);
1347         * edge *E12* is common for the images of *E1* and *E2*.
1348         
1349 @figure{/user_guides/boolean_operations/images/boolean_image015.svg}    
1350
1351 * 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*. 
1352 The common part between the edges (edge) has the same dimension (1) as the dimension of the arguments (1).
1353
1354 @figure{/user_guides/boolean_operations/images/boolean_image016.svg}    
1355
1356 * The result of *Cut12* operation is a compound containing a split part of argument  *E1*, i.e. new edge *E11*. 
1357
1358 @figure{/user_guides/boolean_operations/images/boolean_image017.svg}    
1359
1360 * The result of *Cut21* operation is a compound containing a split part of argument  *E2*, i.e. new edge *E22*.
1361
1362 @figure{/user_guides/boolean_operations/images/boolean_image018.svg}    
1363
1364
1365 @subsubsection occt_algorithms_9_4_7    Case 7: An Edge and a Face intersecting at a point
1366
1367 Let us consider edge *E1* and face *F2* that intersect at a 3D point:
1368
1369 @figure{/user_guides/boolean_operations/images/boolean_image019.png}
1370
1371 * 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).
1372         
1373 * 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).
1374
1375 * The result of *Cut12* operation is a compound containing split parts of the argument  *E1*, i.e. 2 new edges *E11* and *E12*.  
1376
1377 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.
1378
1379 @figure{/user_guides/boolean_operations/images/boolean_image020.png}    
1380
1381 * The result of *Cut21* operation is not defined because the dimension of the edge (1) is less than the dimension of the face (2).
1382
1383 @subsubsection occt_algorithms_9_4_8    Case 8: A Face and an Edge that have a common block
1384
1385 Let us consider edge *E1* and face *F2* that have a common block:
1386
1387 @figure{/user_guides/boolean_operations/images/boolean_image021.png}
1388
1389 * 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).
1390         
1391 * The result of *Common* operation is a compound containing a split part of the argument  *E1*, i.e. new edge *E12*. 
1392
1393 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*.
1394
1395 @figure{/user_guides/boolean_operations/images/boolean_image022.png}
1396
1397 * The result of *Cut12* operation is a compound containing split part of the argument  *E1*, i.e. new edge *E11*.  
1398
1399 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.
1400
1401 @figure{/user_guides/boolean_operations/images/boolean_image023.png}    
1402
1403 * The result of *Cut21* operation is not defined because the dimension of the edge (1) is less than the dimension of the face (2).
1404
1405 @subsubsection occt_algorithms_9_4_9    Case 9: An Edge and a Solid intersecting at a point 
1406
1407 Let us consider edge *E1* and solid *S2* that intersect at a point:
1408
1409 @figure{/user_guides/boolean_operations/images/boolean_image024.png}
1410
1411 * 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).
1412         
1413 * The result of *Common* operation is a compound containing a split part of the argument  *E1*, i.e. new edge *E12*. 
1414
1415 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*.
1416
1417 @figure{/user_guides/boolean_operations/images/boolean_image025.png}
1418
1419 * The result of *Cut12* operation is a compound containing split part of the argument *E1*, i.e. new edge *E11*.  
1420
1421 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*.
1422
1423 @figure{/user_guides/boolean_operations/images/boolean_image071.png}    
1424
1425 * The result of *Cut21* operation is not defined because the dimension of the edge (1) is less than the dimension of the solid (3).
1426
1427 @subsubsection occt_algorithms_9_4_10 Case 10: An Edge and a Solid that have a common block 
1428
1429 Let us consider edge *E1* and solid *S2* that have a common block:
1430
1431 @figure{/user_guides/boolean_operations/images/boolean_image072.png}
1432
1433 * 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).
1434         
1435 * The result of *Common* operation is a compound containing a split part of the argument  *E1*, i.e. new edge *E12*. 
1436
1437 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*.
1438
1439 @figure{/user_guides/boolean_operations/images/boolean_image073.png}
1440
1441 * The result of *Cut12* operation is a compound containing split part of the argument *E1*, i.e. new edge *E11*.  
1442
1443 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*.
1444
1445 @figure{/user_guides/boolean_operations/images/boolean_image026.png}    
1446
1447 * The result of *Cut21* operation is not defined because the dimension of the edge (1) is less than the dimension of the solid (3).
1448
1449 @subsubsection occt_algorithms_9_4_11   Case 11: Two intersecting faces 
1450
1451 Let us consider two intersecting faces *F1* and *F2*:
1452
1453 @figure{/user_guides/boolean_operations/images/boolean_image027.png}
1454
1455 * 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*.
1456
1457 @figure{/user_guides/boolean_operations/images/boolean_image028.png}
1458
1459
1460 * 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).
1461
1462 * The result of *Cut12* operation is a compound containing split part of the argument *F1*, i.e. new face *F11*.  
1463
1464 @figure{/user_guides/boolean_operations/images/boolean_image029.png}    
1465
1466 * The result of *Cut21* operation is a compound containing split parts of the argument  *F2*, i.e. 1 new face *F21*.
1467
1468 @figure{/user_guides/boolean_operations/images/boolean_image030.png}
1469         
1470 @subsubsection occt_algorithms_9_4_12   Case 12: Two faces that have a common part
1471
1472 Let us consider two faces *F1* and *F2* that have a common part:
1473
1474 @figure{/user_guides/boolean_operations/images/boolean_image031.png}
1475
1476 * 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: 
1477         * the argument edge *F1* has resulting split faces *F11* and *F12* (image of *F1*)
1478         * the argument face *F2* has resulting split faces *F12* and *F22* (image of *F2*)
1479         * the face *F12* is common for the images of *F1* and *F2*.
1480         
1481 @figure{/user_guides/boolean_operations/images/boolean_image032.png}
1482
1483 * The result of *Common* operation is a compound containing split parts of arguments i.e. 1 new face *F12*. 
1484 In this case: face *F12* is common for the images of *F1* and *F2*.
1485 The common part between the faces (face) has the same dimension (2) as the dimension of the arguments (2).
1486
1487
1488 @figure{/user_guides/boolean_operations/images/boolean_image033.png}
1489
1490 * The result of *Cut12* operation is a compound containing split part of the argument *F1*, i.e. new face *F11*.  
1491         
1492 @figure{/user_guides/boolean_operations/images/boolean_image034.png}    
1493         
1494 * The result of *Cut21* operation is a compound containing split parts of the argument  *F2*, i.e. 1 new face *F21*.
1495
1496 @figure{/user_guides/boolean_operations/images/boolean_image035.png}
1497
1498 @subsubsection occt_algorithms_9_4_13   Case 13: Two faces that have a common edge
1499
1500 Let us consider two faces *F1* and *F2* that have a common edge:
1501
1502 @figure{/user_guides/boolean_operations/images/boolean_image036.png}
1503
1504 * 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*.
1505         
1506 @figure{/user_guides/boolean_operations/images/boolean_image037.png}
1507
1508 * 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)
1509
1510 * 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.
1511         
1512 @figure{/user_guides/boolean_operations/images/boolean_image038.png}    
1513         
1514 * 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.
1515
1516 @figure{/user_guides/boolean_operations/images/boolean_image039.png}
1517
1518 @subsubsection occt_algorithms_9_4_14   Case 14: Two faces that have a common vertex
1519
1520 Let us consider two faces *F1* and *F2* that have a common vertex:
1521
1522 @figure{/user_guides/boolean_operations/images/boolean_image040.png}
1523
1524 * 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*.
1525         
1526 @figure{/user_guides/boolean_operations/images/boolean_image041.png}
1527
1528 * 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)
1529
1530 * The result of *Cut12* operation is a compound containing split part of the argument *F1*, i.e. new face *F11*.  
1531         
1532 @figure{/user_guides/boolean_operations/images/boolean_image042.png}    
1533         
1534 * The result of *Cut21* operation is a compound containing split parts of the argument  *F2*, i.e. 1 new face *F21*. 
1535
1536 @figure{/user_guides/boolean_operations/images/boolean_image043.png}
1537
1538
1539 @subsubsection occt_algorithms_9_4_15   Case 15: A Face and a Solid that have an intersection curve.
1540
1541 Let us consider face *F1* and solid *S2* that have an intersection curve:
1542
1543 @figure{/user_guides/boolean_operations/images/boolean_image044.png}
1544
1545 * 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).
1546         
1547 * 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*.
1548
1549 @figure{/user_guides/boolean_operations/images/boolean_image045.png}
1550
1551 * 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*.
1552         
1553 @figure{/user_guides/boolean_operations/images/boolean_image046.png}    
1554         
1555 * 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).
1556
1557 @subsubsection occt_algorithms_9_4_16   Case 16: A Face and a Solid that have overlapping faces.
1558
1559 Let us consider face *F1* and solid *S2* that have overlapping faces:
1560
1561 @figure{/user_guides/boolean_operations/images/boolean_image047.png}
1562
1563 * 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).
1564
1565 * 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*.
1566
1567 @figure{/user_guides/boolean_operations/images/boolean_image048.png}
1568
1569 * 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*.
1570         
1571 @figure{/user_guides/boolean_operations/images/boolean_image049.png}    
1572         
1573 * 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).
1574
1575
1576 @subsubsection occt_algorithms_9_4_17   Case 17: A Face and a Solid that have overlapping edges.
1577
1578 Let us consider face *F1* and solid *S2* that have overlapping edges:
1579
1580 @figure{/user_guides/boolean_operations/images/boolean_image050.png}
1581
1582 * 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).
1583         
1584 * 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).
1585
1586 * 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*.
1587         
1588 @figure{/user_guides/boolean_operations/images/boolean_image051.png}    
1589         
1590 * 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).
1591
1592 @subsubsection occt_algorithms_9_4_18   Case 18: A Face and a Solid that have overlapping vertices.
1593
1594 Let us consider face *F1* and solid *S2* that have overlapping vertices:
1595
1596 @figure{/user_guides/boolean_operations/images/boolean_image052.png}
1597
1598 * 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).
1599         
1600 * 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).
1601
1602 * 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*.
1603         
1604 @figure{/user_guides/boolean_operations/images/boolean_image053.png}    
1605         
1606 * 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).
1607
1608 @subsubsection occt_algorithms_9_4_19   Case 19: Two intersecting Solids.
1609
1610 Let us consider two intersecting solids *S1* and *S2*:
1611
1612 @figure{/user_guides/boolean_operations/images/boolean_image054.png}
1613
1614 * 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*. 
1615         
1616 @figure{/user_guides/boolean_operations/images/boolean_image055.png}    
1617         
1618 * 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*. 
1619
1620 @figure{/user_guides/boolean_operations/images/boolean_image056.png}    
1621
1622 * The result of *Cut12* operation is a compound containing split part of the argument *S1*, i.e. 1 new solid *S11*.
1623         
1624 @figure{/user_guides/boolean_operations/images/boolean_image057.png}    
1625         
1626 * The result of *Cut21* operation is a compound containing split part of the argument *S2*, i.e. 1 new solid *S21*.
1627
1628 @figure{/user_guides/boolean_operations/images/boolean_image058.png}
1629
1630 @subsubsection occt_algorithms_9_4_20   Case 20: Two Solids that have overlapping faces.
1631
1632 Let us consider two solids *S1* and *S2* that have a common part on face:
1633
1634 @figure{/user_guides/boolean_operations/images/boolean_image059.png}
1635
1636 * 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*. 
1637         
1638 @figure{/user_guides/boolean_operations/images/boolean_image060.png}    
1639         
1640 * 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). 
1641
1642 * The result of *Cut12* operation is a compound containing split part of the argument *S1*, i.e. 1 new solid *S11*.
1643         
1644 @figure{/user_guides/boolean_operations/images/boolean_image061.png}    
1645         
1646 * The result of *Cut21* operation is a compound containing split part of the argument *S2*, i.e. 1 new solid *S21*.
1647 @figure{/user_guides/boolean_operations/images/boolean_image062.png}
1648
1649
1650 @subsubsection occt_algorithms_9_4_21   Case 21: Two Solids that have overlapping edges.
1651
1652 Let us consider two solids *S1* and *S2* that have overlapping edges:
1653
1654 @figure{/user_guides/boolean_operations/images/boolean_image063.png}
1655
1656 * 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*.
1657         
1658 @figure{/user_guides/boolean_operations/images/boolean_image064.png}    
1659         
1660 * 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). 
1661
1662 * The result of *Cut12* operation is a compound containing split part of the argument *S1*. In this case 
1663 argument *S1* has a common part with solid *S2* so the corresponding part is not included into the result.
1664         
1665 @figure{/user_guides/boolean_operations/images/boolean_image065.png}    
1666         
1667 * The result of *Cut21* operation is a compound containing split part of the argument *S2*. In this case 
1668 argument *S2* has a common part with solid *S1* so the corresponding part is not included into the result.
1669 @figure{/user_guides/boolean_operations/images/boolean_image066.png}
1670
1671 @subsubsection occt_algorithms_9_4_22   Case 22: Two Solids that have overlapping vertices.
1672
1673 Let us consider two solids *S1* and *S2* that have overlapping vertices:
1674
1675 @figure{/user_guides/boolean_operations/images/boolean_image067.png}
1676
1677 * 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*.
1678         
1679 @figure{/user_guides/boolean_operations/images/boolean_image068.png}    
1680         
1681 * 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). 
1682
1683 * The result of *Cut12* operation is a compound containing split part of the argument *S1*.
1684         
1685 @figure{/user_guides/boolean_operations/images/boolean_image069.png}    
1686         
1687 * The result of *Cut21* operation is a  compound containing split part of the argument *S2*. 
1688
1689 @figure{/user_guides/boolean_operations/images/boolean_image070.png}
1690
1691 @subsubsection occt_algorithms_9_4_23   Case 23: A Shell and a Wire cut by a Solid.
1692
1693 Let us consider Shell *Sh* and Wire *W* as the objects and Solid *S* as the tool:
1694
1695 @figure{/user_guides/boolean_operations/images/boolean_image136.png}
1696
1697 * The result of *Fuse* operation is not defined as the dimension of the arguments is not the same.
1698         
1699 * 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.
1700
1701 @figure{/user_guides/boolean_operations/images/boolean_image137.png}    
1702
1703 * 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.
1704         
1705 @figure{/user_guides/boolean_operations/images/boolean_image138.png}    
1706         
1707 * The result of *Cut21* operation is not defined as the objects have a lower dimension than the tool. 
1708
1709 @subsubsection occt_algorithms_9_4_24   Case 24: Two Wires that have overlapping edges.
1710
1711 Let us consider two Wires that have overlapping edges, *W1* is the object and *W2* is the tool:
1712
1713 @figure{/user_guides/boolean_operations/images/boolean_image139.png}
1714
1715 * The result of *Fuse* operation is a compound containing two Wires, which share an overlapping edge. The new Wires are created from the objects:
1716
1717 @figure{/user_guides/boolean_operations/images/boolean_image140.png}
1718         
1719 * The result of *Common* operation is a compound containing one Wire consisting of an overlapping edge. The new Wire is created from the objects:
1720
1721 @figure{/user_guides/boolean_operations/images/boolean_image141.png}    
1722
1723 * 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.
1724         
1725 @figure{/user_guides/boolean_operations/images/boolean_image142.png}    
1726         
1727 * 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.
1728         
1729 @figure{/user_guides/boolean_operations/images/boolean_image143.png}    
1730
1731
1732 @subsection occt_algorithms_9_5 Class BOPAlgo_BOP
1733
1734 BOA is implemented in the class *BOPAlgo_BOP*. The main fields of this class are described in the Table:
1735
1736 | Name | Contents |
1737 | :---- | :--- |        
1738 | *myOperation* | The type of the Boolean operation (Common, Fuse, Cut) |
1739 | *myTools* |   The tools |
1740 | *myDims[2]* | The values of the dimensions of the arguments |
1741 | *myRC* | The draft result (shape) |
1742
1743 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.
1744
1745 @subsection occt_algorithms_9_6 Building Draft Result
1746
1747 The input data for this step is as follows:
1748 * *BOPAlgo_BOP* object after building result of type *Compound*;
1749 * *Type* of the Boolean operation.
1750
1751 | No | Contents | Implementation |
1752 | :---- | :----- | :----- | 
1753 | 1 |   For the Boolean operation *Fuse* add to *myRC* all images of arguments. | *BOPAlgo_BOP::BuildRC()* |
1754 | 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()* |
1755  
1756 @subsection occt_algorithms_9_7 Building the Result
1757
1758 The input data for this step is as follows:
1759 * *BOPAlgo_BOP* object the state after building draft result. 
1760
1761 | No | Contents | Implementation |
1762 | :---- | :---- | :------ |
1763 | 1 | For the Type of the Boolean operation Common, Cut with any dimension and operation Fuse with *myDim[0] < 3* | |
1764 | 1.1 | Find containers (WIRE, SHELL, COMPSOLID) in the arguments | *BOPAlgo_BOP:: BuildShape()* |
1765 | 1.2 | Make connexity blocks from splits of each container that are in *myRC* |        *BOPTools_Tools::MakeConnexityBlocks()* |
1766 | 1.3 | Build the result from shapes made from the connexity blocks | *BOPAlgo_BOP:: BuildShape()* |
1767 | 1.4 | Add the remaining shapes from *myRC* to the result | *BOPAlgo_BOP:: BuildShape()* |
1768 | 2     | For the Type of the Boolean operation Fuse with *myDim[0] = 3* | |    
1769 | 2.1 | Find internal faces <i>(FWi)</i> in *myRC* | *BOPAlgo_BOP::BuildSolid()* |
1770 | 2.2 | Collect all faces of *myRC* except for internal faces <i>(FWi) -> SFS</i> | *BOPAlgo_BOP::BuildSolid ()* |
1771 | 2.3 | Build solids <i>(SDi)</i> from *SFS*. | *BOPAlgo_BuilderSolid* |
1772 | 2.4 | Add the solids <i>(SDi)</i> to the result       | |
1773
1774 @section occt_algorithms_10a Section Algorithm 
1775
1776 @subsection occt_algorithms_10a_1 Arguments
1777
1778 The arguments of BOA are shapes in terms of *TopoDS_Shape*. The main requirements for the arguments are described in the Algorithms.
1779
1780 @subsection occt_algorithms_10a_2 Results and general rules
1781 * 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. 
1782 * The result of Section operation contains shapes that have dimension that is  less then 2 i.e. vertices and edges. 
1783 * The result of Section operation contains standalone vertices if these vertices do not belong to the edges of the result.
1784 * 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).
1785 * The result of Section operation contains Section vertices and edges obtained from Face/Face interferences.
1786 * The result of Section operation contains vertices that are the result of interferences between vertices and faces.
1787 * The result of Section operation contains edges that are the result of interferences between edges and faces (Common Blocks),
1788
1789 @subsection occt_algorithms_10a_3  Examples
1790
1791 @subsubsection occt_algorithms_10a_3_1 Case 1: Two Vertices
1792
1793 Let us consider two interfering vertices: *V1* and *V2*.
1794
1795 @figure{/user_guides/boolean_operations/images/boolean_image080.png}
1796
1797 The result of *Section* operation is the compound that contains a new vertex *V*.
1798
1799 @figure{/user_guides/boolean_operations/images/boolean_image081.png}
1800
1801 @subsubsection occt_algorithms_10a_3_2 Case 1: Case 2: A Vertex and an Edge
1802
1803 Let us consider vertex *V1* and the edge *E2*, that intersect in a 3D point:
1804
1805 @figure{/user_guides/boolean_operations/images/boolean_image082.png}
1806
1807 The result of *Section* operation is the compound that contains vertex *V1*.
1808
1809 @figure{/user_guides/boolean_operations/images/boolean_image083.png}
1810
1811 @subsubsection occt_algorithms_10a_3_3 Case 1: Case 2: A Vertex and a Face
1812  
1813 Let us consider vertex *V1* and face *F2*, that intersect in a 3D point:
1814
1815 @figure{/user_guides/boolean_operations/images/boolean_image084.png}
1816
1817 The result of *Section* operation is the compound that contains vertex *V1*.
1818
1819 @figure{/user_guides/boolean_operations/images/boolean_image085.png}
1820
1821 @subsubsection occt_algorithms_10a_3_4 Case 4: A Vertex and a Solid
1822
1823 Let us consider vertex *V1* and solid *Z2*. The vertex *V1* is inside the solid *Z2*.
1824
1825 @figure{/user_guides/boolean_operations/images/boolean_image086.png}
1826  
1827 The result of *Section* operation is an empty compound.
1828
1829 @subsubsection occt_algorithms_10a_3_5 Case 5: Two edges intersecting at one point
1830
1831 Let us consider edges *E1* and *E2*, that intersect in a 3D point:
1832
1833 @figure{/user_guides/boolean_operations/images/boolean_image087.png}
1834
1835 The result of *Section* operation is the compound that contains a new vertex *Vnew*.
1836
1837 @figure{/user_guides/boolean_operations/images/boolean_image088.png}
1838
1839 @subsubsection occt_algorithms_10a_3_6 Case 6: Two edges having a common block
1840
1841 Let us consider edges *E1* and *E2*, that have a common block:
1842
1843 @figure{/user_guides/boolean_operations/images/boolean_image089.png}
1844  
1845 The result of *Section* operation is the compound that contains a new edge *Enew*.
1846
1847 @figure{/user_guides/boolean_operations/images/boolean_image090.png} 
1848
1849 @subsubsection occt_algorithms_10a_3_7 Case 7: An Edge and a Face intersecting at a point
1850
1851 Let us consider edge *E1* and face *F2*, that intersect at a 3D point:
1852  
1853 @figure{/user_guides/boolean_operations/images/boolean_image091.png}
1854
1855 The result of *Section* operation is the compound that contains a new vertex *Vnew*.
1856
1857 @figure{/user_guides/boolean_operations/images/boolean_image092.png}
1858  
1859 @subsubsection occt_algorithms_10a_3_8 Case 8: A Face and an Edge that have a common block
1860
1861 Let us consider edge *E1* and face *F2*, that have a common block:
1862
1863 @figure{/user_guides/boolean_operations/images/boolean_image093.png}
1864
1865 The result of *Section* operation is the compound that contains new edge *Enew*. 
1866
1867 @figure{/user_guides/boolean_operations/images/boolean_image094.png}
1868  
1869  
1870 @subsubsection occt_algorithms_10a_3_9 Case 9: An Edge and a Solid intersecting at a point
1871
1872 Let us consider edge *E1* and solid *Z2*, that intersect at a point:
1873
1874 @figure{/user_guides/boolean_operations/images/boolean_image095.png} 
1875
1876 The result of *Section* operation is the compound that contains a new vertex *Vnew*. 
1877
1878 @figure{/user_guides/boolean_operations/images/boolean_image096.png}
1879
1880 @subsubsection occt_algorithms_10a_3_10 Case 10: An Edge and a Solid that have a common block
1881
1882 Let us consider edge *E1* and solid *Z2*, that have a common block at a face:
1883
1884 @figure{/user_guides/boolean_operations/images/boolean_image097.png}
1885  
1886 The result of *Section* operation is the compound that contains a new edge *Enew*. 
1887
1888 @figure{/user_guides/boolean_operations/images/boolean_image098.png}
1889  
1890 @subsubsection occt_algorithms_10a_3_11 Case 11: Two intersecting faces
1891
1892 Let us consider two intersecting faces *F1* and *F2*:
1893  
1894 @figure{/user_guides/boolean_operations/images/boolean_image099.png}
1895
1896 The result of *Section* operation is the compound that contains a new edge *Enew*. 
1897
1898 @figure{/user_guides/boolean_operations/images/boolean_image100.png}
1899  
1900 @subsubsection occt_algorithms_10a_3_12 Case 12: Two faces that have a common part
1901
1902 Let us consider two faces *F1* and *F2* that have a common part:
1903
1904 @figure{/user_guides/boolean_operations/images/boolean_image133.png}
1905  
1906 The result of *Section* operation is the compound that contains 4 new edges.
1907
1908 @figure{/user_guides/boolean_operations/images/boolean_image134.png}
1909
1910 @subsubsection occt_algorithms_10a_3_13 Case 13: Two faces that have overlapping edges
1911
1912 Let us consider two faces *F1* and *F2* that have a overlapping edges:
1913
1914 @figure{/user_guides/boolean_operations/images/boolean_image101.png}
1915
1916 The result of *Section* operation is the compound that contains a new edge *Enew*.
1917
1918 @figure{/user_guides/boolean_operations/images/boolean_image102.png}
1919  
1920 @subsubsection occt_algorithms_10a_3_14 Case 14: Two faces that have overlapping vertices
1921
1922 Let us consider two faces *F1* and *F2* that have overlapping vertices:
1923
1924 @figure{/user_guides/boolean_operations/images/boolean_image103.png}
1925  
1926 The result of *Section* operation is the compound that contains a new vertex *Vnew*. 
1927  
1928 @figure{/user_guides/boolean_operations/images/boolean_image104.png}
1929  
1930 @subsubsection occt_algorithms_10a_3_15 Case 15: A Face and a Solid that have an intersection curve
1931
1932 Let us consider face *F1* and solid *Z2* that have an intersection curve:
1933  
1934 @figure{/user_guides/boolean_operations/images/boolean_image105.png}
1935  
1936 The result of *Section* operation is the compound that contains new edges.
1937
1938 @figure{/user_guides/boolean_operations/images/boolean_image106.png}
1939  
1940 @subsubsection occt_algorithms_10a_3_16 Case 16: A Face and a Solid that have overlapping faces.
1941
1942 Let us consider face *F1* and solid *Z2* that have overlapping faces:
1943
1944 @figure{/user_guides/boolean_operations/images/boolean_image107.png}
1945  
1946 The result of *Section* operation is the compound that contains new edges
1947  
1948 @figure{/user_guides/boolean_operations/images/boolean_image108.png}
1949  
1950 @subsubsection occt_algorithms_10a_3_17 Case 17: A Face and a Solid that have overlapping edges.
1951
1952 Let us consider face *F1* and solid *Z2* that have a common part on edge:
1953
1954 @figure{/user_guides/boolean_operations/images/boolean_image109.png} 
1955
1956 The result of *Section* operation is the compound that contains a new edge *Enew*.
1957
1958 @figure{/user_guides/boolean_operations/images/boolean_image110.png}
1959  
1960 @subsubsection occt_algorithms_10a_3_18 Case 18: A Face and a Solid that have overlapping vertices.
1961
1962 Let us consider face *F1* and solid *Z2* that have overlapping vertices:
1963
1964 @figure{/user_guides/boolean_operations/images/boolean_image111.png}
1965   
1966 The result of *Section* operation is the compound that contains a new vertex *Vnew*.
1967  
1968 @figure{/user_guides/boolean_operations/images/boolean_image112.png}
1969
1970 @subsubsection occt_algorithms_10a_3_19 Case 19: Two intersecting Solids
1971
1972 Let us consider two intersecting solids *Z1* and *Z2*:
1973 @figure{/user_guides/boolean_operations/images/boolean_image113.png} 
1974
1975 The result of *Section* operation is the compound that contains new edges.
1976 @figure{/user_guides/boolean_operations/images/boolean_image114.png} 
1977
1978 @subsubsection occt_algorithms_10a_3_20 Case 20: Two Solids that have overlapping faces
1979
1980 Let us consider two solids *Z1* and *Z2* that have a common part on face:
1981 @figure{/user_guides/boolean_operations/images/boolean_image115.png} 
1982
1983 The result of *Section* operation is the compound that contains new edges.
1984 @figure{/user_guides/boolean_operations/images/boolean_image116.png} 
1985  
1986 @subsubsection occt_algorithms_10a_3_21 Case 21: Two Solids that have overlapping edges
1987
1988 Let us consider two solids *Z1* and *Z2* that have overlapping edges:
1989 @figure{/user_guides/boolean_operations/images/boolean_image117.png}
1990  
1991 The result of *Section* operation is the compound that contains a new edge *Enew*.
1992 @figure{/user_guides/boolean_operations/images/boolean_image118.png} 
1993
1994 @subsubsection occt_algorithms_10a_3_22 Case 22: Two Solids that have overlapping vertices
1995
1996 Let us consider two solids *Z1* and *Z2* that have overlapping vertices: 
1997 @figure{/user_guides/boolean_operations/images/boolean_image119.png} 
1998
1999 The result of *Section* operation is the compound that contains a new vertex *Vnew*.
2000 @figure{/user_guides/boolean_operations/images/boolean_image120.png} 
2001
2002 @subsection occt_algorithms_10a_4 Class BOPAlgo_Section
2003
2004 SA is implemented in the class *BOPAlgo_Section*. The class has no specific fields.
2005 The main steps of the *BOPAlgo_Section*  are the same as of *BOPAlgo_Builder* except for the following steps:
2006
2007 * Build Images for Wires;
2008 * Build Result of Type Wire;
2009 * Build Images for Faces;
2010 * Build Result of Type Face;
2011 * Build Images for Shells;
2012 * Build Result of Type Shell;
2013 * Build Images for Solids;
2014 * Build Result of Type Solid;
2015 * Build Images for Type CompSolid;
2016 * Build Result of Type CompSolid;
2017 * Build Images for Compounds;
2018 Some aspects of building the result are described in the next paragraph
2019
2020 @subsection occt_algorithms_10a_5 Building the Result
2021
2022 | No | Contents | Implementation |
2023 | :---- | :---- | :------ |
2024 | 1 | Build the result of the operation using all information contained in *FaceInfo*, Common Block, Shared entities of the arguments, etc. | *BOPAlgo_Section:: BuildSection()* |
2025
2026 @section occt_algorithms_10b Volume Maker Algorithm
2027
2028 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.
2029 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.
2030 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>
2031 Non-closed faces, free wires etc. located outside of any solid are always excluded from the result.
2032
2033 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 such as possibility to run algorithm in parallel mode, fuzzy option, safe mode, glue options and history support are also available in this algorithm.
2034
2035 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.
2036
2037 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.
2038 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.
2039
2040 @subsection occt_algorithms_10b_1 Usage
2041
2042 #### C++ Level
2043 The usage of the algorithm on the API level:
2044 ~~~~
2045 BOPAlgo_MakerVolume aMV;
2046 BOPCol_ListOfShape aLS = …; // arguments
2047 Standard_Boolean bRunParallel = Standard_False; /* parallel or single mode (the default value is FALSE)*/
2048 Standard_Boolean bIntersect = Standard_True; /* intersect or not the arguments (the default value is TRUE)*/
2049 Standard_Real aTol = 0.0; /* fuzzy option (default value is 0)*/
2050 Standard_Boolean bSafeMode = Standard_False; /* protect or not the arguments from modification*/
2051 BOPAlgo_Glue aGlue = BOPAlgo_GlueOff; /* Glue option to speed up intersection of the arguments*/
2052 Standard_Boolean bAvoidInternalShapes = Standard_False; /* Avoid or not the internal for solids shapes in the result*/
2053 //
2054 aMV.SetArguments(aLS);
2055 aMV.SetRunParallel(bRunParallel);
2056 aMV.SetIntersect(bIntersect);
2057 aMV.SetFuzzyValue(aTol);
2058 aMV.SetNonDestructive(bSafeMode);
2059 aMV.SetGlue(aGlue);
2060 aMV.SetAvoidInternalShapes(bAvoidInternalShapes);
2061 //
2062 aMV.Perform(); //perform the operation
2063 if (aMV.ErrorStatus()) { //check error status
2064   return;
2065 }
2066 //
2067 const TopoDS_Shape& aResult = aMV.Shape(); // result of the operation
2068 ~~~~
2069
2070 #### Tcl Level
2071 To use the algorithm in Draw the command mkvolume has been implemented. The usage of this command is following:
2072 ~~~~
2073 Usage: mkvolume r b1 b2 ... [-c] [-ni] [-ai]
2074 Options:
2075 -c - use this option to have input compounds considered as set of separate arguments (allows passing multiple arguments as one compound);
2076 -ni - use this option to disable the intersection of the arguments;
2077 -ai - use this option to avoid internal for solids shapes in the result.
2078 ~~~~
2079
2080 @subsection occt_algorithms_10b_2 Examples
2081
2082 #### Example 1
2083 Creation of 9832 solids from sphere and set of 63 planes:
2084
2085 <table align="center">
2086 <tr>
2087   <td>@figure{/user_guides/boolean_operations/images/mkvolume_image001.png, "Arguments"}</td>
2088   <td>@figure{/user_guides/boolean_operations/images/mkvolume_image002.png, "Results"}</td>
2089 </tr>
2090 </table>
2091
2092 #### Example 2
2093 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:
2094
2095 <table align="center">
2096 <tr>
2097   <td>@figure{/user_guides/boolean_operations/images/mkvolume_image003.png, "Arguments"}</td>
2098   <td>@figure{/user_guides/boolean_operations/images/mkvolume_image004.png, "Results"}</td>
2099 </tr>
2100 </table>
2101
2102 @section occt_algorithms_10     Algorithm Limitations 
2103
2104 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.
2105
2106 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.
2107 * 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.
2108 * 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. 
2109 * 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.
2110
2111 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.
2112
2113
2114 @subsection occt_algorithms_10_1        Arguments
2115
2116 @subsubsection occt_algorithms_10_1_1   Common requirements 
2117
2118 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.
2119
2120 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.
2121
2122 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.
2123
2124 Let us consider the following example:
2125
2126 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). 
2127
2128 Let us consider the case when edge *E* is recognized valid (in terms of *BRepCheck_Analyzer*).
2129
2130 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*. 
2131
2132 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*. 
2133
2134 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*.
2135
2136 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.
2137
2138 @subsubsection occt_algorithms_10_1_3   Pure self-interference
2139
2140 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.
2141
2142 #### Example 1: Compound of two edges
2143 The compound of two edges *E1* and *E2* is a self-interfered shape and cannot be used as the argument of the Algorithms.
2144
2145 @figure{/user_guides/boolean_operations/images/operations_image036.svg, "Compound of two edges"}
2146
2147 #### Example 2: Self-interfered Edge
2148 The edge *E* is a self-interfered shape and cannot be used as an argument of the Algorithms.
2149
2150 @figure{/user_guides/boolean_operations/images/operations_image037.svg, "Self-interfered Edge"}
2151  
2152 #### Example 3: Self-interfered Face
2153 The face *F* is a self-interfered shape and cannot be used as an argument of the Algorithms.
2154
2155 @figure{/user_guides/boolean_operations/images/operations_image038.svg, "Self-interfered Face"}
2156  
2157 ####    Example 4: Face of Revolution
2158 The face *F* has been obtained by revolution of edge *E* around line *L*.
2159
2160 @figure{/user_guides/boolean_operations/images/operations_image039a.png, "Face of Revolution: Arguments"} 
2161 @figure{/user_guides/boolean_operations/images/operations_image039b.png, "Face of Revolution: Result"} 
2162
2163 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.
2164
2165 @subsubsection occt_algorithms_10_1_4   Self-interferences due to tolerances
2166 #### Example 1: Non-closed Edge
2167
2168 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"}
2169
2170 The distance between the vertices of *E* is *D=0.69799*. The values of the tolerances *Tol(V1)=Tol(V2)=0.5*.
2171 @figure{/user_guides/boolean_operations/images/operations_image041.png,  "Distance and Tolerances"}
2172  
2173 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.
2174
2175 #### Example 2: Solid containing an interfered vertex
2176
2177 Let us consider solid *S* containing vertex V. @figure{/user_guides/boolean_operations/images/operations_image042.png,  "Solid containing an interfered vertex"}
2178
2179 The value of  tolerance Tol(V)= 50.000075982061.
2180
2181 @figure{/user_guides/boolean_operations/images/operations_image043.png,  "Tolerance"}
2182
2183 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.
2184
2185 @subsubsection occt_algorithms_10_1_5 Parametric representation
2186 The parameterization of some surfaces (cylinder, cone, surface of revolution) can be the cause of limitation.
2187
2188 ####    Example 1: Cylindrical surface
2189 The parameterization range for cylindrical surface is:
2190
2191 @figure{/user_guides/boolean_operations/images/boolean_image135.png}
2192
2193 The range of *U* coordinate is always restricted while the range of *V* coordinate is non-restricted.
2194
2195 Let us consider a cylinder-based *Face 1* with radii *R=3* and *H=6*. 
2196
2197 @figure{/user_guides/boolean_operations/images/operations_image044.png, "Face 1"}
2198
2199 @figure{/user_guides/boolean_operations/images/operations_image045.png, "P-Curves for Face 1"}
2200
2201 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*). 
2202
2203 @figure{/user_guides/boolean_operations/images/operations_image046.png, "Face 2"}
2204
2205 @figure{/user_guides/boolean_operations/images/operations_image047.png, "P-Curves for Face 2"}
2206
2207 Please, pay attention to the Zoom value of the Figures.
2208
2209 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.
2210
2211
2212 @subsubsection occt_algorithms_10_1_6 Using tolerances of vertices to fix gaps
2213
2214 It is possible to create shapes that use sub-shapes of lower order to avoid gaps in the tolerance-based data model.
2215
2216 Let us consider the following example:
2217
2218 @figure{/user_guides/boolean_operations/images/operations_image048.png, "Example"}
2219
2220 * Face *F* has two edges *E1* and *E2* and two vertices, the base plane is <i>{0,0,0, 0,0,1}</i>;
2221 * Edge *E1* is based on line <i>{0,0,0, 1,0,0}, Tol(E1) = 1.e-7; </i>
2222 * Edge *E2* is based on line <i>{0,1,0, 1,0,0}, Tol(E2) = 1.e-7;</i>
2223 * Vertex *V1*, point <i>{0,0.5,0}, Tol(V1) = 1;</i>
2224 * Vertex *V2*, point <i>{10,0.5,0}, Tol(V2) = 1;</i>
2225 * Face *F* is valid (in terms of *BRepCheck_Analyzer*).
2226  
2227 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. 
2228
2229
2230 @subsection occt_algorithms_11_1        Intersection problems
2231 @subsubsection occt_algorithms_11_1_1 Pure intersections and common zones 
2232
2233 #### Example: Intersecting Edges
2234
2235 Let us consider the intersection between two edges:
2236 * *E1* is based on a line: <i>{0,-10,0, 1,0,0}, Tol(E1)=2.</i>
2237 * *E2* is based on a circle: <i>{0,0,0, 0,0,1}, R=10, Tol(E2)=2.</i>
2238
2239 @figure{/user_guides/boolean_operations/images/operations_image049.png, "Intersecting Edges"} 
2240
2241 The result of pure intersection between *E1* and *E2* is vertex *Vx {0,-10,0}*.
2242
2243 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. 
2244
2245 The Intersection Part of Algorithms uses the result of pure intersection *Vx* instead of *CZ* for the following reasons: 
2246 * 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.
2247 * 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.
2248
2249 @subsubsection occt_algorithms_11_2_2 Tolerances and inaccuracies
2250
2251 The following limitations result from modeling errors or inaccuracies.
2252
2253 #### Example: Intersection of planar faces
2254
2255 Let us consider two planar rectangular faces *F1* and *F2*.
2256
2257 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.
2258
2259 @figure{/user_guides/boolean_operations/images/operations_image050.svg, "Intersecting Faces"} 
2260
2261
2262 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.
2263
2264 In a particular case the problem can be solved in several ways:
2265 * Reduce, if possible, the values of *Tol(V1)* and *Tol(V2)* (refinement of *F1*).
2266 * 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*.
2267
2268 It is easy to see that if *C12* is slightly above the tolerance spheres of *V1* and *V2* the problem does not appear. 
2269
2270 #### Example: Intersection of two edges
2271
2272 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>.*
2273
2274 *C1* practically coincides in 3D with *C2*. The value of deflection is *Dmax* (e.g. *Dmax=1.e<sup>-6</sup>*). 
2275
2276 @figure{/user_guides/boolean_operations/images/operations_image051.svg, "Intersecting Edges"} 
2277
2278 The evident and prospective result should be the Common Block between *E1* and *E2*. However, the result of intersection differs. 
2279
2280 @figure{/user_guides/boolean_operations/images/operations_image052.svg, "Result of Intersection"} 
2281
2282 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>.
2283
2284 In this particular case the problem can be solved by several ways:
2285 * Increase, if possible, the values *Tol(E1)* and *Tol(E2)* to get coincidence in 3D between *E1* and *E2* in terms of tolerance.
2286 * Replace *E1* by a more accurate model.
2287
2288 The example can be extended from 1D (edges) to 2D (faces).
2289
2290 @figure{/user_guides/boolean_operations/images/operations_image053.svg, "Intersecting Faces"} 
2291
2292 The comments and recommendations are the same as for 1D case above.
2293
2294
2295 @subsubsection occt_algorithms_11_2_3 Acquired Self-interferences
2296 ####    Example 1: Vertex and edge
2297
2298 Let us consider vertex *V1* and edge *E2*. 
2299
2300 @figure{/user_guides/boolean_operations/images/operations_image054.svg, "Vertex and Edge"} 
2301
2302 Vertex *V1* interferes with vertices *V12* and *V22*.
2303 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*.
2304
2305 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*).
2306
2307 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)*.
2308
2309 #### Example 2: Vertex and wire
2310   
2311 Let us consider vertex *V2* and wire consisting of edges *E11* and *E12*. 
2312
2313 @figure{/user_guides/boolean_operations/images/operations_image055.svg, "Vertex and Wire"} 
2314
2315 The arguments themselves are not self-intersected.
2316 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.
2317  
2318 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.
2319
2320 @section occt_algorithms_11a Advanced Options
2321
2322 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. 
2323
2324 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.
2325
2326 @subsection occt_algorithms_11a_1  Fuzzy Boolean Operation
2327
2328 Fuzzy Boolean operation is the option of Basic Operations (GFA, BOA, PA and SA), in which additional user-specified tolerance is used. This option allows operators to handle robustly cases of touching and near-coincident, misalignment entities of the arguments.
2329
2330 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. 
2331
2332 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.
2333
2334 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.
2335
2336 Fuzzy option is included in interface of Intersection Part (class *BOPAlgo_PaveFiller*) and application programming interface (class  *BRepAlgoAPI_BooleanOperation*)
2337
2338 @subsubsection occt_algorithms_11a_1_1 Examples
2339 The following examples demonstrate the advantages of usage Fuzzy option operations over the Basic Operations in typical situations.
2340
2341 #### Case 1
2342
2343 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>).
2344
2345 @figure{/user_guides/boolean_operations/images/boolean_image121.png} 
2346   
2347 The following results are obtained using Basic Operations and the Fuzzy ones with the fuzzy value 5e<sup>-5</sup>:
2348
2349 @figure{/user_guides/boolean_operations/images/boolean_image122.png, "Result of CUT operation obtained with Basic Operations"} 
2350
2351 @figure{/user_guides/boolean_operations/images/boolean_image123.png, "Result of CUT operation obtained with Fuzzy Option"} 
2352
2353 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. 
2354
2355 #### Case 2
2356
2357 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. 
2358
2359 @figure{/user_guides/boolean_operations/images/boolean_image124.png} 
2360
2361 The following results are obtained using Basic Operations and the Fuzzy ones with the fuzzy value 1e<sup>-6</sup>: 
2362
2363 @figure{/user_guides/boolean_operations/images/boolean_image125.png, "Result of CUT operation obtained with Basic Operations"} 
2364
2365 @figure{/user_guides/boolean_operations/images/boolean_image126.png, "Result of CUT operation obtained with Fuzzy Option"} 
2366
2367 In this example Fuzzy option allows eliminating an extremely narrow face in the result produced by Basic operation.
2368
2369 #### Case 3
2370
2371 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.
2372
2373 @figure{/user_guides/boolean_operations/images/boolean_image127.png} 
2374
2375 The following results are obtained using Basic Operations and the Fuzzy ones with the fuzzy value 1e<sup>-5</sup>: 
2376
2377 @figure{/user_guides/boolean_operations/images/boolean_image128.png, "Result of CUT operation obtained with Basic Operations"} 
2378
2379 @figure{/user_guides/boolean_operations/images/boolean_image129.png, "Result of CUT operation obtained with Fuzzy Option"} 
2380
2381 In this example Fuzzy options eliminated a pin-like protrusion resulting from the gap between edges of the argument faces.
2382
2383 #### Case 4
2384
2385 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.
2386
2387 @figure{/user_guides/boolean_operations/images/boolean_image130.png} 
2388
2389 The following results are obtained using Basic Operations and the Fuzzy ones with the fuzzy value 6e<sup>-5</sup>: 
2390
2391 @figure{/user_guides/boolean_operations/images/boolean_image131.png, "Result of CUT operation obtained with Basic Operations"} 
2392
2393 @figure{/user_guides/boolean_operations/images/boolean_image132.png, "Result of CUT operation obtained with Fuzzy Option"} 
2394
2395 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).
2396
2397 @subsection occt_algorithms_11a_2 Gluing Operation
2398
2399 The Gluing operation is the option of the Basic Operations, such as General Fuse, Partition, Boolean, Section, Maker Volume operations.
2400 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.
2401
2402 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:
2403 @figure{/user_guides/boolean_operations/images/glue_options_image002.png, "Intersecting faces"}
2404
2405 There are two possibilities of overlapping shapes:
2406 * 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:
2407 @figure{/user_guides/boolean_operations/images/glue_options_image001.png, "Partially coinciding faces"}
2408 * 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
2409 @figure{/user_guides/boolean_operations/images/glue_options_image003.png, "Full coinciding faces of the boxes"}
2410
2411 Thus, there are two possible options - for full and partial coincidence of the shapes.
2412
2413 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.
2414
2415 The performance improvement in gluing mode is achieved by excluding the most time consuming computations and in some case can go up to 90%:
2416 * Exclude computation of FACE/FACE intersections for partial coincidence;
2417 * Exclude computation of VERTEX/FACE, EDGE/FACE and FACE/FACE intersections for full coincidence.
2418
2419 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.
2420
2421 @subsubsection occt_algorithms_11a_2_1 Usage
2422
2423 The Gluing option is an enumeration implemented in BOPAlgo_GlueEnum.hxx:
2424 * BOPAlgo_GlueOff - default value for the algorithms, Gluing is switched off;
2425 * BOPAlgo_GlueShift - Glue option for shapes with partial coincidence;
2426 * BOPAlgo_GlueFull - Glue option for shapes with full coincidence.
2427
2428 #### API level
2429 For setting the Gluing options for the algorithm it is just necessary to call the SetGlue(const BOPAlgo_Glue) method with appropriate value:
2430 ~~~~
2431 BOPAlgo_Builder aGF;
2432 //
2433 ....
2434 // setting the gluing option to speed up intersection of the arguments
2435 aGF.SetGlue(BOPAlgo_GlueShift)
2436 //
2437 ....
2438 ~~~~
2439
2440 #### TCL level
2441 For setting the Gluing options in DRAW it is necessary to call the <i>bglue</i> command with appropriate value:
2442 * 0 - default value, Gluing is off;
2443 * 1 - for partial coincidence;
2444 * 2 - for full coincidence
2445
2446 ~~~~
2447 bglue 1
2448 ~~~~
2449
2450 @subsubsection occt_algorithms_11a_2_2 Examples
2451 #### Case1 - Fusing the 64 bspline boxes into one solid
2452 @figure{/user_guides/boolean_operations/images/glue_options_image004.png, "BSpline Boxes with partial coincidence"}
2453
2454 Performance improvement from using the GlueShift option in this case is about 70 percent.
2455
2456 #### Case2 - Sewing faces of the shape after reading from IGES
2457 @figure{/user_guides/boolean_operations/images/glue_options_image005.png, "Faces with coinciding but not shared edges"}
2458
2459 Performance improvement in this case is also about 70 percent.
2460
2461 @subsection occt_algorithms_11a_3 Safe processing mode
2462
2463 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, Partition, Boolean, Section, Maker Volume.
2464 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.
2465
2466 The option might be very useful for implementation of the Undo/Redo mechanism in the applications and allows performing the operation many times without changing the inputs.
2467
2468 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 entitiy it will be necessary to create the copy of this entitiy and modify it. But this degradation should be very small because the copying is performed only in case of necessity.
2469
2470 The option is also availible in the Intersection algorithm - *BOPAlgo_PaveFiller*. Thus, if it is necessary to perform several different operations on the same arguemnts, it is possible to enable the safe processing mode in PaveFiller and prepare it only once and then use it in operations. It is enough to set the option to PaveFiller only and all algorithms taking this PaveFiller will also work in safe mode.
2471
2472 @subsubsection occt_algorithms_11a_3_1 Usage
2473
2474 #### API level
2475
2476 To enable/disable the safe processing mode for the algorithm it is necessary to call the SetNonDestructive() method with appropriate value:
2477 ~~~~
2478 BOPAlgo_Builder aGF;
2479 //
2480 ....
2481 // enabling the safe processing mode to prevent modification of the input shapes
2482 aGF.SetNonDestructive(Standard_True);
2483 //
2484 ....
2485 ~~~~
2486
2487 #### TCL level
2488 For enabling the safe processing mode for the operaton in DRAW it is necessary to call the <i>bnondestructive</i> command with appropriate value:
2489 * 0 - default value, the safe mode is switched off;
2490 * 1 - the safe mode will be switched on.
2491
2492 ~~~~
2493 bnondestructive 1
2494 ~~~~
2495
2496
2497 @section occt_algorithms_11b Usage 
2498
2499 The chapter contains some examples of the OCCT Boolean Component usage. The usage is possible on two levels: C++ and Tcl. 
2500
2501 @subsection occt_algorithms_11b_1 Package BRepAlgoAPI
2502
2503 The package *BRepAlgoAPI* provides the Application Programming Interface of the Boolean Component.
2504
2505 The package consists of the following classes:
2506 * *BRepAlgoAPI_Algo* -- the root class that provides the interface for algorithms. 
2507 * *BRepAlgoAPI_BuilderAlgo* -- the class API level of General Fuse algorithm.
2508 * *BRepAlgoAPI_Splitter* -- the class API level of the Partition algorithm.
2509 * *BRepAlgoAPI_BooleanOperation* -- the root class for the classes *BRepAlgoAPI_Fuse*. *BRepAlgoAPI_Common*, *BRepAlgoAPI_Cut* and *BRepAlgoAPI_Section*.
2510 * *BRepAlgoAPI_Fuse* -- the class provides Boolean fusion operation. 
2511 * *BRepAlgoAPI_Common* -- the class provides Boolean common operation.
2512 * *BRepAlgoAPI_Cut* -- the class provides Boolean cut operation.
2513 * *BRepAlgoAPI_Section* -- the class provides Boolean section operation.
2514
2515 @figure{/user_guides/boolean_operations/images/operations_image065.png, "Diagram of BRepAlgoAPI package"} 
2516
2517 The detailed description of the classes can be found in the corresponding .hxx files. The examples are below in this chapter.
2518
2519 @subsection occt_algorithms_11b_2 Package BOPTest
2520 The package *BOPTest* provides the usage of the Boolean Component on Tcl level. The method *BOPTest::APICommands* contains corresponding Tcl commands: 
2521
2522 * *bapibuild* -- for General Fuse Operator;
2523 * *bapisplit* -- for Partition Operator;
2524 * *bapibop* -- for Boolean Operator and Section Operator.
2525
2526 The examples of how to use the commands are below in this chapter.
2527
2528 @subsubsection occt_algorithms_11b_2_1 Case 1. General Fuse operation
2529
2530 The following example illustrates how to use General Fuse operator:
2531
2532 #### C++ Level
2533
2534 ~~~~
2535 #include <TopoDS_Shape.hxx>
2536 #include <TopTools_ListOfShape.hxx>
2537 #include <BRepAlgoAPI_BuilderAlgo.hxx>
2538  {…
2539   Standard_Boolean bRunParallel;
2540   Standard_Integer iErr;
2541   Standard_Real aFuzzyValue;
2542   BRepAlgoAPI_BuilderAlgo aBuilder;
2543   //
2544   // prepare the arguments
2545   TopTools_ListOfShape& aLS=…;
2546   //
2547   bRunParallel=Standard_True;
2548   aFuzzyValue=2.1e-5;
2549   //
2550   // set the arguments  
2551   aBuilder.SetArguments(aLS);
2552   // set parallel processing mode 
2553   // if  bRunParallel= Standard_True :  the parallel processing is switched on
2554   // if  bRunParallel= Standard_False :  the parallel processing is switched off
2555   aBuilder.SetRunParallel(bRunParallel);
2556   //
2557   // set Fuzzy value
2558   // if aFuzzyValue=0.: the Fuzzy option is off
2559   //  if aFuzzyValue>0.: the Fuzzy option is on
2560   aBuilder.SetFuzzyValue(aFuzzyValue);
2561   //
2562   // safe mode - avoid modification of the arguments
2563   Standard_Boolean bSafeMode = Standard_True;
2564   // if bSafeMode == Standard_True  - the safe mode is switched on
2565   // if bSafeMode == Standard_False - the safe mode is switched off
2566   aBuilder.SetNonDestructive(bSafeMode);
2567   //
2568   // gluing options - for coinciding arguments
2569   BOPAlgo_GlueEnum aGlueOpt = BOPAlgo_GlueFull;
2570   // if aGlueOpt == BOPAlgo_GlueOff   - the gluing mode is switched off
2571   // if aGlueOpt == BOPAlgo_GlueShift - the gluing mode is switched on
2572   // if aGlueOpt == BOPAlgo_GlueFull  - the gluing mode is switched on
2573   aBuilder.SetGlue(aGlueOpt);
2574   //
2575   // run the algorithm 
2576   aBuilder.Build(); 
2577   iErr=aBuilder.ErrorStatus();
2578   if (iErr) {
2579     // an error treatment
2580     return;
2581   }
2582   //
2583   // result of the operation aR
2584   const TopoDS_Shape& aR=aBuilder.Shape();
2585
2586 }
2587 ~~~~
2588
2589 #### Tcl Level
2590
2591 ~~~~
2592 # prepare the arguments
2593 box b1 10 10 10 
2594 box b2 3 4 5 10 10 10 
2595 box b3 5 6 7 10 10 10 
2596 #
2597 # clear inner contents
2598 bclearobjects; bcleartools;
2599 #
2600 # set the arguments
2601 baddobjects b1 b2 b3
2602 # set parallel processing mode
2603 # 1:  the parallel processing is switched on
2604 # 0:  the parallel processing is switched off
2605 brunparallel 1 
2606 #
2607 # set Fuzzy value
2608 # 0.    : the Fuzzy option is off
2609 # >0. : the Fuzzy option is on
2610 bfuzzyvalue 0.
2611 #
2612 # set safe processing mode
2613 bnondestructive 1
2614 # set safe mode
2615 # 1 - the safe processing mode is switched on
2616 # 0 - the safe processing mode is switched off
2617 #
2618 # set gluing mode
2619 bglue 1
2620 # set the gluing mode
2621 # 1 or 2 - the gluing mode is switched on
2622 # 0 - the gluing mode is switched off
2623 #
2624 # run the algorithm
2625 # r is the result of the operation
2626 bapibuild r 
2627 ~~~~
2628
2629 @subsubsection occt_algorithms_11b_2_2 Case 2. Partition operation
2630
2631 The following example illustrates how to use the Partition operator:
2632
2633 #### C++ Level
2634
2635 ~~~~
2636 #include <TopoDS_Shape.hxx>
2637 #include <TopTools_ListOfShape.hxx>
2638 #include <BRepAlgoAPI_Splitter.hxx>
2639 //
2640 BRepAlgoAPI_BuilderAlgo aSplitter;
2641 //
2642 // prepare the arguments
2643 // objects
2644 TopTools_ListOfShape& aLSObjects = … ;
2645 // tools
2646 TopTools_ListOfShape& aLSTools = … ;
2647 //
2648 // set the arguments
2649 aSplitter.SetArguments(aLSObjects);
2650 aSplitter.SetTools(aLSTools);
2651 //
2652 // set options
2653 // parallel processing mode 
2654 Standard_Boolean bRunParallel = Standard_True;
2655 // bRunParallel == Standard_True  - the parallel processing is switched on
2656 // bRunParallel == Standard_False - the parallel processing is switched off
2657 aSplitter.SetRunParallel();
2658 //
2659 // fuzzy value - additional tolerance for the operation
2660 Standard_Real aFuzzyValue = 1.e-5;
2661 // if aFuzzyValue == 0. - the Fuzzy option is off
2662 // if aFuzzyValue > 0.  - the Fuzzy option is on
2663 aSplitter.SetFuzzyValue(aFuzzyValue);
2664 //
2665 // safe mode - avoid modification of the arguments
2666 Standard_Boolean bSafeMode = Standard_True;
2667 // if bSafeMode == Standard_True  - the safe mode is switched on
2668 // if bSafeMode == Standard_False - the safe mode is switched off
2669 aSplitter.SetNonDestructive(bSafeMode);
2670 //
2671 // gluing options - for coinciding arguments
2672 BOPAlgo_GlueEnum aGlueOpt = BOPAlgo_GlueFull;
2673 // if aGlueOpt == BOPAlgo_GlueOff   - the gluing mode is switched off
2674 // if aGlueOpt == BOPAlgo_GlueShift - the gluing mode is switched on
2675 // if aGlueOpt == BOPAlgo_GlueFull  - the gluing mode is switched on
2676 aSplitter.SetGlue(aGlueOpt);
2677 //
2678 // run the algorithm 
2679 aSplitter.Build(); 
2680 // check error status
2681 if (aSplitter.ErrorStatus()) {
2682   return;
2683 }
2684 //
2685 // result of the operation aResult
2686 const TopoDS_Shape& aResult = aSplitter.Shape();
2687 ~~~~
2688
2689 #### Tcl Level
2690
2691 ~~~~
2692 # prepare the arguments
2693 # objects
2694 box b1 10 10 10 
2695 box b2 7 0 0 10 10 10
2696
2697 # tools
2698 plane p 10 5 5 0 1 0
2699 mkface f p -20 20 -20 20
2700 #
2701 # clear inner contents
2702 bclearobjects; bcleartools;
2703 #
2704 # set the objects
2705 baddobjects b1 b2
2706 # set the tools
2707 baddtools f
2708 #
2709 # set parallel processing mode
2710 # 1:  the parallel processing is switched on
2711 # 0:  the parallel processing is switched off
2712 brunparallel 1 
2713 #
2714 # set Fuzzy value
2715 # 0.  : the Fuzzy option is off
2716 # >0. : the Fuzzy option is on
2717 bfuzzyvalue 0.
2718 #
2719 # set safe processing mode
2720 bnondestructive 1
2721 # set safe mode
2722 # 1 - the safe processing mode is switched on
2723 # 0 - the safe processing mode is switched off
2724 #
2725 # set gluing mode
2726 bglue 1
2727 # set the gluing mode
2728 # 1 or 2 - the gluing mode is switched on
2729 # 0 - the gluing mode is switched off
2730 #
2731 # run the algorithm
2732 # r is the result of the operation
2733 bapisplit r 
2734 ~~~~
2735
2736 @subsubsection occt_algorithms_11b_2_3 Case 3. Common operation
2737
2738 The following example illustrates how to use Common operation:
2739
2740 #### C++ Level
2741
2742 ~~~~
2743 #include <TopoDS_Shape.hxx>
2744 #include <TopTools_ListOfShape.hxx>
2745 #include < BRepAlgoAPI_Common.hxx>
2746  {…
2747   Standard_Boolean bRunParallel;
2748   Standard_Integer iErr;
2749   Standard_Real aFuzzyValue;
2750   BRepAlgoAPI_Common aBuilder;
2751   
2752   // perpare the arguments
2753   TopTools_ListOfShape& aLS=…;
2754   TopTools_ListOfShape& aLT=…;
2755   //
2756   bRunParallel=Standard_True;
2757   aFuzzyValue=2.1e-5;
2758   //
2759   // set the arguments  
2760   aBuilder.SetArguments(aLS);
2761   aBuilder.SetTools(aLT);
2762   //    
2763   // set parallel processing mode 
2764   // if  bRunParallel= Standard_True :  the parallel processing is switched on
2765   // if  bRunParallel= Standard_False :  the parallel processing is switched off
2766   aBuilder.SetRunParallel(bRunParallel);
2767   //
2768   // set Fuzzy value
2769   // if aFuzzyValue=0.: the Fuzzy option is off
2770   //  if aFuzzyValue>0.: the Fuzzy option is on
2771   aBuilder.SetFuzzyValue(aFuzzyValue);
2772   //
2773   // safe mode - avoid modification of the arguments
2774   Standard_Boolean bSafeMode = Standard_True;
2775   // if bSafeMode == Standard_True  - the safe mode is switched on
2776   // if bSafeMode == Standard_False - the safe mode is switched off
2777   aBuilder.SetNonDestructive(bSafeMode);
2778   //
2779   // gluing options - for coinciding arguments
2780   BOPAlgo_GlueEnum aGlueOpt = BOPAlgo_GlueFull;
2781   // if aGlueOpt == BOPAlgo_GlueOff   - the gluing mode is switched off
2782   // if aGlueOpt == BOPAlgo_GlueShift - the gluing mode is switched on
2783   // if aGlueOpt == BOPAlgo_GlueFull  - the gluing mode is switched on
2784   aBuilder.SetGlue(aGlueOpt);
2785   //
2786   // run the algorithm 
2787   aBuilder.Build(); 
2788   iErr=aBuilder.ErrorStatus();
2789   if (iErr) {
2790     // an error treatment
2791     return;
2792   }
2793   //
2794   // result of the operation aR
2795   const TopoDS_Shape& aR=aBuilder.Shape();
2796
2797 }
2798 ~~~~
2799
2800 #### Tcl Level
2801
2802 ~~~~
2803 # prepare the arguments
2804 box b1 10 10 10 
2805 box b2 7 0 4 10 10 10 
2806 box b3 14 0 0 10 10 10 
2807 #
2808 # clear inner contents
2809 bclearobjects; bcleartools;
2810 #
2811 # set the arguments
2812 baddobjects b1 b3
2813 baddtools b2
2814 #
2815 # set parallel processing mode
2816 # 1:  the parallel processing is switched on
2817 # 0:  the parallel processing is switched off
2818 brunparallel 1
2819 #
2820 # set Fuzzy value
2821 # 0.    : the Fuzzy option is off
2822 # >0. : the Fuzzy option is on
2823 bfuzzyvalue 0.
2824 #
2825 # set safe processing mode
2826 bnondestructive 1
2827 # set safe mode
2828 # 1 - the safe processing mode is switched on
2829 # 0 - the safe processing mode is switched off
2830 #
2831 # set gluing mode
2832 bglue 1
2833 # set the gluing mode
2834 # 1 or 2 - the gluing mode is switched on
2835 # 0 - the gluing mode is switched off
2836 #
2837 # run the algorithm
2838 # r is the result of the operation
2839 # 0 means Common operation
2840 bapibop r 0
2841 ~~~~
2842
2843 @subsubsection occt_algorithms_11b_2_4 Case 4. Fuse operation
2844
2845 The following example illustrates how to use Fuse operation:
2846
2847 #### C++ Level
2848
2849 ~~~~
2850 #include <TopoDS_Shape.hxx>
2851 #include <TopTools_ListOfShape.hxx>
2852 #include < BRepAlgoAPI_Fuse.hxx>
2853  {…
2854   Standard_Boolean bRunParallel;
2855   Standard_Integer iErr;
2856   Standard_Real aFuzzyValue;
2857   BRepAlgoAPI_Fuse aBuilder;
2858   
2859   // perpare the arguments
2860   TopTools_ListOfShape& aLS=…;
2861   TopTools_ListOfShape& aLT=…;
2862   //
2863   bRunParallel=Standard_True;
2864   aFuzzyValue=2.1e-5;
2865   //
2866   // set the arguments  
2867   aBuilder.SetArguments(aLS);
2868   aBuilder.SetTools(aLT);
2869   //    
2870   // set parallel processing mode 
2871   // if  bRunParallel= Standard_True :  the parallel processing is switched on
2872   // if  bRunParallel= Standard_False :  the parallel processing is switched off
2873   aBuilder.SetRunParallel(bRunParallel);
2874   //
2875   // set Fuzzy value
2876   // if aFuzzyValue=0.: the Fuzzy option is off
2877   //  if aFuzzyValue>0.: the Fuzzy option is on
2878   aBuilder.SetFuzzyValue(aFuzzyValue);
2879   //
2880   // safe mode - avoid modification of the arguments
2881   Standard_Boolean bSafeMode = Standard_True;
2882   // if bSafeMode == Standard_True  - the safe mode is switched on
2883   // if bSafeMode == Standard_False - the safe mode is switched off
2884   aBuilder.SetNonDestructive(bSafeMode);
2885   //
2886   // gluing options - for coinciding arguments
2887   BOPAlgo_GlueEnum aGlueOpt = BOPAlgo_GlueFull;
2888   // if aGlueOpt == BOPAlgo_GlueOff   - the gluing mode is switched off
2889   // if aGlueOpt == BOPAlgo_GlueShift - the gluing mode is switched on
2890   // if aGlueOpt == BOPAlgo_GlueFull  - the gluing mode is switched on
2891   aBuilder.SetGlue(aGlueOpt);
2892   //
2893   // run the algorithm 
2894   aBuilder.Build(); 
2895   iErr=aBuilder.ErrorStatus();
2896   if (iErr) {
2897     // an error treatment
2898     return;
2899   }
2900   //
2901   // result of the operation aR
2902   const TopoDS_Shape& aR=aBuilder.Shape();
2903
2904 }
2905 ~~~~
2906
2907 #### Tcl Level
2908
2909 ~~~~
2910 # prepare the arguments
2911 box b1 10 10 10 
2912 box b2 7 0 4 10 10 10 
2913 box b3 14 0 0 10 10 10 
2914 #
2915 # clear inner contents
2916 bclearobjects; bcleartools;
2917 #
2918 # set the arguments
2919 baddobjects b1 b3
2920 baddtools b2
2921 #
2922 # set parallel processing mode
2923 # 1:  the parallel processing is switched on
2924 # 0:  the parallel processing is switched off
2925 brunparallel 1
2926 #
2927 # set Fuzzy value
2928 # 0.    : the Fuzzy option is off
2929 # >0. : the Fuzzy option is on
2930 bfuzzyvalue 0.
2931 #
2932 # set safe processing mode
2933 bnondestructive 1
2934 # set safe mode
2935 # 1 - the safe processing mode is switched on
2936 # 0 - the safe processing mode is switched off
2937 #
2938 # set gluing mode
2939 bglue 1
2940 # set the gluing mode
2941 # 1 or 2 - the gluing mode is switched on
2942 # 0 - the gluing mode is switched off
2943 #
2944 # run the algorithm
2945 # r is the result of the operation
2946 # 1 means Fuse operation
2947 bapibop r 1
2948 ~~~~
2949
2950 @subsubsection occt_algorithms_11b_2_5 Case 5. Cut operation
2951
2952 The following example illustrates how to use Cut operation:
2953
2954 #### C++ Level
2955
2956 ~~~~
2957 #include <TopoDS_Shape.hxx>
2958 #include <TopTools_ListOfShape.hxx>
2959 #include < BRepAlgoAPI_Cut.hxx>
2960  {…
2961   Standard_Boolean bRunParallel;
2962   Standard_Integer iErr;
2963   Standard_Real aFuzzyValue;
2964   BRepAlgoAPI_Cut aBuilder;
2965   
2966   // perpare the arguments
2967   TopTools_ListOfShape& aLS=…;
2968   TopTools_ListOfShape& aLT=…;
2969   //
2970   bRunParallel=Standard_True;
2971   aFuzzyValue=2.1e-5;
2972   //
2973   // set the arguments  
2974   aBuilder.SetArguments(aLS);
2975   aBuilder.SetTools(aLT);
2976   //    
2977   // set parallel processing mode 
2978   // if  bRunParallel= Standard_True :  the parallel processing is switched on
2979   // if  bRunParallel= Standard_False :  the parallel processing is switched off
2980   aBuilder.SetRunParallel(bRunParallel);
2981   //
2982   // set Fuzzy value
2983   // if aFuzzyValue=0.: the Fuzzy option is off
2984   //  if aFuzzyValue>0.: the Fuzzy option is on
2985   aBuilder.SetFuzzyValue(aFuzzyValue);
2986   //
2987   // safe mode - avoid modification of the arguments
2988   Standard_Boolean bSafeMode = Standard_True;
2989   // if bSafeMode == Standard_True  - the safe mode is switched on
2990   // if bSafeMode == Standard_False - the safe mode is switched off
2991   aBuilder.SetNonDestructive(bSafeMode);
2992   //
2993   // gluing options - for coinciding arguments
2994   BOPAlgo_GlueEnum aGlueOpt = BOPAlgo_GlueFull;
2995   // if aGlueOpt == BOPAlgo_GlueOff   - the gluing mode is switched off
2996   // if aGlueOpt == BOPAlgo_GlueShift - the gluing mode is switched on
2997   // if aGlueOpt == BOPAlgo_GlueFull  - the gluing mode is switched on
2998   aBuilder.SetGlue(aGlueOpt);
2999   //
3000   // run the algorithm 
3001   aBuilder.Build(); 
3002   iErr=aBuilder.ErrorStatus();
3003   if (iErr) {
3004     // an error treatment
3005     return;
3006   }
3007   //
3008   // result of the operation aR
3009   const TopoDS_Shape& aR=aBuilder.Shape();
3010
3011 }
3012 ~~~~
3013
3014 #### Tcl Level
3015
3016 ~~~~
3017 # prepare the arguments
3018 box b1 10 10 10 
3019 box b2 7 0 4 10 10 10 
3020 box b3 14 0 0 10 10 10 
3021 #
3022 # clear inner contents
3023 bclearobjects; bcleartools;
3024 #
3025 # set the arguments
3026 baddobjects b1 b3
3027 baddtools b2
3028 #
3029 # set parallel processing mode
3030 # 1:  the parallel processing is switched on
3031 # 0:  the parallel processing is switched off
3032 brunparallel 1
3033 #
3034 # set Fuzzy value
3035 # 0.    : the Fuzzy option is off
3036 # >0. : the Fuzzy option is on
3037 bfuzzyvalue 0.
3038 #
3039 # set safe processing mode
3040 bnondestructive 1
3041 # set safe mode
3042 # 1 - the safe processing mode is switched on
3043 # 0 - the safe processing mode is switched off
3044 # set gluing mode
3045 #
3046 bglue 1
3047 # set the gluing mode
3048 # 1 or 2 - the gluing mode is switched on
3049 # 0 - the gluing mode is switched off
3050 #
3051 # run the algorithm
3052 # r is the result of the operation
3053 # 2 means Cut operation
3054 bapibop r 2
3055 ~~~~
3056
3057
3058 @subsubsection occt_algorithms_11b_2_6 Case 6. Section operation
3059
3060 The following example illustrates how to use Section operation:
3061
3062 #### C++ Level
3063
3064 ~~~~
3065 #include <TopoDS_Shape.hxx>
3066 #include <TopTools_ListOfShape.hxx>
3067 #include < BRepAlgoAPI_Section.hxx>
3068  {…
3069   Standard_Boolean bRunParallel;
3070   Standard_Integer iErr;
3071   Standard_Real aFuzzyValue;
3072   BRepAlgoAPI_Section aBuilder;
3073   
3074   // perpare the arguments
3075   TopTools_ListOfShape& aLS=…;
3076   TopTools_ListOfShape& aLT=…;
3077   //
3078   bRunParallel=Standard_True;
3079   aFuzzyValue=2.1e-5;
3080   //
3081   // set the arguments  
3082   aBuilder.SetArguments(aLS);
3083   aBuilder.SetTools(aLT);
3084   //    
3085   // set parallel processing mode 
3086   // if  bRunParallel= Standard_True :  the parallel processing is switched on
3087   // if  bRunParallel= Standard_False :  the parallel processing is switched off
3088   aBuilder.SetRunParallel(bRunParallel);
3089   //
3090   // set Fuzzy value
3091   // if aFuzzyValue=0.: the Fuzzy option is off
3092