CommitLineData
ba06f8bb 1Modeling Algorithms {#occt_user_guides__modeling_algos}
72b7576f 2=========================
3
e5bd0d98 4@tableofcontents
5
72b7576f 6@section occt_modalg_1 Introduction
7
e2ba9cb1 8This manual explains how to use the Modeling Algorithms. It provides basic documentation on modeling algorithms. For advanced information on Modeling Algorithms, see our <a href="http://www.opencascade.com/content/tutorial-learning">E-learning & Training</a> offerings.
72b7576f 9
10The Modeling Algorithms module brings together a wide range of topological algorithms used in modeling. Along with these tools, you will find the geometric algorithms, which they call.
11
72b7576f 12@section occt_modalg_2 Geometric Tools
13
e2b55410 14Open CASCADE Technology geometric tools provide algorithms to:
15 * Calculate the intersection of two 2D curves, surfaces, or a 3D curve and a surface;
16 * Project points onto 2D and 3D curves, points onto surfaces, and 3D curves onto surfaces;
17 * Construct lines and circles from constraints;
18 * Construct curves and surfaces from constraints;
19 * Construct curves and surfaces by interpolation.
20
72b7576f 21@subsection occt_modalg_2_2 Intersections
22
e2b55410 23The Intersections component is used to compute intersections between 2D or 3D geometrical objects:
24 * the intersections between two 2D curves;
25 * the self-intersections of a 2D curve;
26 * the intersection between a 3D curve and a surface;
27 * the intersection between two surfaces.
28
dba69de2 29The *Geom2dAPI_InterCurveCurve* class allows the evaluation of the intersection points (*gp_Pnt2d*) between two geometric curves (*Geom2d_Curve*) and the evaluation of the points of self-intersection of a curve.
72b7576f 30
d6b4d3d0 31@figure{/user_guides/modeling_algos/images/modeling_algos_image003.png,"Intersection and self-intersection of curves",420}
72b7576f 32
33In both cases, the algorithm requires a value for the tolerance (Standard_Real) for the confusion between two points. The default tolerance value used in all constructors is *1.0e-6.*
34
d6b4d3d0 35@figure{/user_guides/modeling_algos/images/modeling_algos_image004.png,"Intersection and tangent intersection",420}
72b7576f 36
37The algorithm returns a point in the case of an intersection and a segment in the case of tangent intersection.
38
e2b55410 39@subsubsection occt_modalg_2_2_1 Intersection of two curves
72b7576f 40
e2b55410 41*Geom2dAPI_InterCurveCurve* class may be instantiated for intersection of curves *C1* and *C2*.
72b7576f 42~~~~~
43Geom2dAPI_InterCurveCurve Intersector(C1,C2,tolerance);
44~~~~~
45
e2b55410 46or for self-intersection of curve *C3*.
72b7576f 47~~~~~
48Geom2dAPI_InterCurveCurve Intersector(C3,tolerance);
49~~~~~
50
51~~~~~
52Standard_Integer N = Intersector.NbPoints();
53~~~~~
54Calls the number of intersection points
55
56To select the desired intersection point, pass an integer index value in argument.
57~~~~~
58gp_Pnt2d P = Intersector.Point(Index);
59~~~~~
60
dba69de2 61To call the number of intersection segments, use
72b7576f 62~~~~~
63Standard_Integer M = Intersector.NbSegments();
64~~~~~
65
72b7576f 66To select the desired intersection segment pass integer index values in argument.
67~~~~~
68Handle(Geom2d_Curve) Seg1, Seg2;
69Intersector.Segment(Index,Seg1,Seg2);
70// if intersection of 2 curves
71Intersector.Segment(Index,Seg1);
72// if self-intersection of a curve
73~~~~~
74
e2b55410 75If you need access to a wider range of functionalities the following method will return the algorithmic object for the calculation of intersections:
72b7576f 76
77~~~~~
e5bd0d98 78Geom2dInt_GInter& TheIntersector = Intersector.Intersector();
72b7576f 79~~~~~
80
81@subsubsection occt_modalg_2_2_2 Intersection of Curves and Surfaces
e2b55410 82
dba69de2 83The *GeomAPI_IntCS* class is used to compute the intersection points between a curve and a surface.
72b7576f 84
85This class is instantiated as follows:
86~~~~~
87GeomAPI_IntCS Intersector(C, S);
88~~~~~
89
e5bd0d98 90To call the number of intersection points, use:
72b7576f 91~~~~~
92Standard_Integer nb = Intersector.NbPoints();
93~~~~~
e5bd0d98 94
72b7576f 95
96~~~~~
e5bd0d98 97gp_Pnt& P = Intersector.Point(Index);
72b7576f 98~~~~~
99
dba69de2 100Where *Index* is an integer between 1 and *nb*, calls the intersection points.
72b7576f 101
102@subsubsection occt_modalg_2_2_3 Intersection of two Surfaces
dba69de2 103The *GeomAPI_IntSS* class is used to compute the intersection of two surfaces from *Geom_Surface* with respect to a given tolerance.
72b7576f 104
105This class is instantiated as follows:
106~~~~~
107GeomAPI_IntSS Intersector(S1, S2, Tolerance);
108~~~~~
dba69de2 109Once the *GeomAPI_IntSS* object has been created, it can be interpreted.
72b7576f 110
111~~~~~
112Standard_Integer nb = Intersector. NbLines();
113~~~~~
114Calls the number of intersection curves.
115
116~~~~~
117Handle(Geom_Curve) C = Intersector.Line(Index)
118~~~~~
dba69de2 119Where *Index* is an integer between 1 and *nb*, calls the intersection curves.
72b7576f 120
e2b55410 121
72b7576f 122@subsection occt_modalg_2_3 Interpolations
72b7576f 123
e2b55410 124The Interpolation Laws component provides definitions of functions: <i> y=f(x) </i>.
125
126In particular, it provides definitions of:
127 * a linear function,
128 * an <i> S </i> function, and
129 * an interpolation function for a range of values.
130
131Such functions can be used to define, for example, the evolution law of a fillet along the edge of a shape.
132
133The validity of the function built is never checked: the Law package does not know for what application or to what end the function will be used. In particular, if the function is used as the evolution law of a fillet, it is important that the function is always positive. The user must check this.
72b7576f 134
135@subsubsection occt_modalg_2_3_1 Geom2dAPI_Interpolate
dba69de2 136This class is used to interpolate a BSplineCurve passing through an array of points. If tangency is not requested at the point of interpolation, continuity will be *C2*. If tangency is requested at the point, continuity will be *C1*. If Periodicity is requested, the curve will be closed and the junction will be the first point given. The curve will then have a continuity of *C1* only.
72b7576f 137This class may be instantiated as follows:
138~~~~~
139Geom2dAPI_Interpolate
e5bd0d98 140(const Handle_TColgp_HArray1OfPnt2d& Points,
72b7576f 141const Standard_Boolean PeriodicFlag,
142const Standard_Real Tolerance);
143
144Geom2dAPI_Interpolate Interp(Points, Standard_False,
dba69de2 145 Precision::Confusion());
72b7576f 146~~~~~
147
148
149It is possible to call the BSpline curve from the object defined above it.
150~~~~~
151Handle(Geom2d_BSplineCurve) C = Interp.Curve();
152~~~~~
153
dba69de2 154Note that the *Handle(Geom2d_BSplineCurve)* operator has been redefined by the method *Curve()*. Consequently, it is unnecessary to pass via the construction of an intermediate object of the *Geom2dAPI_Interpolate* type and the following syntax is correct.
72b7576f 155
156~~~~~
157Handle(Geom2d_BSplineCurve) C =
158Geom2dAPI_Interpolate(Points,
dba69de2 159 Standard_False,
160 Precision::Confusion());
72b7576f 161~~~~~
162
163@subsubsection occt_modalg_2_3_2 GeomAPI_Interpolate
164
165This class may be instantiated as follows:
166~~~~~
167GeomAPI_Interpolate
e5bd0d98 168(const Handle_TColgp_HArray1OfPnt& Points,
72b7576f 169const Standard_Boolean PeriodicFlag,
170const Standard_Real Tolerance);
171
172GeomAPI_Interpolate Interp(Points, Standard_False,
dba69de2 173 Precision::Confusion());
72b7576f 174~~~~~
175
176It is possible to call the BSpline curve from the object defined above it.
177~~~~~
178Handle(Geom_BSplineCurve) C = Interp.Curve();
179~~~~~
dba69de2 180Note that the *Handle(Geom_BSplineCurve)* operator has been redefined by the method *Curve()*. Thus, it is unnecessary to pass via the construction of an intermediate object of the *GeomAPI_Interpolate* type and the following syntax is correct.
72b7576f 181
182Handle(Geom_BSplineCurve) C =
183 GeomAPI_Interpolate(Points,
184 Standard_False,
185 1.0e-7);
186
187Boundary conditions may be imposed with the method Load.
188~~~~~
189GeomAPI_Interpolate AnInterpolator
190(Points, Standard_False, 1.0e-5);
192~~~~~
193
194@subsection occt_modalg_2_4 Lines and Circles from Constraints
195
2683e647 196@subsubsection occt_modalg_2_4_1 Types of constraints
72b7576f 197
e2b55410 198The algorithms for construction of 2D circles or lines can be described with numeric or geometric constraints in relation to other curves.
72b7576f 199
e2b55410 200These constraints can impose the following :
201 * the radius of a circle,
202 * the angle that a straight line makes with another straight line,
203 * the tangency of a straight line or circle in relation to a curve,
204 * the passage of a straight line or circle through a point,
205 * the circle with center in a point or curve.
72b7576f 206
e2b55410 207For example, these algorithms enable to easily construct a circle of a given radius, centered on a straight line and tangential to another circle.
72b7576f 208
e2b55410 209The implemented algorithms are more complex than those provided by the Direct Constructions component for building 2D circles or lines.
72b7576f 210
e2b55410 211The expression of a tangency problem generally leads to several results, according to the relative positions of the solution and the circles or straight lines in relation to which the tangency constraints are expressed. For example, consider the following
212case of a circle of a given radius (a small one) which is tangential to two secant circles C1 and C2:
72b7576f 213
d6b4d3d0 214@figure{/user_guides/modeling_algos/images/modeling_algos_image058.png,"Example of a Tangency Constraint",360}
72b7576f 215
e2b55410 216This diagram clearly shows that there are 8 possible solutions.
72b7576f 217
e2b55410 218In order to limit the number of solutions, we can try to express the relative position
219of the required solution in relation to the circles to which it is tangential. For
220example, if we specify that the solution is inside the circle C1 and outside the
221circle C2, only two solutions referenced 3 and 4 on the diagram respond to the problem
222posed.
223
224These definitions are very easy to interpret on a circle, where it is easy to identify
225the interior and exterior sides. In fact, for any kind of curve the interior is defined
226as the left-hand side of the curve in relation to its orientation.
227
228This technique of qualification of a solution, in relation to the curves to which
229it is tangential, can be used in all algorithms for constructing a circle or a straight
230line by geometric constraints. Four qualifiers are used:
3f812249 231 * **Enclosing** -- the solution(s) must enclose the argument;
232 * **Enclosed** -- the solution(s) must be enclosed by the argument;
233 * **Outside** -- the solution(s) and the argument must be external to one another;
234 * **Unqualified** -- the relative position is not qualified, i.e. all solutions apply.
e2b55410 235
236It is possible to create expressions using the qualifiers, for example:
237~~~~~
239 Solver(GccEnt::Outside(C1),
241~~~~~
72b7576f 242
e2b55410 243This expression finds all circles of radius *Rad*, which are tangent to both circle *C1* and *C2*, while *C1* is outside and *C2* is inside.
244
2683e647 245@subsubsection occt_modalg_2_4_2 Available types of lines and circles
e2b55410 246
247The following analytic algorithms using value-handled entities for creation of 2D lines or circles with geometric constraints are available:
72b7576f 248 * circle tangent to three elements (lines, circles, curves, points),
249 * circle tangent to two elements and having a radius,
250 * circle tangent to two elements and centered on a third element,
251 * circle tangent to two elements and centered on a point,
252 * circle tangent to one element and centered on a second,
253 * bisector of two points,
254 * bisector of two lines,
255 * bisector of two circles,
256 * bisector of a line and a point,
257 * bisector of a circle and a point,
258 * bisector of a line and a circle,
259 * line tangent to two elements (points, circles, curves),
260 * line tangent to one element and parallel to a line,
261 * line tangent to one element and perpendicular to a line,
262 * line tangent to one element and forming angle with a line.
263
e2b55410 264#### Exterior/Interior
72b7576f 265It is not hard to define the interior and exterior of a circle. As is shown in the following diagram, the exterior is indicated by the sense of the binormal, that is to say the right side according to the sense of traversing the circle. The left side is therefore the interior (or &quot;material&quot;).
266
d6b4d3d0 267@figure{/user_guides/modeling_algos/images/modeling_algos_image006.png,"Exterior/Interior of a Circle",220}
72b7576f 268
269By extension, the interior of a line or any open curve is defined as the left side according to the passing direction, as shown in the following diagram:
270
d6b4d3d0 271@figure{/user_guides/modeling_algos/images/modeling_algos_image007.png,"Exterior/Interior of a Line and a Curve",220}
72b7576f 272
e2b55410 273#### Orientation of a Line
72b7576f 274It is sometimes necessary to define in advance the sense of travel along a line to be created. This sense will be from first to second argument.
275
276The following figure shows a line, which is first tangent to circle C1 which is interior to the line, and then passes through point P1.
277
d6b4d3d0 278@figure{/user_guides/modeling_algos/images/modeling_algos_image008.png,"An Oriented Line",220}
72b7576f 279
72b7576f 280
e2b55410 281#### Line tangent to two circles
72b7576f 282The following four diagrams illustrate four cases of using qualifiers in the creation of a line. The fifth shows the solution if no qualifiers are given.
e2b55410 283
72b7576f 284
285**Example 1 Case 1**
286
d6b4d3d0 287@figure{/user_guides/modeling_algos/images/modeling_algos_image009.png,"Both circles outside",220}
72b7576f 288
289Constraints:
290Tangent and Exterior to C1.
291Tangent and Exterior to C2.
292
293Syntax:
294
295~~~~~
296GccAna_Lin2d2Tan
297 Solver(GccEnt::Outside(C1),
298 GccEnt::Outside(C2),
299 Tolerance);
300~~~~~
301
302**Example 1 Case 2**
303
d6b4d3d0 304@figure{/user_guides/modeling_algos/images/modeling_algos_image010.png,"Both circles enclosed",220}
72b7576f 305
306Constraints:
307Tangent and Including C1.
308Tangent and Including C2.
309
310Syntax:
311
312~~~~~
313GccAna_Lin2d2Tan
314 Solver(GccEnt::Enclosing(C1),
315 GccEnt::Enclosing(C2),
316 Tolerance);
317~~~~~
318
319**Example 1 Case 3**
320
d6b4d3d0 321@figure{/user_guides/modeling_algos/images/modeling_algos_image011.png,"C1 enclosed and C2 outside",220}
72b7576f 322
323Constraints:
324Tangent and Including C1.
e2b55410 325Tangent and Exterior to C2.
72b7576f 326
327Syntax:
328~~~~~
329GccAna_Lin2d2Tan
330 Solver(GccEnt::Enclosing(C1),
331 GccEnt::Outside(C2),
332 Tolerance);
333~~~~~
334
335**Example 1 Case 4**
336
d6b4d3d0 337@figure{/user_guides/modeling_algos/images/modeling_algos_image012.png,"C1 outside and C2 enclosed",220}
72b7576f 338Constraints:
339Tangent and Exterior to C1.
340Tangent and Including C2.
341
342Syntax:
343~~~~~
344GccAna_Lin2d2Tan
345 Solver(GccEnt::Outside(C1),
346 GccEnt::Enclosing(C2),
347 Tolerance);
348~~~~~
349
350**Example 1 Case 5**
351
d6b4d3d0 352@figure{/user_guides/modeling_algos/images/modeling_algos_image013.png,"Without qualifiers",220}
72b7576f 353
354Constraints:
355Tangent and Undefined with respect to C1.
356Tangent and Undefined with respect to C2.
357
358Syntax:
359~~~~~
360GccAna_Lin2d2Tan
361 Solver(GccEnt::Unqualified(C1),
362 GccEnt::Unqualified(C2),
363 Tolerance);
364~~~~~
365
e2b55410 366#### Circle of given radius tangent to two circles
72b7576f 367The following four diagrams show the four cases in using qualifiers in the creation of a circle.
368
369**Example 2 Case 1**
d6b4d3d0 370@figure{/user_guides/modeling_algos/images/modeling_algos_image014.png,"Both solutions outside",220}
72b7576f 371
372Constraints:
373Tangent and Exterior to C1.
374Tangent and Exterior to C2.
375
376Syntax:
377~~~~~
379 Solver(GccEnt::Outside(C1),
381~~~~~
382
383**Example 2 Case 2**
384
d6b4d3d0 385@figure{/user_guides/modeling_algos/images/modeling_algos_image015.png,"C2 encompasses C1",220}
72b7576f 386
387Constraints:
388Tangent and Exterior to C1.
389Tangent and Included by C2.
390
391Syntax:
392~~~~~
394 Solver(GccEnt::Outside(C1),
396~~~~~
397
398**Example 2 Case 3**
d6b4d3d0 399@figure{/user_guides/modeling_algos/images/modeling_algos_image016.png,"Solutions enclose C2",220}
72b7576f 400
401Constraints:
402Tangent and Exterior to C1.
403Tangent and Including C2.
404
405Syntax:
406~~~~~
408 Solver(GccEnt::Outside(C1),
410~~~~~
411
412**Example 2 Case 4**
d6b4d3d0 413@figure{/user_guides/modeling_algos/images/modeling_algos_image017.png,"Solutions enclose C1",220}
72b7576f 414
415Constraints:
416Tangent and Enclosing C1.
417Tangent and Enclosing C2.
418
419Syntax:
420~~~~~
422 Solver(GccEnt::Enclosing(C1),
424~~~~~
425
426**Example 2 Case 5**
dba69de2 427
428The following syntax will give all the circles of radius *Rad*, which are tangent to *C1* and *C2* without discrimination of relative position:
72b7576f 429
430~~~~~
432 GccEnt::Unqualified(C2),
434~~~~~
72b7576f 435
72b7576f 436
2683e647 437@subsubsection occt_modalg_2_4_3 Types of algorithms
72b7576f 438
e2b55410 439OCCT implements several categories of algorithms:
72b7576f 440
e2b55410 441* **Analytic** algorithms, where solutions are obtained by the resolution of an equation, such algorithms are used when the geometries which are worked on (tangency arguments, position of the center, etc.) are points, lines or circles;
442* **Geometric** algorithms, where the solution is generally obtained by calculating the intersection of parallel or bisecting curves built from geometric arguments;
443* **Iterative** algorithms, where the solution is obtained by a process of iteration.
444
445For each kind of geometric construction of a constrained line or circle, OCCT provides two types of access:
72b7576f 446
e2b55410 447 * algorithms from the package <i> Geom2dGcc </i> automatically select the algorithm best suited to the problem, both in the general case and in all types of specific cases; the used arguments are *Geom2d* objects, while the computed solutions are <i> gp </i> objects;
448 * algorithms from the package <i> GccAna</i> resolve the problem analytically, and can only be used when the geometries to be worked on are lines or circles; both the used arguments and the computed solutions are <i> gp </i> objects.
72b7576f 449
e2b55410 450The provided algorithms compute all solutions, which correspond to the stated geometric problem, unless the solution is found by an iterative algorithm.
72b7576f 451
e2b55410 452Iterative algorithms compute only one solution, closest to an initial position. They can be used in the following cases:
453 * to build a circle, when an argument is more complex than a line or a circle, and where the radius is not known or difficult to determine: this is the case for a circle tangential to three geometric elements, or tangential to two geometric elements and centered on a curve;
454 * to build a line, when a tangency argument is more complex than a line or a circle.
72b7576f 455
e2b55410 456Qualified curves (for tangency arguments) are provided either by:
457 * the <i> GccEnt</i> package, for direct use by <i> GccAna</i> algorithms, or
458 * the <i> Geom2dGcc </i> package, for general use by <i> Geom2dGcc </i> algorithms.
72b7576f 459
e2b55410 460The <i> GccEnt</i> and <i> Geom2dGcc</i> packages also provide simple functions for building qualified curves in a very efficient way.
72b7576f 461
e2b55410 462The <i> GccAna </i>package also provides algorithms for constructing bisecting loci between circles, lines or points. Bisecting loci between two geometric objects are such that each of their points is at the same distance from the two geometric objects. They
463are typically curves, such as circles, lines or conics for <i> GccAna</i> algorithms.
464Each elementary solution is given as an elementary bisecting locus object (line, circle, ellipse, hyperbola, parabola), described by the <i>GccInt</i> package.
dba69de2 465
e2b55410 466Note: Curves used by <i>GccAna</i> algorithms to define the geometric problem to be solved, are 2D lines or circles from the <i> gp</i> package: they are not explicitly parameterized. However, these lines or circles retain an implicit parameterization, corresponding to that which they induce on equivalent Geom2d objects. This induced parameterization is the one used when returning parameter values on such curves, for instance with the functions <i> Tangency1, Tangency2, Tangency3, Intersection2</i> and <i> CenterOn3</i> provided by construction algorithms from the <i> GccAna </i> or <i> Geom2dGcc</i> packages.
72b7576f 467
e2b55410 468@subsection occt_modalg_2_5 Curves and Surfaces from Constraints
72b7576f 469
e2b55410 470The Curves and Surfaces from Constraints component groups together high level functions used in 2D and 3D geometry for:
471 * creation of faired and minimal variation 2D curves
472 * construction of ruled surfaces
473 * construction of pipe surfaces
474 * filling of surfaces
475 * construction of plate surfaces
476 * extension of a 3D curve or surface beyond its original bounds.
477
e2ba9cb1 478OPEN CASCADE company also provides a product known as <a href="http://www.opencascade.com/content/surfaces-scattered-points">Surfaces from Scattered Points</a>, which allows constructing surfaces from scattered points. This algorithm accepts or constructs an initial B-Spline surface and looks for its deformation (finite elements method) which would satisfy the constraints. Using optimized computation methods, this algorithm is able to construct a surface from more than 500 000 points.
72b7576f 479
e2b55410 480SSP product is not supplied with Open CASCADE Technology, but can be purchased separately.
72b7576f 481
e2b55410 482@subsubsection occt_modalg_2_5_1 Faired and Minimal Variation 2D Curves
72b7576f 483
e2b55410 484Elastic beam curves have their origin in traditional methods of modeling applied
485in boat-building, where a long thin piece of wood, a lathe, was forced to pass
486between two sets of nails and in this way, take the form of a curve based on the
487two points, the directions of the forces applied at those points, and the properties
488of the wooden lathe itself.
72b7576f 489
e2b55410 490Maintaining these constraints requires both longitudinal and transversal forces to
491be applied to the beam in order to compensate for its internal elasticity. The longitudinal
492forces can be a push or a pull and the beam may or may not be allowed to slide over
493these fixed points.
72b7576f 494
e2b55410 495#### Batten Curves
dba69de2 496
e2b55410 497The class *FairCurve_Batten* allows producing faired curves defined on the basis of one or more constraints on each of the two reference points. These include point, angle of tangency and curvature settings.
72b7576f 498The following constraint orders are available:
499
500 * 0 the curve must pass through a point
501 * 1 the curve must pass through a point and have a given tangent
502 * 2 the curve must pass through a point, have a given tangent and a given curvature.
503
504Only 0 and 1 constraint orders are used.
505The function Curve returns the result as a 2D BSpline curve.
506
e2b55410 507#### Minimal Variation Curves
dba69de2 508
e2b55410 509The class *FairCurve_MinimalVariation* allows producing curves with minimal variation in curvature at each reference point. The following constraint orders are available:
72b7576f 510
511 * 0 the curve must pass through a point
512 * 1 the curve must pass through a point and have a given tangent
513 * 2 the curve must pass through a point, have a given tangent and a given curvature.
514
515Constraint orders of 0, 1 and 2 can be used. The algorithm minimizes tension, sagging and jerk energy.
516
517The function *Curve* returns the result as a 2D BSpline curve.
518
72b7576f 519If you want to give a specific length to a batten curve, use:
520
521~~~~~
522b.SetSlidingFactor(L / b.SlidingOfReference())
523~~~~~
524where *b* is the name of the batten curve object
525
e2b55410 526Free sliding is generally more aesthetically pleasing than constrained sliding. However, the computation can fail with values such as angles greater than *p/2* because in this case the length is theoretically infinite.
72b7576f 527
528In other cases, when sliding is imposed and the sliding factor is too large, the batten can collapse.
529
72b7576f 530The constructor parameters, *Tolerance* and *NbIterations*, control how precise the computation is, and how long it will take.
531
e2b55410 532@subsubsection occt_modalg_2_5_2 Ruled Surfaces
72b7576f 533
e2b55410 534A ruled surface is built by ruling a line along the length of two curves.
72b7576f 535
dba69de2 536#### Creation of Bezier surfaces
537
e2b55410 538The class *GeomFill_BezierCurves* allows producing a Bezier surface from contiguous Bezier curves. Note that problems may occur with rational Bezier Curves.
72b7576f 539
dba69de2 540#### Creation of BSpline surfaces
541
e2b55410 542The class *GeomFill_BSplineCurves* allows producing a BSpline surface from contiguous BSpline curves. Note that problems may occur with rational BSplines.
543
2683e647 544@subsubsection occt_modalg_2_5_3 Pipe Surfaces
e2b55410 545
546The class *GeomFill_Pipe* allows producing a pipe by sweeping a curve (the section) along another curve (the path). The result is a BSpline surface.
547
548The following types of construction are available:
549 * pipes with a circular section of constant radius,
550 * pipes with a constant section,
551 * pipes with a section evolving between two given curves.
552
553
2683e647 554@subsubsection occt_modalg_2_5_4 Filling a contour
72b7576f 555
3a398392 556It is often convenient to create a surface from some curves, which will form the boundaries that define the new surface.
557This is done by the class *GeomFill_ConstrainedFilling*, which allows filling a contour defined by three or four curves as well as by tangency constraints. The resulting surface is a BSpline.
dba69de2 558
e2b55410 559A case in point is the intersection of two fillets at a corner. If the radius of the fillet on one edge is different from that of the fillet on another, it becomes impossible to sew together all the edges of the resulting surfaces. This leaves a gap in the overall surface of the object which you are constructing.
dba69de2 560
d6b4d3d0 561@figure{/user_guides/modeling_algos/images/modeling_algos_image059.png,"Intersecting filleted edges with differing radiuses",220}
72b7576f 562
e2b55410 563These algorithms allow you to fill this gap from two, three or four curves. This can be done with or without constraints, and the resulting surface will be either a Bezier or a BSpline surface in one of a range of filling styles.
72b7576f 564
dba69de2 565#### Creation of a Boundary
566
72b7576f 567The class *GeomFill_SimpleBound* allows you defining a boundary for the surface to be constructed.
568
dba69de2 569#### Creation of a Boundary with an adjoining surface
570
72b7576f 571The class *GeomFill_BoundWithSurf* allows defining a boundary for the surface to be constructed. This boundary will already be joined to another surface.
572
dba69de2 573#### Filling styles
574
72b7576f 575The enumerations *FillingStyle* specify the styles used to build the surface. These include:
576
3f812249 577 * *Stretch* -- the style with the flattest patches
578 * *Coons* -- a rounded style with less depth than *Curved*
579 * *Curved* -- the style with the most rounded patches.
72b7576f 580
d6b4d3d0 581@figure{/user_guides/modeling_algos/images/modeling_algos_image018.png,"Intersecting filleted edges with different radii leave a gap filled by a surface",274}
72b7576f 582
2683e647 583@subsubsection occt_modalg_2_5_5 Plate surfaces
e2b55410 584
585In CAD, it is often necessary to generate a surface which has no exact mathematical definition, but which is defined by respective constraints. These can be of a mathematical, a technical or an aesthetic order.
586
587Essentially, a plate surface is constructed by deforming a surface so that it conforms to a given number of curve or point constraints. In the figure below, you can see four segments of the outline of the plane, and a point which have been used as the
588curve constraints and the point constraint respectively. The resulting surface can be converted into a BSpline surface by using the function <i> MakeApprox </i>.
589
590The surface is built using a variational spline algorithm. It uses the principle of deformation of a thin plate by localised mechanical forces. If not already given in the input, an initial surface is calculated. This corresponds to the plate prior
591to deformation. Then, the algorithm is called to calculate the final surface. It looks for a solution satisfying constraints and minimizing energy input.
592
d6b4d3d0 593@figure{/user_guides/modeling_algos/images/modeling_algos_image061.png,"Surface generated from two curves and a point",360}
72b7576f 594
e2b55410 595The package *GeomPlate* provides the following services for creating surfaces respecting curve and point constraints:
72b7576f 596
dba69de2 597#### Definition of a Framework
598
72b7576f 599The class *BuildPlateSurface* allows creating a framework to build surfaces according to curve and point constraints as well as tolerance settings. The result is returned with the function *Surface*.
600
601Note that you do not have to specify an initial surface at the time of construction. It can be added later or, if none is loaded, a surface will be computed automatically.
602
dba69de2 603#### Definition of a Curve Constraint
604
72b7576f 605The class *CurveConstraint* allows defining curves as constraints to the surface, which you want to build.
606
dba69de2 607#### Definition of a Point Constraint
608
72b7576f 609The class *PointConstraint* allows defining points as constraints to the surface, which you want to build.
610
dba69de2 611#### Applying Geom_Surface to Plate Surfaces
612
72b7576f 613The class *Surface* allows describing the characteristics of plate surface objects returned by **BuildPlateSurface::Surface** using the methods of *Geom_Surface*
614
dba69de2 615#### Approximating a Plate surface to a BSpline
72b7576f 616
dba69de2 617The class *MakeApprox* allows converting a *GeomPlate* surface into a *Geom_BSplineSurface*.
72b7576f 618
d6b4d3d0 619@figure{/user_guides/modeling_algos/images/modeling_algos_image060.png,"Surface generated from four curves and a point",360}
72b7576f 620
dba69de2 621Let us create a Plate surface and approximate it from a polyline as a curve constraint and a point constraint
72b7576f 622
623~~~~~
624Standard_Integer NbCurFront=4,
625NbPointConstraint=1;
626gp_Pnt P1(0.,0.,0.);
627gp_Pnt P2(0.,10.,0.);
628gp_Pnt P3(0.,10.,10.);
629gp_Pnt P4(0.,0.,10.);
630gp_Pnt P5(5.,5.,5.);
631BRepBuilderAPI_MakePolygon W;
637// Initialize a BuildPlateSurface
638GeomPlate_BuildPlateSurface BPSurf(3,15,2);
639// Create the curve constraints
640BRepTools_WireExplorer anExp;
641for(anExp.Init(W); anExp.More(); anExp.Next())
642{
643TopoDS_Edge E = anExp.Current();
646C-ChangeCurve().Initialize(E);
647Handle(BRepFill_CurveConstraint) Cont= new
648BRepFill_CurveConstraint(C,0);
650}
651// Point constraint
652Handle(GeomPlate_PointConstraint) PCont= new
653GeomPlate_PointConstraint(P5,0);
655// Compute the Plate surface
656BPSurf.Perform();
657// Approximation of the Plate surface
658Standard_Integer MaxSeg=9;
659Standard_Integer MaxDegree=8;
660Standard_Integer CritOrder=0;
661Standard_Real dmax,Tol;
662Handle(GeomPlate_Surface) PSurf = BPSurf.Surface();
663dmax = Max(0.0001,10*BPSurf.G0Error());
664Tol=0.0001;
665GeomPlate_MakeApprox
666Mapp(PSurf,Tol,MaxSeg,MaxDegree,dmax,CritOrder);
667Handle (Geom_Surface) Surf (Mapp.Surface());
668// create a face corresponding to the approximated Plate
669Surface
670Standard_Real Umin, Umax, Vmin, Vmax;
465e6861 671PSurf->Bounds( Umin, Umax, Vmin, Vmax);
72b7576f 672BRepBuilderAPI_MakeFace MF(Surf,Umin, Umax, Vmin, Vmax);
673~~~~~
674
e2b55410 675@subsection occt_modalg_2_6 Projections
72b7576f 676
e2b55410 677Projections provide for computing the following:
678 * the projections of a 2D point onto a 2D curve
679 * the projections of a 3D point onto a 3D curve or surface
680 * the projection of a 3D curve onto a surface.
681 * the planar curve transposition from the 3D to the 2D parametric space of an underlying plane and v. s.
682 * the positioning of a 2D gp object in the 3D geometric space.
72b7576f 683
e2b55410 684@subsubsection occt_modalg_2_6_1 Projection of a 2D Point on a Curve
685
686*Geom2dAPI_ProjectPointOnCurve* allows calculation of all normals projected from a point (*gp_Pnt2d*) onto a geometric curve (*Geom2d_Curve*). The calculation may be restricted to a given domain.
72b7576f 687
d6b4d3d0 688@figure{/user_guides/modeling_algos/images/modeling_algos_image020.png,"Normals from a point to a curve",320}
dba69de2 689
e2b55410 690The curve does not have to be a *Geom2d_TrimmedCurve*. The algorithm will function with any class inheriting *Geom2d_Curve*.
72b7576f 691
e2b55410 692The class *Geom2dAPI_ProjectPointOnCurve* may be instantiated as in the following example:
72b7576f 693
694~~~~~
695gp_Pnt2d P;
696Handle(Geom2d_BezierCurve) C =
697 new Geom2d_BezierCurve(args);
698Geom2dAPI_ProjectPointOnCurve Projector (P, C);
699~~~~~
700
4ee1bdf4 701To restrict the search for normals to a given domain <i>[U1,U2]</i>, use the following constructor:
72b7576f 702~~~~~
703Geom2dAPI_ProjectPointOnCurve Projector (P, C, U1, U2);
704~~~~~
705Having thus created the *Geom2dAPI_ProjectPointOnCurve* object, we can now interrogate it.
706
dba69de2 707#### Calling the number of solution points
708
72b7576f 709~~~~~
710Standard_Integer NumSolutions = Projector.NbPoints();
711~~~~~
712
dba69de2 713#### Calling the location of a solution point
714
72b7576f 715The solutions are indexed in a range from *1* to *Projector.NbPoints()*. The point, which corresponds to a given *Index* may be found:
716~~~~~
717gp_Pnt2d Pn = Projector.Point(Index);
718~~~~~
719
dba69de2 720#### Calling the parameter of a solution point
721
72b7576f 722For a given point corresponding to a given *Index*:
723
724~~~~~
725Standard_Real U = Projector.Parameter(Index);
726~~~~~
727
728This can also be programmed as:
729
730~~~~~
731Standard_Real U;
732Projector.Parameter(Index,U);
733~~~~~
734
dba69de2 735#### Calling the distance between the start and end points
736
72b7576f 737We can find the distance between the initial point and a point, which corresponds to the given *Index*:
738
739~~~~~
740Standard_Real D = Projector.Distance(Index);
741~~~~~
742
dba69de2 743#### Calling the nearest solution point
744
72b7576f 745
746This class offers a method to return the closest solution point to the starting point. This solution is accessed as follows:
747~~~~~
748gp_Pnt2d P1 = Projector.NearestPoint();
749~~~~~
750
dba69de2 751#### Calling the parameter of the nearest solution point
752
72b7576f 753~~~~~
754Standard_Real U = Projector.LowerDistanceParameter();
755~~~~~
756
dba69de2 757#### Calling the minimum distance from the point to the curve
758
72b7576f 759~~~~~
760Standard_Real D = Projector.LowerDistance();
761~~~~~
762
e2b55410 763#### Redefined operators
72b7576f 764
765Some operators have been redefined to find the closest solution.
766
767*Standard_Real()* returns the minimum distance from the point to the curve.
768
769~~~~~
770Standard_Real D = Geom2dAPI_ProjectPointOnCurve (P,C);
771~~~~~
772
773*Standard_Integer()* returns the number of solutions.
774
775~~~~~
776Standard_Integer N =
777Geom2dAPI_ProjectPointOnCurve (P,C);
778~~~~~
779
780*gp_Pnt2d()* returns the nearest solution point.
781
782~~~~~
783gp_Pnt2d P1 = Geom2dAPI_ProjectPointOnCurve (P,C);
784~~~~~
785
786Using these operators makes coding easier when you only need the nearest point. Thus:
787~~~~~
788Geom2dAPI_ProjectPointOnCurve Projector (P, C);
789gp_Pnt2d P1 = Projector.NearestPoint();
790~~~~~
791can be written more concisely as:
792~~~~~
793gp_Pnt2d P1 = Geom2dAPI_ProjectPointOnCurve (P,C);
794~~~~~
795However, note that in this second case no intermediate *Geom2dAPI_ProjectPointOnCurve* object is created, and thus it is impossible to have access to other solution points.
796
797
72b7576f 799
800If you want to use the wider range of functionalities available from the *Extrema* package, a call to the *Extrema()* method will return the algorithmic object for calculating extrema. For example:
801
802~~~~~
e5bd0d98 803Extrema_ExtPC2d& TheExtrema = Projector.Extrema();
72b7576f 804~~~~~
805
e2b55410 806@subsubsection occt_modalg_2_6_2 Projection of a 3D Point on a Curve
807
808The class *GeomAPI_ProjectPointOnCurve* is instantiated as in the following example:
72b7576f 809
72b7576f 810~~~~~
811gp_Pnt P;
812Handle(Geom_BezierCurve) C =
813 new Geom_BezierCurve(args);
814GeomAPI_ProjectPointOnCurve Projector (P, C);
815~~~~~
e2b55410 816
72b7576f 817If you wish to restrict the search for normals to the given domain [U1,U2], use the following constructor:
e2b55410 818
72b7576f 819~~~~~
820GeomAPI_ProjectPointOnCurve Projector (P, C, U1, U2);
821~~~~~
822Having thus created the *GeomAPI_ProjectPointOnCurve* object, you can now interrogate it.
823
dba69de2 824#### Calling the number of solution points
825
72b7576f 826~~~~~
827Standard_Integer NumSolutions = Projector.NbPoints();
828~~~~~
829
dba69de2 830#### Calling the location of a solution point
831
72b7576f 832The solutions are indexed in a range from 1 to *Projector.NbPoints()*. The point, which corresponds to a given index, may be found:
833~~~~~
834gp_Pnt Pn = Projector.Point(Index);
835~~~~~
836
dba69de2 837#### Calling the parameter of a solution point
838
72b7576f 839For a given point corresponding to a given index:
840
841~~~~~
842Standard_Real U = Projector.Parameter(Index);
843~~~~~
844
845This can also be programmed as:
846~~~~~
847Standard_Real U;
848Projector.Parameter(Index,U);
849~~~~~
850
dba69de2 851#### Calling the distance between the start and end point
852
72b7576f 853The distance between the initial point and a point, which corresponds to a given index, may be found:
854~~~~~
855Standard_Real D = Projector.Distance(Index);
856~~~~~
857
dba69de2 858#### Calling the nearest solution point
859
72b7576f 860This class offers a method to return the closest solution point to the starting point. This solution is accessed as follows:
861~~~~~
862gp_Pnt P1 = Projector.NearestPoint();
863~~~~~
864
dba69de2 865#### Calling the parameter of the nearest solution point
866
72b7576f 867~~~~~
868Standard_Real U = Projector.LowerDistanceParameter();
869~~~~~
870
dba69de2 871#### Calling the minimum distance from the point to the curve
872
72b7576f 873~~~~~
874Standard_Real D = Projector.LowerDistance();
875~~~~~
876
dba69de2 877#### Redefined operators
878
72b7576f 879Some operators have been redefined to find the nearest solution.
880
881*Standard_Real()* returns the minimum distance from the point to the curve.
882
883~~~~~
884Standard_Real D = GeomAPI_ProjectPointOnCurve (P,C);
885~~~~~
886
887*Standard_Integer()* returns the number of solutions.
888~~~~~
889Standard_Integer N = GeomAPI_ProjectPointOnCurve (P,C);
890~~~~~
891
892*gp_Pnt2d()* returns the nearest solution point.
893
894~~~~~
895gp_Pnt P1 = GeomAPI_ProjectPointOnCurve (P,C);
896~~~~~
897Using these operators makes coding easier when you only need the nearest point. In this way,
898
899~~~~~
900GeomAPI_ProjectPointOnCurve Projector (P, C);
901gp_Pnt P1 = Projector.NearestPoint();
902~~~~~
903
904can be written more concisely as:
905~~~~~
906gp_Pnt P1 = GeomAPI_ProjectPointOnCurve (P,C);
907~~~~~
908In the second case, however, no intermediate *GeomAPI_ProjectPointOnCurve* object is created, and it is impossible to access other solutions points.
909
911
912If you want to use the wider range of functionalities available from the *Extrema* package, a call to the *Extrema()* method will return the algorithmic object for calculating the extrema. For example:
72b7576f 913
914~~~~~
e5bd0d98 915Extrema_ExtPC& TheExtrema = Projector.Extrema();
72b7576f 916~~~~~
917
e2b55410 918@subsubsection occt_modalg_2_6_3 Projection of a Point on a Surface
72b7576f 919
e2b55410 920The class *GeomAPI_ProjectPointOnSurf* allows calculation of all normals projected from a point from *gp_Pnt* onto a geometric surface from *Geom_Surface*.
72b7576f 921
d6b4d3d0 922@figure{/user_guides/modeling_algos/images/modeling_algos_image021.png,"Projection of normals from a point to a surface",360}
72b7576f 923
72b7576f 924Note that the surface does not have to be of *Geom_RectangularTrimmedSurface* type.
e2b55410 925The algorithm will function with any class inheriting *Geom_Surface*.
72b7576f 926
927*GeomAPI_ProjectPointOnSurf* is instantiated as in the following example:
928~~~~~
929gp_Pnt P;
930Handle (Geom_Surface) S = new Geom_BezierSurface(args);
931GeomAPI_ProjectPointOnSurf Proj (P, S);
932~~~~~
933
e2b55410 934To restrict the search for normals within the given rectangular domain [U1, U2, V1, V2], use the constructor <i>GeomAPI_ProjectPointOnSurf Proj (P, S, U1, U2, V1, V2)</i>
72b7576f 935
e2b55410 936The values of *U1, U2, V1* and *V2* lie at or within their maximum and minimum limits, i.e.:
72b7576f 937~~~~~
938Umin <= U1 < U2 <= Umax
939Vmin <= V1 < V2 <= Vmax
940~~~~~
941Having thus created the *GeomAPI_ProjectPointOnSurf* object, you can interrogate it.
942
dba69de2 943#### Calling the number of solution points
72b7576f 944
945~~~~~
946Standard_Integer NumSolutions = Proj.NbPoints();
947~~~~~
948
dba69de2 949#### Calling the location of a solution point
950
72b7576f 951The solutions are indexed in a range from 1 to *Proj.NbPoints()*. The point corresponding to the given index may be found:
952
953~~~~~
954gp_Pnt Pn = Proj.Point(Index);
955~~~~~
956
dba69de2 957#### Calling the parameters of a solution point
958
72b7576f 959For a given point corresponding to the given index:
960
961~~~~~
962Standard_Real U,V;
963Proj.Parameters(Index, U, V);
964~~~~~
965
dba69de2 966#### Calling the distance between the start and end point
967
72b7576f 968
969The distance between the initial point and a point corresponding to the given index may be found:
970~~~~~
971Standard_Real D = Projector.Distance(Index);
972~~~~~
973
dba69de2 974#### Calling the nearest solution point
975
72b7576f 976This class offers a method, which returns the closest solution point to the starting point. This solution is accessed as follows:
977~~~~~
978gp_Pnt P1 = Proj.NearestPoint();
979~~~~~
980
dba69de2 981#### Calling the parameters of the nearest solution point
982
72b7576f 983~~~~~
984Standard_Real U,V;
985Proj.LowerDistanceParameters (U, V);
986~~~~~
987
dba69de2 988#### Calling the minimum distance from a point to the surface
989
72b7576f 990~~~~~
991Standard_Real D = Proj.LowerDistance();
992~~~~~
993
dba69de2 994#### Redefined operators
995
72b7576f 996Some operators have been redefined to help you find the nearest solution.
997
998*Standard_Real()* returns the minimum distance from the point to the surface.
999
1000~~~~~
1001Standard_Real D = GeomAPI_ProjectPointOnSurf (P,S);
1002~~~~~
1003
1004*Standard_Integer()* returns the number of solutions.
1005
1006~~~~~
1007Standard_Integer N = GeomAPI_ProjectPointOnSurf (P,S);
1008~~~~~
1009
1010*gp_Pnt2d()* returns the nearest solution point.
1011
1012~~~~~
1013gp_Pnt P1 = GeomAPI_ProjectPointOnSurf (P,S);
1014~~~~~
1015
1016Using these operators makes coding easier when you only need the nearest point. In this way,
1017
1018~~~~~
1019GeomAPI_ProjectPointOnSurface Proj (P, S);
1020gp_Pnt P1 = Proj.NearestPoint();
1021~~~~~
1022
1023can be written more concisely as:
1024
1025~~~~~
1026gp_Pnt P1 = GeomAPI_ProjectPointOnSurface (P,S);
1027~~~~~
1028
1029In the second case, however, no intermediate *GeomAPI_ProjectPointOnSurf* object is created, and it is impossible to access other solution points.
1030
72b7576f 1032
dba69de2 1033If you want to use the wider range of functionalities available from the *Extrema* package, a call to the *Extrema()* method will return the algorithmic object for calculating the extrema as follows:
72b7576f 1034
1035~~~~~
e5bd0d98 1036Extrema_ExtPS& TheExtrema = Proj.Extrema();
72b7576f 1037~~~~~
1038
72b7576f 1039@subsubsection occt_modalg_2_12_8 Switching from 2d and 3d Curves
e2b55410 1040
1041The *To2d* and *To3d* methods are used to;
72b7576f 1042
dba69de2 1043 * build a 2d curve from a 3d *Geom_Curve* lying on a *gp_Pln* plane
1044 * build a 3d curve from a *Geom2d_Curve* and a *gp_Pln* plane.
72b7576f 1045
1046These methods are called as follows:
1047~~~~~
1048Handle(Geom2d_Curve) C2d = GeomAPI::To2d(C3d, Pln);
1049Handle(Geom_Curve) C3d = GeomAPI::To3d(C2d, Pln);
1050~~~~~
1051
e6ae74fd 1052
1053@section occt_modalg_2_topo_tools Topological Tools
1054
1055Open CASCADE Technology topological tools provide algorithms to
1056 * Create wires from edges;
1057 * Create faces from wires;
1058 * Compute state of the shape relatively other shape;
1059 * Orient shapes in container;
1060 * Create new shapes from the existing ones;
1061 * Build PCurves of edges on the faces;
1062 * Check the validity of the shapes;
1063 * Take the point in the face;
1064 * Get the normal direction for the face.
1065
1066
1067@subsection occt_modalg_2_topo_tools_1 Creation of the faces from wireframe model
1068
1069It is possible to create the planar faces from the arbitrary set of planar edges randomly located in 3D space.
1070This feature might be useful if you need for instance to restore the shape from the wireframe model:
1071<table align="center">
1072<tr>
d6b4d3d0 1073 <td>@figure{/user_guides/modeling_algos/images/modeling_algos_image062.png,"Wireframe model",160}</td>
1074 <td>@figure{/user_guides/modeling_algos/images/modeling_algos_image063.png,"Faces of the model",160}</td>
e6ae74fd 1075</tr>
1076</table>
1077
1078To make the faces from edges it is, firstly, necessary to create planar wires from the given edges and than create planar faces from each wire.
1079The static methods *BOPAlgo_Tools::EdgesToWires* and *BOPAlgo_Tools::WiresToFaces* can be used for that:
1080~~~~~
1081TopoDS_Shape anEdges = ...; /* The input edges */
1082Standard_Real anAngTol = 1.e-8; /* The angular tolerance for distinguishing the planes in which the wires are located */
1083Standard_Boolean bShared = Standard_False; /* Defines whether the edges are shared or not */
1084//
1085TopoDS_Shape aWires; /* resulting wires */
1086Standard_Integer iErr = BOPAlgo_Tools::EdgesToWires(anEdges, aWires, bShared, anAngTol);
1087if (iErr) {
1088 cout << "Error: Unable to build wires from given edges\n";
1089 return;
1090}
1091//
1092TopoDS_Shape aFaces; /* resulting faces */
1093Standard_Boolean bDone = BOPAlgo_Tools::WiresToFaces(aWires, aFaces, anAngTol);
1094if (!bDone) {
1095 cout << "Error: Unable to build faces from wires\n";
1096 return;
1097}
1098~~~~~
1099
1100These methods can also be used separately:
1101 * *BOPAlgo_Tools::EdgesToWires* allows creating planar wires from edges.
1102The input edges may be not shared, but the output wires will be sharing the coinciding vertices and edges. For this the intersection of the edges is performed.
1103Although, it is possible to skip the intersection stage (if the input edges are already shared) by passing the corresponding flag into the method.
1104The input edges are expected to be planar, but the method does not check it. Thus, if the input edges are not planar, the output wires will also be not planar.
1105In general, the output wires are non-manifold and may contain free vertices, as well as multi-connected vertices.
1106 * *BOPAlgo_Tools::WiresToFaces* allows creating planar faces from the planar wires.
1107In general, the input wires are non-manifold and may be not closed, but should share the coinciding parts.
1108The wires located in the same plane and completely included into other wires will create holes in the faces built from outer wires:
1109
1110<table align="center">
1111<tr>
d6b4d3d0 1112 <td>@figure{/user_guides/modeling_algos/images/modeling_algos_image064.png,"Wireframe model",160}</td>
1113 <td>@figure{/user_guides/modeling_algos/images/modeling_algos_image065.png,"Two faces (red face has a hole)",160}</td>
e6ae74fd 1114</tr>
1115</table>
1116
1117
1118@subsection occt_modalg_2_topo_tools_2 Classification of the shapes
1119
1120The following methods allow classifying the different shapes relatively other shapes:
1121 * The variety of the *BOPTools_AlgoTools::ComputState* methods classify the vertex/edge/face relatively solid;
1122 * *BOPTools_AlgoTools::IsHole* classifies wire relatively face;
1123 * *IntTools_Tools::ClassifyPointByFace* classifies point relatively face.
1124
1125@subsection occt_modalg_2_topo_tools_3 Orientation of the shapes in the container
1126
1127The following methods allow reorienting shapes in the containers:
1128 * *BOPTools_AlgoTools::OrientEdgesOnWire* correctly orients edges on the wire;
1129 * *BOPTools_AlgoTools::OrientFacesOnShell* correctly orients faces on the shell.
1130
1131@subsection occt_modalg_2_topo_tools_4 Making new shapes
1132
1133The following methods allow creating new shapes from the existing ones:
1134 * The variety of the *BOPTools_AlgoTools::MakeNewVertex* creates the new vertices from other vertices and edges;
1135 * *BOPTools_AlgoTools::MakeSplitEdge* splits the edge by the given parameters.
1136
1137@subsection occt_modalg_2_topo_tools_5 Building PCurves
1138
1139The following methods allow building PCurves of edges on faces:
1140 * *BOPTools_AlgoTools::BuildPCurveForEdgeOnFace* computes PCurve for the edge on the face;
1141 * *BOPTools_AlgoTools::BuildPCurveForEdgeOnPlane* and *BOPTools_AlgoTools::BuildPCurveForEdgesOnPlane* allow building PCurves for edges on the planar face;
1142 * *BOPTools_AlgoTools::AttachExistingPCurve* takes PCurve on the face from one edge and attach this PCurve to other edge coinciding with the first one.
1143
1144@subsection occt_modalg_2_topo_tools_6 Checking the validity of the shapes
1145
1146The following methods allow checking the validity of the shapes:
1147 * *BOPTools_AlgoTools::IsMicroEdge* detects the small edges;
c0a1a35f 1148 * *BOPTools_AlgoTools::ComputeTolerance* computes the correct tolerance of the edge on the face;
d6b4d3d0 1149 * *BOPTools_AlgoTools::CorrectShapeTolerances* and *BOPTools_AlgoTools::CorrectTolerances* allow correcting the tolerances of the sub-shapes.
c0a1a35f 1150 * *BRepLib::FindValidRange* finds a range of 3d curve of the edge not covered by tolerance spheres of vertices.
d6b4d3d0 1151
e6ae74fd 1152@subsection occt_modalg_2_topo_tools_7 Taking a point inside the face
1153
1154The following methods allow taking a point located inside the face:
1155 * The variety of the *BOPTools_AlgoTools3D::PointNearEdge* allows getting a point inside the face located near the edge;
1156 * *BOPTools_AlgoTools3D::PointInFace* allows getting a point inside the face.
1157
1158@subsection occt_modalg_2_topo_tools_8 Getting normal for the face
1159
1160The following methods allow getting the normal direction for the face/surface:
1161 * *BOPTools_AlgoTools3D::GetNormalToSurface* computes the normal direction for the surface in the given point defined by UV parameters;
1162 * *BOPTools_AlgoTools3D::GetNormalToFaceOnEdge* computes the normal direction for the face in the point located on the edge of the face;
1163 * *BOPTools_AlgoTools3D::GetApproxNormalToFaceOnEdge* computes the normal direction for the face in the point located near the edge of the face.
1164
1165
1166
e2b55410 1167@section occt_modalg_3a The Topology API
1168
1169The Topology API of Open CASCADE Technology (**OCCT**) includes the following six packages:
1170 * *BRepAlgoAPI*
1171 * *BRepBuilderAPI*
1172 * *BRepFilletAPI*
1173 * *BRepFeat*
1174 * *BRepOffsetAPI*
1175 * *BRepPrimAPI*
1176
1177The classes provided by the API have the following features:
1178 * The constructors of classes provide different construction methods;
1179 * The class retains different tools used to build objects as fields;
1180 * The class provides a casting method to obtain the result automatically with a function-like call.
1181
1182Let us use the class *BRepBuilderAPI_MakeEdge* to create a linear edge from two points.
1183
1184~~~~~
1185gp_Pnt P1(10,0,0), P2(20,0,0);
1186TopoDS_Edge E = BRepBuilderAPI_MakeEdge(P1,P2);
1187~~~~~
1188
1189This is the simplest way to create edge E from two points P1, P2, but the developer can test for errors when he is not as confident of the data as in the previous example.
1190
1191~~~~~
1192#include <gp_Pnt.hxx>
1193#include <TopoDS_Edge.hxx>
1194#include <BRepBuilderAPI_MakeEdge.hxx>
1195void EdgeTest()
1196{
1197gp_Pnt P1;
1198gp_Pnt P2;
1199BRepBuilderAPI_MakeEdge ME(P1,P2);
1200if (!ME.IsDone())
1201{
1202// doing ME.Edge() or E = ME here
1203// would raise StdFail_NotDone
1204Standard_DomainError::Raise
1205(“ProcessPoints::Failed to createan edge”);
1206}
1207TopoDS_Edge E = ME;
1208}
1209~~~~~
72b7576f 1210
e2b55410 1211In this example an intermediary object ME has been introduced. This can be tested for the completion of the function before accessing the result. More information on **error handling** in the topology programming interface can be found in the next section.
72b7576f 1212
e2b55410 1213*BRepBuilderAPI_MakeEdge* provides valuable information. For example, when creating an edge from two points, two vertices have to be created from the points. Sometimes you may be interested in getting these vertices quickly without exploring the new edge. Such information can be provided when using a class. The following example shows a function creating an edge and two vertices from two points.
72b7576f 1214
e2b55410 1215~~~~~
1216void MakeEdgeAndVertices(const gp_Pnt& P1,
1217const gp_Pnt& P2,
1218TopoDS_Edge& E,
1219TopoDS_Vertex& V1,
1220TopoDS_Vertex& V2)
1221{
1222BRepBuilderAPI_MakeEdge ME(P1,P2);
1223if (!ME.IsDone()) {
1224Standard_DomainError::Raise
1225(“MakeEdgeAndVerices::Failed to create an edge”);
1226}
1227E = ME;
1228V1 = ME.Vextex1();
1229V2 = ME.Vertex2();
1230~~~~~
72b7576f 1231
e2b55410 1232The class *BRepBuilderAPI_MakeEdge* provides two methods *Vertex1* and *Vertex2*, which return two vertices used to create the edge.
1233
1234How can *BRepBuilderAPI_MakeEdge* be both a function and a class? It can do this because it uses the casting capabilities of C++. The *BRepBuilderAPI_MakeEdge* class has a method called Edge; in the previous example the line <i>E = ME</i> could have been written.
1235
1236~~~~~
1237E = ME.Edge();
1238~~~~~
1239
1240This instruction tells the C++ compiler that there is an **implicit casting** of a *BRepBuilderAPI_MakeEdge* into a *TopoDS_Edge* using the *Edge* method. It means this method is automatically called when a *BRepBuilderAPI_MakeEdge* is found where a *TopoDS_Edge* is required.
1241
1242This feature allows you to provide classes, which have the simplicity of function calls when required and the power of classes when advanced processing is necessary. All the benefits of this approach are explained when describing the topology programming interface classes.
1243
1244
1245@subsection occt_modalg_3a_1 Error Handling in the Topology API
1246
1247A method can report an error in the two following situations:
1248 * The data or arguments of the method are incorrect, i.e. they do not respect the restrictions specified by the methods in its specifications. Typical example: creating a linear edge from two identical points is likely to lead to a zero divide when computing the direction of the line.
1249 * Something unexpected happened. This situation covers every error not included in the first category. Including: interruption, programming errors in the method or in another method called by the first method, bad specifications of the arguments (i.e. a set of arguments that was not expected to fail).
1250
1251The second situation is supposed to become increasingly exceptional as a system is debugged and it is handled by the **exception mechanism**. Using exceptions avoids handling error statuses in the call to a method: a very cumbersome style of programming.
1252
1253In the first situation, an exception is also supposed to be raised because the calling method should have verified the arguments and if it did not do so, there is a bug. For example, if before calling *MakeEdge* you are not sure that the two points are non-identical, this situation must be tested.
1254
1255Making those validity checks on the arguments can be tedious to program and frustrating as you have probably correctly surmised that the method will perform the test twice. It does not trust you.
1256As the test involves a great deal of computation, performing it twice is also time-consuming.
1257
1258Consequently, you might be tempted to adopt the highly inadvisable style of programming illustrated in the following example:
1259
1260~~~~~
1261#include <Standard_ErrorHandler.hxx>
1262try {
1263TopoDS_Edge E = BRepBuilderAPI_MakeEdge(P1,P2);
1264// go on with the edge
1265}
1266catch {
1267// process the error.
1268}
1269~~~~~
1270
1271To help the user, the Topology API classes only raise the exception *StdFail_NotDone*. Any other exception means that something happened which was unforeseen in the design of this API.
1272
1273The *NotDone* exception is only raised when the user tries to access the result of the computation and the original data is corrupted. At the construction of the class instance, if the algorithm cannot be completed, the internal flag *NotDone* is set. This flag can be tested and in some situations a more complete description of the error can be queried. If the user ignores the *NotDone* status and tries to access the result, an exception is raised.
1274
1275~~~~~
1276BRepBuilderAPI_MakeEdge ME(P1,P2);
1277if (!ME.IsDone()) {
1278// doing ME.Edge() or E = ME here
1279// would raise StdFail_NotDone
1280Standard_DomainError::Raise
1281(“ProcessPoints::Failed to create an edge”);
1282}
1283TopoDS_Edge E = ME;
1284~~~~~
72b7576f 1285
4f7d41ea 1286
1287@subsection occt_modalg_hist History support
1288
14deaf42 1289All topological API algorithms support the history of shape modifications (or just History) for their arguments.
4f7d41ea 1290Generally, the history is available for the following types of sub-shapes of input shapes:
14deaf42 1291* Vertex;
1292* Edge;
1293* Face.
4f7d41ea 1294
1295Some algorithms also support the history for Solids.
1296
1297The history information consists of the following information:
1301
1302The History is filled basing on the result of the operation. History cannot return any shapes not contained in the result.
14deaf42 1303If the result of the operation is an empty shape, all input shapes will be considered as Deleted and none will have Modified and Generated shapes.
4f7d41ea 1304
1305The history information can be accessed by the API methods:
1306* *Standard_Boolean IsDeleted(const TopoDS_Shape& theS)* - to check if the shape has been Deleted during the operation;
1307* *const TopTools_ListOfShape& Modified(const TopoDS_Shape& theS)* - to get the shapes Modified from the given shape;
1308* *const TopTools_ListOfShape& Generated(const TopoDS_Shape& theS)* - to get the shapes Generated from the given shape.
1309
1310@subsubsection occt_modalg_hist_del Deleted shapes
1311
1312The shape is considered as Deleted during the operation if all of the following conditions are met:
14deaf42 1313* The shape is a part of the argument shapes of the operation;
4f7d41ea 1314* The result shape does not contain the shape itself;
1315* The result shape does not contain any of the splits of the shape.
1316
1317For example, in the CUT operation between two intersecting solids all vertices/edges/faces located completely inside the Tool solid will be Deleted during the operation.
1318
1319@subsubsection occt_modalg_hist_mod Modified shapes
1320
14deaf42 1321The shape is considered as Modified during the operation if the result shape contains the splits of the shape, not the shape itself. The shape can be modified only into the shapes with the same dimension.
4f7d41ea 1322The splits of the shape contained in the result shape are Modified from the shape.
1323The Modified shapes are created from the sub-shapes of the input shapes and, generally, repeat their geometry.
1324
14deaf42 1325The list of Modified elements will contain only those contributing to the result of the operation. If the list is empty, the shape has not been modified and it is necessary to check if it has been Deleted.
4f7d41ea 1326
1327For example, after translation of the shape in any direction all its sub-shapes will be modified into their translated copies.
1328
1329@subsubsection occt_modalg_hist_gen Generated shapes
1330
14deaf42 1331The shapes contained in the result shape are considered as Generated from the input shape if they were produced during the operation and have a different dimension from the shapes from which they were created.
4f7d41ea 1332
14deaf42 1333The list of Generated elements will contain only those included in the result of the operation. If the list is empty, no new shapes have been Generated from the shape.
4f7d41ea 1334
1335For example, extrusion of the edge in some direction will create a face. This face will be generated from the edge.
1336
1337@subsubsection occt_modalg_hist_tool BRepTools_History
1338
1339*BRepTools_History* is the general History tool intended for unification of the histories of different algorithms.
1340
14deaf42 1341*BRepTools_History* can be created from any algorithm supporting the standard history methods *(IsDeleted(), Modified()* and *Generated())*:
4f7d41ea 1342~~~~
1343// The arguments of the operation
1344TopoDS_Shape aS = ...;
1345
1346// Perform transformation on the shape
1347gp_Trsf aTrsf;
1348aTrsf.SetTranslationPart(gp_Vec(0, 0, 1));
1349BRepBuilderAPI_Transform aTransformer(aS, aTrsf); // Transformation API algorithm
1350const TopoDS_Shape& aRes = aTransformer.Shape();
1351
1352// Create the translation history object
1353TopTools_ListOfShape anArguments;
1354anArguments.Append(aS);
1355BRepTools_History aHistory(anArguments, aTransformer);
1356~~~~
1357
14deaf42 1358*BRepTools_History* also allows merging histories. Thus, if you have two or more subsequent operations you can get one final history combined from histories of these operations:
4f7d41ea 1359
1360~~~~
1361Handle(BRepTools_History) aHist1 = ...; // History of first operation
1362Handle(BRepTools_History) aHist2 = ...; // History of second operation
1363~~~~
1364
1365It is possible to merge the second history into the first one:
1366~~~~
1367aHist1->Merge(aHist2);
1368~~~~
1369
1370Or create the new history keeping the two histories unmodified:
1371~~~~
1372Handle(BRepTools_History) aResHistory = new BRepTools_History;
1373aResHistory->Merge(aHist1);
1374aResHistory->Merge(aHist2);
1375~~~~
1376
14deaf42 1377The possibilities of Merging histories and history creation from the API algorithms allow providing easy History support for the new algorithms.
4f7d41ea 1378
1379@subsubsection occt_modalg_hist_draw DRAW history support
1380
14deaf42 1381DRAW History support for the algorithms is provided by three basic commands:
4f7d41ea 1382* *isdeleted*;
1383* *modified*;
1384* *generated*.
1385
07f2b741 1386For more information on the Draw History mechanism, refer to the corresponding chapter in the Draw users guide - @ref occt_draw_hist "History commands".
4f7d41ea 1387
1388
e2b55410 1389@section occt_modalg_3 Standard Topological Objects
72b7576f 1390
e2b55410 1391The following standard topological objects can be created:
14deaf42 1392 * Vertices;
1393 * Edges;
1394 * Faces;
1395 * Wires;
1396 * Polygonal wires;
1397 * Shells;
72b7576f 1398 * Solids.
1399
1400There are two root classes for their construction and modification:
1401* The deferred class *BRepBuilderAPI_MakeShape* is the root of all *BRepBuilderAPI* classes, which build shapes. It inherits from the class *BRepBuilderAPI_Command* and provides a field to store the constructed shape.
e2b55410 1402* The deferred class *BRepBuilderAPI_ModifyShape* is used as a root for the shape modifications. It inherits *BRepBuilderAPI_MakeShape* and implements the methods used to trace the history of all sub-shapes.
72b7576f 1403
2683e647 1404@subsection occt_modalg_3_1 Vertex
72b7576f 1405
1406*BRepBuilderAPI_MakeVertex* creates a new vertex from a 3D point from gp.
1407~~~~~
1408gp_Pnt P(0,0,10);
1409TopoDS_Vertex V = BRepBuilderAPI_MakeVertex(P);
1410~~~~~
1411
1412This class always creates a new vertex and has no other methods.
1413
e2b55410 1414@subsection occt_modalg_3_2 Edge
72b7576f 1415
e2b55410 1416@subsubsection occt_modalg_3_2_1 Basic edge construction method
72b7576f 1417
e2b55410 1418Use *BRepBuilderAPI_MakeEdge* to create from a curve and vertices. The basic method constructs an edge from a curve, two vertices, and two parameters.
72b7576f 1419
1420~~~~~
1421Handle(Geom_Curve) C = ...; // a curve
1422TopoDS_Vertex V1 = ...,V2 = ...;// two Vertices
1423Standard_Real p1 = ..., p2 = ..;// two parameters
1424TopoDS_Edge E = BRepBuilderAPI_MakeEdge(C,V1,V2,p1,p2);
1425~~~~~
1426
1427where C is the domain of the edge; V1 is the first vertex oriented FORWARD; V2 is the second vertex oriented REVERSED; p1 and p2 are the parameters for the vertices V1 and V2 on the curve. The default tolerance is associated with this edge.
1428
d6b4d3d0 1429@figure{/user_guides/modeling_algos/images/modeling_algos_image022.png,"Basic Edge Construction",220}
72b7576f 1430
1431The following rules apply to the arguments:
1432
1433**The curve**
1434 * Must not be a Null Handle.
1435 * If the curve is a trimmed curve, the basis curve is used.
1436
1437**The vertices**
1438 * Can be null shapes. When V1 or V2 is Null the edge is open in the corresponding direction and the corresponding parameter p1 or p2 must be infinite (i.e p1 is RealFirst(), p2 is RealLast()).
1439 * Must be different vertices if they have different 3d locations and identical vertices if they have the same 3d location (identical vertices are used when the curve is closed).
1440
1441**The parameters**
1442 * Must be increasing and in the range of the curve, i.e.:
e5bd0d98 1443
72b7576f 1444~~~~~
1445 C->FirstParameter() <= p1 < p2 <= C->LastParameter()
1446~~~~~
1447
e5bd0d98 1448 * If the parameters are decreasing, the Vertices are switched, i.e. V2 becomes V1 and V1 becomes V2.
1449 * On a periodic curve the parameters p1 and p2 are adjusted by adding or subtracting the period to obtain p1 in the range of the curve and p2 in the range p1 < p2 <= p1+ Period. So on a parametric curve p2 can be greater than the second parameter, see the figure below.
1450 * Can be infinite but the corresponding vertex must be Null (see above).
1451 * The distance between the Vertex 3d location and the point evaluated on the curve with the parameter must be lower than the default precision.
72b7576f 1452
1453The figure below illustrates two special cases, a semi-infinite edge and an edge on a periodic curve.
1454
d6b4d3d0 1455@figure{/user_guides/modeling_algos/images/modeling_algos_image023.png,"Infinite and Periodic Edges",220}
72b7576f 1456
e2b55410 1457@subsubsection occt_modalg_3_2_2 Supplementary edge construction methods
72b7576f 1458
e2b55410 1459There exist supplementary edge construction methods derived from the basic one.
dba69de2 1460
72b7576f 1461*BRepBuilderAPI_MakeEdge* class provides methods, which are all simplified calls of the previous one:
1462
1463 * The parameters can be omitted. They are computed by projecting the vertices on the curve.
1464 * 3d points (Pnt from gp) can be given in place of vertices. Vertices are created from the points. Giving vertices is useful when creating connected vertices.
1465 * The vertices or points can be omitted if the parameters are given. The points are computed by evaluating the parameters on the curve.
1466 * The vertices or points and the parameters can be omitted. The first and the last parameters of the curve are used.
1467
1468The five following methods are thus derived from the basic construction:
1469
1470~~~~~
1471Handle(Geom_Curve) C = ...; // a curve
1472TopoDS_Vertex V1 = ...,V2 = ...;// two Vertices
1473Standard_Real p1 = ..., p2 = ..;// two parameters
1474gp_Pnt P1 = ..., P2 = ...;// two points
1475TopoDS_Edge E;
1476// project the vertices on the curve
1477E = BRepBuilderAPI_MakeEdge(C,V1,V2);
1478// Make vertices from points
1479E = BRepBuilderAPI_MakeEdge(C,P1,P2,p1,p2);
1480// Make vertices from points and project them
1481E = BRepBuilderAPI_MakeEdge(C,P1,P2);
1482// Computes the points from the parameters
1483E = BRepBuilderAPI_MakeEdge(C,p1,p2);
1484// Make an edge from the whole curve
1485E = BRepBuilderAPI_MakeEdge(C);
1486~~~~~
1487
1488
1489Six methods (the five above and the basic method) are also provided for curves from the gp package in place of Curve from Geom. The methods create the corresponding Curve from Geom and are implemented for the following classes:
1490
dba69de2 1491*gp_Lin* creates a *Geom_Line*
1492*gp_Circ* creates a *Geom_Circle*
1493*gp_Elips* creates a *Geom_Ellipse*
1494*gp_Hypr* creates a *Geom_Hyperbola*
1495*gp_Parab* creates a *Geom_Parabola*
72b7576f 1496
1497There are also two methods to construct edges from two vertices or two points. These methods assume that the curve is a line; the vertices or points must have different locations.
1498
1499~~~~~
1500
1501TopoDS_Vertex V1 = ...,V2 = ...;// two Vertices
1502gp_Pnt P1 = ..., P2 = ...;// two points
1503TopoDS_Edge E;
1504
1505// linear edge from two vertices
1506E = BRepBuilderAPI_MakeEdge(V1,V2);
1507
1508// linear edge from two points
1509E = BRepBuilderAPI_MakeEdge(P1,P2);
1510~~~~~
1511
e2b55410 1512@subsubsection occt_modalg_3_2_3 Other information and error status
1513
1514The class *BRepBuilderAPI_MakeEdge* can provide extra information and return an error status.
dba69de2 1515
1516If *BRepBuilderAPI_MakeEdge* is used as a class, it can provide two vertices. This is useful when the vertices were not provided as arguments, for example when the edge was constructed from a curve and parameters. The two methods *Vertex1* and *Vertex2* return the vertices. Note that the returned vertices can be null if the edge is open in the corresponding direction.
72b7576f 1517
1518The *Error* method returns a term of the *BRepBuilderAPI_EdgeError* enumeration. It can be used to analyze the error when *IsDone* method returns False. The terms are:
1519
3f812249 1520 * **EdgeDone** -- No error occurred, *IsDone* returns True.
1521 * **PointProjectionFailed** -- No parameters were given, but the projection of the 3D points on the curve failed. This happens if the point distance to the curve is greater than the precision.
1522 * **ParameterOutOfRange** -- The given parameters are not in the range *C->FirstParameter()*, *C->LastParameter()*
1523 * **DifferentPointsOnClosedCurve** -- The two vertices or points have different locations but they are the extremities of a closed curve.
1524 * **PointWithInfiniteParameter** -- A finite coordinate point was associated with an infinite parameter (see the Precision package for a definition of infinite values).
1525 * **DifferentsPointAndParameter** -- The distance of the 3D point and the point evaluated on the curve with the parameter is greater than the precision.
1526 * **LineThroughIdenticPoints** -- Two identical points were given to define a line (construction of an edge without curve), *gp::Resolution* is used to test confusion .
72b7576f 1527
1528The following example creates a rectangle centered on the origin of dimensions H, L with fillets of radius R. The edges and the vertices are stored in the arrays *theEdges* and *theVertices*. We use class *Array1OfShape* (i.e. not arrays of edges or vertices). See the image below.
1529
d6b4d3d0 1530@figure{/user_guides/modeling_algos/images/modeling_algos_image024.png,"Creating a Wire",360}
72b7576f 1531
1532~~~~~
1533#include <BRepBuilderAPI_MakeEdge.hxx>
1534#include <TopoDS_Shape.hxx>
1535#include <gp_Circ.hxx>
1536#include <gp.hxx>
1537#include <TopoDS_Wire.hxx>
1538#include <TopTools_Array1OfShape.hxx>
1539#include <BRepBuilderAPI_MakeWire.hxx>
1540
1541// Use MakeArc method to make an edge and two vertices
1542void MakeArc(Standard_Real x,Standard_Real y,
1543Standard_Real R,
1544Standard_Real ang,
e5bd0d98 1545TopoDS_Shape& E,
1546TopoDS_Shape& V1,
1547TopoDS_Shape& V2)
72b7576f 1548{
1549gp_Ax2 Origin = gp::XOY();
1550gp_Vec Offset(x, y, 0.);
1551Origin.Translate(Offset);
1552BRepBuilderAPI_MakeEdge
1553ME(gp_Circ(Origin,R), ang, ang+PI/2);
1554E = ME;
1555V1 = ME.Vertex1();
1556V2 = ME.Vertex2();
1557}
1558
1559TopoDS_Wire MakeFilletedRectangle(const Standard_Real H,
1560const Standard_Real L,
1561const Standard_Real R)
1562{
1563TopTools_Array1OfShape theEdges(1,8);
1564TopTools_Array1OfShape theVertices(1,8);
1565
1566// First create the circular edges and the vertices
1567// using the MakeArc function described above.
1568void MakeArc(Standard_Real, Standard_Real,
1569Standard_Real, Standard_Real,
e5bd0d98 1570TopoDS_Shape&, TopoDS_Shape&, TopoDS_Shape&);
72b7576f 1571
1572Standard_Real x = L/2 - R, y = H/2 - R;
1573MakeArc(x,-y,R,3.*PI/2.,theEdges(2),theVertices(2),
1574theVertices(3));
1575MakeArc(x,y,R,0.,theEdges(4),theVertices(4),
1576theVertices(5));
1577MakeArc(-x,y,R,PI/2.,theEdges(6),theVertices(6),
1578theVertices(7));
1579MakeArc(-x,-y,R,PI,theEdges(8),theVertices(8),
1580theVertices(1));
1581// Create the linear edges
1582for (Standard_Integer i = 1; i <= 7; i += 2)
1583{
1584theEdges(i) = BRepBuilderAPI_MakeEdge
1585(TopoDS::Vertex(theVertices(i)),TopoDS::Vertex
1586(theVertices(i+1)));
1587}
1588// Create the wire using the BRepBuilderAPI_MakeWire
1589BRepBuilderAPI_MakeWire MW;
1590for (i = 1; i <= 8; i++)
1591{
1593}
1594return MW.Wire();
1595}
1596~~~~~
1597
e2b55410 1598@subsection occt_modalg_3_3 Edge 2D
72b7576f 1599
1600Use *BRepBuilderAPI_MakeEdge2d* class to make edges on a working plane from 2d curves. The working plane is a default value of the *BRepBuilderAPI* package (see the *Plane* methods).
1601
1602*BRepBuilderAPI_MakeEdge2d* class is strictly similar to BRepBuilderAPI_MakeEdge, but it uses 2D geometry from gp and Geom2d instead of 3D geometry.
1603
e2b55410 1604@subsection occt_modalg_3_4 Polygon
72b7576f 1605
1606*BRepBuilderAPI_MakePolygon* class is used to build polygonal wires from vertices or points. Points are automatically changed to vertices as in *BRepBuilderAPI_MakeEdge*.
1607
1608The basic usage of *BRepBuilderAPI_MakePolygon* is to create a wire by adding vertices or points using the Add method. At any moment, the current wire can be extracted. The close method can be used to close the current wire. In the following example, a closed wire is created from an array of points.
1609
1610~~~~~
1611#include <TopoDS_Wire.hxx>
1612#include <BRepBuilderAPI_MakePolygon.hxx>
1613#include <TColgp_Array1OfPnt.hxx>
1614
e5bd0d98 1615TopoDS_Wire ClosedPolygon(const TColgp_Array1OfPnt& Points)
72b7576f 1616{
1617BRepBuilderAPI_MakePolygon MP;
1618for(Standard_Integer i=Points.Lower();i=Points.Upper();i++)
1619{
1621}
1622MP.Close();
1623return MP;
1624}
1625~~~~~
1626
1627Short-cuts are provided for 2, 3, or 4 points or vertices. Those methods have a Boolean last argument to tell if the polygon is closed. The default value is False.
1628
1629Two examples:
1630
1631Example of a closed triangle from three vertices:
1632~~~~~
1633TopoDS_Wire W = BRepBuilderAPI_MakePolygon(V1,V2,V3,Standard_True);
1634~~~~~
1635
1636Example of an open polygon from four points:
1637~~~~~
1638TopoDS_Wire W = BRepBuilderAPI_MakePolygon(P1,P2,P3,P4);
1639~~~~~
1640
dba69de2 1641*BRepBuilderAPI_MakePolygon* class maintains a current wire. The current wire can be extracted at any moment and the construction can proceed to a longer wire. After each point insertion, the class maintains the last created edge and vertex, which are returned by the methods *Edge, FirstVertex* and *LastVertex*.
72b7576f 1642
dba69de2 1643When the added point or vertex has the same location as the previous one it is not added to the current wire but the most recently created edge becomes Null. The *Added* method can be used to test this condition. The *MakePolygon* class never raises an error. If no vertex has been added, the *Wire* is *Null*. If two vertices are at the same location, no edge is created.
72b7576f 1644
e2b55410 1645@subsection occt_modalg_3_5 Face
72b7576f 1646
1647Use *BRepBuilderAPI_MakeFace* class to create a face from a surface and wires. An underlying surface is constructed from a surface and optional parametric values. Wires can be added to the surface. A planar surface can be constructed from a wire. An error status can be returned after face construction.
1648
e2b55410 1649@subsubsection occt_modalg_3_5_1 Basic face construction method
72b7576f 1650
1651A face can be constructed from a surface and four parameters to determine a limitation of the UV space. The parameters are optional, if they are omitted the natural bounds of the surface are used. Up to four edges and vertices are created with a wire. No edge is created when the parameter is infinite.
1652
1653~~~~~
1654Handle(Geom_Surface) S = ...; // a surface
1655Standard_Real umin,umax,vmin,vmax; // parameters
1656TopoDS_Face F = BRepBuilderAPI_MakeFace(S,umin,umax,vmin,vmax);
1657~~~~~
1658
d6b4d3d0 1659@figure{/user_guides/modeling_algos/images/modeling_algos_image025.png,"Basic Face Construction",360}
72b7576f 1660
1661To make a face from the natural boundary of a surface, the parameters are not required:
1662
1663~~~~~
1664Handle(Geom_Surface) S = ...; // a surface
1665TopoDS_Face F = BRepBuilderAPI_MakeFace(S);
1666~~~~~
1667
1668Constraints on the parameters are similar to the constraints in *BRepBuilderAPI_MakeEdge*.
dba69de2 1669 * *umin,umax (vmin,vmax)* must be in the range of the surface and must be increasing.
1670 * On a *U (V)* periodic surface *umin* and *umax (vmin,vmax)* are adjusted.
1671 * *umin, umax, vmin, vmax* can be infinite. There will be no edge in the corresponding direction.
1672
e2b55410 1673@subsubsection occt_modalg_3_5_2 Supplementary face construction methods
72b7576f 1674
e2b55410 1675The two basic constructions (from a surface and from a surface and parameters) are implemented for all *gp* package surfaces, which are transformed in the corresponding Surface from Geom.
72b7576f 1676
e5bd0d98 1677| gp package surface | | Geom package surface |
dba69de2 1678| :------------------- | :----------- | :------------- |
1679| *gp_Pln* | | *Geom_Plane* |
1680| *gp_Cylinder* | | *Geom_CylindricalSurface* |
1681| *gp_Cone* | creates a | *Geom_ConicalSurface* |
1682| *gp_Sphere* | | *Geom_SphericalSurface* |
1683| *gp_Torus* | | *Geom_ToroidalSurface* |
72b7576f 1684
e2b55410 1685Once a face has been created, a wire can be added using the *Add* method. For example, the following code creates a cylindrical surface and adds a wire.
72b7576f 1686
1687~~~~~
1688gp_Cylinder C = ..; // a cylinder
1689TopoDS_Wire W = ...;// a wire
1690BRepBuilderAPI_MakeFace MF(C);
1692TopoDS_Face F = MF;
1693~~~~~
1694
dba69de2 1695More than one wire can be added to a face, provided that they do not cross each other and they define only one area on the surface. (Note that this is not checked). The edges on a Face must have a parametric curve description.
72b7576f 1696
1697If there is no parametric curve for an edge of the wire on the Face it is computed by projection.
1698
1699For one wire, a simple syntax is provided to construct the face from the surface and the wire. The above lines could be written:
1700
1701~~~~~
1702TopoDS_Face F = BRepBuilderAPI_MakeFace(C,W);
1703~~~~~
1704
1705A planar face can be created from only a wire, provided this wire defines a plane. For example, to create a planar face from a set of points you can use *BRepBuilderAPI_MakePolygon* and *BRepBuilderAPI_MakeFace*.
1706
1707~~~~~
1708#include <TopoDS_Face.hxx>
1709#include <TColgp_Array1OfPnt.hxx>
1710#include <BRepBuilderAPI_MakePolygon.hxx>
1711#include <BRepBuilderAPI_MakeFace.hxx>
1712
e5bd0d98 1713TopoDS_Face PolygonalFace(const TColgp_Array1OfPnt& thePnts)
72b7576f 1714{
1715BRepBuilderAPI_MakePolygon MP;
1716for(Standard_Integer i=thePnts.Lower();
1717i<=thePnts.Upper(); i++)
1718{
1720}
1721MP.Close();
1722TopoDS_Face F = BRepBuilderAPI_MakeFace(MP.Wire());
1723return F;
1724}
1725~~~~~
1726
e2b55410 1727The last use of *MakeFace* is to copy an existing face to add new wires. For example, the following code adds a new wire to a face:
72b7576f 1728
1729~~~~~
1730TopoDS_Face F = ...; // a face
1731TopoDS_Wire W = ...; // a wire
1732F = BRepBuilderAPI_MakeFace(F,W);
1733~~~~~
1734
e2b55410 1735To add more than one wire an instance of the *BRepBuilderAPI_MakeFace* class can be created with the face and the first wire and the new wires inserted with the *Add* method.
1736
1737@subsubsection occt_modalg_3_5_3 Error status
72b7576f 1738
e2b55410 1739The *Error* method returns an error status, which is a term from the *BRepBuilderAPI_FaceError* enumeration.
72b7576f 1740
3f812249 1741* *FaceDone* -- no error occurred.
1742* *NoFace* -- no initialization of the algorithm; an empty constructor was used.
1743* *NotPlanar* -- no surface was given and the wire was not planar.
1744* *CurveProjectionFailed* -- no curve was found in the parametric space of the surface for an edge.
1745* *ParametersOutOfRange* -- the parameters *umin, umax, vmin, vmax* are out of the surface.
72b7576f 1746
e2b55410 1747@subsection occt_modalg_3_6 Wire
72b7576f 1748The wire is a composite shape built not from a geometry, but by the assembly of edges. *BRepBuilderAPI_MakeWire* class can build a wire from one or more edges or connect new edges to an existing wire.
1749
1750Up to four edges can be used directly, for example:
1751
1752~~~~~
1753TopoDS_Wire W = BRepBuilderAPI_MakeWire(E1,E2,E3,E4);
1754~~~~~
1755
1756For a higher or unknown number of edges the Add method must be used; for example, to build a wire from an array of shapes (to be edges).
1757
1758~~~~~
1759TopTools_Array1OfShapes theEdges;
1760BRepBuilderAPI_MakeWire MW;
1761for (Standard_Integer i = theEdge.Lower();
1762i <= theEdges.Upper(); i++)
1764TopoDS_Wire W = MW;
1765~~~~~
1766
1767The class can be constructed with a wire. A wire can also be added. In this case, all the edges of the wires are added. For example to merge two wires:
1768
1769~~~~~
1770#include <TopoDS_Wire.hxx>
1771#include <BRepBuilderAPI_MakeWire.hxx>
1772
e5bd0d98 1773TopoDS_Wire MergeWires (const TopoDS_Wire& W1,
1774const TopoDS_Wire& W2)
72b7576f 1775{
1776BRepBuilderAPI_MakeWire MW(W1);
1778return MW;
1779}
1780~~~~~
1781
1782*BRepBuilderAPI_MakeWire* class connects the edges to the wire. When a new edge is added if one of its vertices is shared with the wire it is considered as connected to the wire. If there is no shared vertex, the algorithm searches for a vertex of the edge and a vertex of the wire, which are at the same location (the tolerances of the vertices are used to test if they have the same location). If such a pair of vertices is found, the edge is copied with the vertex of the wire in place of the original vertex. All the vertices of the edge can be exchanged for vertices from the wire. If no connection is found the wire is considered to be disconnected. This is an error.
1783
1784BRepBuilderAPI_MakeWire class can return the last edge added to the wire (Edge method). This edge can be different from the original edge if it was copied.
1785
1786The Error method returns a term of the *BRepBuilderAPI_WireError* enumeration:
3f812249 1787*WireDone* -- no error occurred.
1788*EmptyWire* -- no initialization of the algorithm, an empty constructor was used.
1789*DisconnectedWire* -- the last added edge was not connected to the wire.
1790*NonManifoldWire* -- the wire with some singularity.
72b7576f 1791
e2b55410 1792@subsection occt_modalg_3_7 Shell
72b7576f 1793The shell is a composite shape built not from a geometry, but by the assembly of faces.
1794Use *BRepBuilderAPI_MakeShell* class to build a Shell from a set of Faces. What may be important is that each face should have the required continuity. That is why an initial surface is broken up into faces.
1795
e2b55410 1796@subsection occt_modalg_3_8 Solid
72b7576f 1797The solid is a composite shape built not from a geometry, but by the assembly of shells. Use *BRepBuilderAPI_MakeSolid* class to build a Solid from a set of Shells. Its use is similar to the use of the MakeWire class: shells are added to the solid in the same way that edges are added to the wire in MakeWire.
1798
1799
e2b55410 1800@section occt_modalg_3b Object Modification
72b7576f 1801
e2b55410 1802@subsection occt_modalg_3b_1 Transformation
72b7576f 1803*BRepBuilderAPI_Transform* class can be used to apply a transformation to a shape (see class *gp_Trsf*). The methods have a boolean argument to copy or share the original shape, as long as the transformation allows (it is only possible for direct isometric transformations). By default, the original shape is shared.
1804
1805The following example deals with the rotation of shapes.
1806
1807~~~~~
1808
1809TopoDS_Shape myShape1 = ...;
1810// The original shape 1
1811TopoDS_Shape myShape2 = ...;
1812// The original shape2
1813gp_Trsf T;
1814T.SetRotation(gp_Ax1(gp_Pnt(0.,0.,0.),gp_Vec(0.,0.,1.)),
18152.*PI/5.);
1816BRepBuilderAPI_Transformation theTrsf(T);
1817theTrsf.Perform(myShape1);
1818TopoDS_Shape myNewShape1 = theTrsf.Shape()
1819theTrsf.Perform(myShape2,Standard_True);
1820// Here duplication is forced
1821TopoDS_Shape myNewShape2 = theTrsf.Shape()
1822~~~~~
1823
e2b55410 1824@subsection occt_modalg_3b_2 Duplication
72b7576f 1825
dba69de2 1826Use the *BRepBuilderAPI_Copy* class to duplicate a shape. A new shape is thus created.
72b7576f 1827In the following example, a solid is copied:
1828
1829~~~~~
1830TopoDS Solid MySolid;
1831....// Creates a solid
1832
1833TopoDS_Solid myCopy = BRepBuilderAPI_Copy(mySolid);
1834~~~~~
1835
e2b55410 1836
1837@section occt_modalg_4 Primitives
1838
1839The <i> BRepPrimAPI</i> package provides an API (Application Programming Interface) for construction of primitives such as:
1840 * Boxes;
1841 * Cones;
1842 * Cylinders;
1843 * Prisms.
1844
1845It is possible to create partial solids, such as a sphere limited by longitude. In real models, primitives can be used for easy creation of specific sub-parts.
1846
1847 * Construction by sweeping along a profile:
1848 * Linear;
1849 * Rotational (through an angle of rotation).
1850
1851Sweeps are objects obtained by sweeping a profile along a path. The profile can be any topology and the path is usually a curve or a wire. The profile generates objects according to the following rules:
1852 * Vertices generate Edges
1853 * Edges generate Faces.
1854 * Wires generate Shells.
1855 * Faces generate Solids.
1856 * Shells generate Composite Solids.
1857
1858It is not allowed to sweep Solids and Composite Solids. Swept constructions along complex profiles such as BSpline curves also available in the <i> BRepOffsetAPI </i> package. This API provides simple, high level calls for the most common operations.
1859
72b7576f 1860@subsection occt_modalg_4_1 Making Primitives
1861@subsubsection occt_modalg_4_1_1 Box
1862
e2b55410 1863The class *BRepPrimAPI_MakeBox* allows building a parallelepiped box. The result is either a **Shell** or a **Solid**. There are four ways to build a box:
72b7576f 1864
e2b55410 1865* From three dimensions *dx, dy* and *dz*. The box is parallel to the axes and extends for <i>[0,dx] [0,dy] [0,dz] </i>.
72b7576f 1866* From a point and three dimensions. The same as above but the point is the new origin.
1867* From two points, the box is parallel to the axes and extends on the intervals defined by the coordinates of the two points.
e2b55410 1868* From a system of axes *gp_Ax2* and three dimensions. Same as the first way but the box is parallel to the given system of axes.
72b7576f 1869
1870An error is raised if the box is flat in any dimension using the default precision. The following code shows how to create a box:
1871~~~~~
1872TopoDS_Solid theBox = BRepPrimAPI_MakeBox(10.,20.,30.);
1873~~~~~
1874
1875The four methods to build a box are shown in the figure:
1876
d6b4d3d0 1877@figure{/user_guides/modeling_algos/images/modeling_algos_image026.png,"Making Boxes",420}
72b7576f 1878
1879@subsubsection occt_modalg_4_1_2 Wedge
dba69de2 1880*BRepPrimAPI_MakeWedge* class allows building a wedge, which is a slanted box, i.e. a box with angles. The wedge is constructed in much the same way as a box i.e. from three dimensions dx,dy,dz plus arguments or from an axis system, three dimensions, and arguments.
72b7576f 1881
e2b55410 1882The following figure shows two ways to build wedges. One is to add a dimension *ltx*, which is the length in *x* of the face at *dy*. The second is to add *xmin, xmax, zmin* and *zmax* to describe the face at *dy*.
72b7576f 1883
e2b55410 1884The first method is a particular case of the second with *xmin = 0, xmax = ltx, zmin = 0, zmax = dz*.
1885To make a centered pyramid you can use *xmin = xmax = dx / 2, zmin = zmax = dz / 2*.
72b7576f 1886
d6b4d3d0 1887@figure{/user_guides/modeling_algos/images/modeling_algos_image027.png,"Making Wedges",420}
72b7576f 1888
1889@subsubsection occt_modalg_4_1_3 Rotation object
dba69de2 1890*BRepPrimAPI_MakeOneAxis* is a deferred class used as a root class for all classes constructing rotational primitives. Rotational primitives are created by rotating a curve around an axis. They cover the cylinder, the cone, the sphere, the torus, and the revolution, which provides all other curves.
72b7576f 1891
1892The particular constructions of these primitives are described, but they all have some common arguments, which are:
1893
1894 * A system of coordinates, where the Z axis is the rotation axis..
1895 * An angle in the range [0,2*PI].
1896 * A vmin, vmax parameter range on the curve.
1897
1898The result of the OneAxis construction is a Solid, a Shell, or a Face. The face is the face covering the rotational surface. Remember that you will not use the OneAxis directly but one of the derived classes, which provide improved constructions. The following figure illustrates the OneAxis arguments.
1899
d6b4d3d0 1900@figure{/user_guides/modeling_algos/images/modeling_algos_image028.png,"MakeOneAxis arguments",360}
72b7576f 1901
1902@subsubsection occt_modalg_4_1_4 Cylinder
e2b55410 1903*BRepPrimAPI_MakeCylinder* class allows creating cylindrical primitives. A cylinder is created either in the default coordinate system or in a given coordinate system *gp_Ax2*. There are two constructions:
72b7576f 1904
1905 * Radius and height, to build a full cylinder.
1906 * Radius, height and angle to build a portion of a cylinder.
1907
e2b55410 1908The following code builds the cylindrical face of the figure, which is a quarter of cylinder along the *Y* axis with the origin at *X,Y,Z* the length of *DY* and radius *R*.
72b7576f 1909
1910~~~~~
1911
1912Standard_Real X = 20, Y = 10, Z = 15, R = 10, DY = 30;
1913// Make the system of coordinates
1914gp_Ax2 axes = gp::ZOX();
1915axes.Translate(gp_Vec(X,Y,Z));
1916TopoDS_Face F =
1917BRepPrimAPI_MakeCylinder(axes,R,DY,PI/2.);
1918~~~~~
d6b4d3d0 1919@figure{/user_guides/modeling_algos/images/modeling_algos_image029.png,"Cylinder",360}
72b7576f 1920
1921@subsubsection occt_modalg_4_1_5 Cone
dba69de2 1922*BRepPrimAPI_MakeCone* class allows creating conical primitives. Like a cylinder, a cone is created either in the default coordinate system or in a given coordinate system (gp_Ax2). There are two constructions:
72b7576f 1923
1924 * Two radii and height, to build a full cone. One of the radii can be null to make a sharp cone.
1925 * Radii, height and angle to build a truncated cone.
1926
e2b55410 1927The following code builds the solid cone of the figure, which is located in the default system with radii *R1* and *R2* and height *H*.
72b7576f 1928
1929~~~~~
1930Standard_Real R1 = 30, R2 = 10, H = 15;
1931TopoDS_Solid S = BRepPrimAPI_MakeCone(R1,R2,H);
1932~~~~~
1933
d6b4d3d0 1934@figure{/user_guides/modeling_algos/images/modeling_algos_image030.png,"Cone",360}
72b7576f 1935
1936@subsubsection occt_modalg_4_1_6 Sphere
e2b55410 1937*BRepPrimAPI_MakeSphere* class allows creating spherical primitives. Like a cylinder, a sphere is created either in the default coordinate system or in a given coordinate system *gp_Ax2*. There are four constructions:
72b7576f 1938
3f812249 1939 * From a radius -- builds a full sphere.
1940 * From a radius and an angle -- builds a lune (digon).
1941 * From a radius and two angles -- builds a wraparound spherical segment between two latitudes. The angles *a1* and *a2* must follow the relation: <i>PI/2 <= a1 < a2 <= PI/2 </i>.
1942 * From a radius and three angles -- a combination of two previous methods builds a portion of spherical segment.
72b7576f 1943
1944The following code builds four spheres from a radius and three angles.
1945
1946~~~~~
1947Standard_Real R = 30, ang =
1948 PI/2, a1 = -PI/2.3, a2 = PI/4;
1949TopoDS_Solid S1 = BRepPrimAPI_MakeSphere(R);
1950TopoDS_Solid S2 = BRepPrimAPI_MakeSphere(R,ang);
1951TopoDS_Solid S3 = BRepPrimAPI_MakeSphere(R,a1,a2);
1952TopoDS_Solid S4 = BRepPrimAPI_MakeSphere(R,a1,a2,ang);
1953~~~~~
1954
1955Note that we could equally well choose to create Shells instead of Solids.
1956
d6b4d3d0 1957@figure{/user_guides/modeling_algos/images/modeling_algos_image031.png,"Examples of Spheres",420}
72b7576f 1958
1959
1960@subsubsection occt_modalg_4_1_7 Torus
e2b55410 1961*BRepPrimAPI_MakeTorus* class allows creating toroidal primitives. Like the other primitives, a torus is created either in the default coordinate system or in a given coordinate system *gp_Ax2*. There are four constructions similar to the sphere constructions:
72b7576f 1962
3f812249 1963 * Two radii -- builds a full torus.
1964 * Two radii and an angle -- builds an angular torus segment.
1965 * Two radii and two angles -- builds a wraparound torus segment between two radial planes. The angles a1, a2 must follow the relation 0 < a2 - a1 < 2*PI.
1966 * Two radii and three angles -- a combination of two previous methods builds a portion of torus segment.
72b7576f 1967
d6b4d3d0 1968@figure{/user_guides/modeling_algos/images/modeling_algos_image032.png,"Examples of Tori",420}
72b7576f 1969
1970The following code builds four toroidal shells from two radii and three angles.
1971
1972~~~~~
1973Standard_Real R1 = 30, R2 = 10, ang = PI, a1 = 0,
1974 a2 = PI/2;
1975TopoDS_Shell S1 = BRepPrimAPI_MakeTorus(R1,R2);
1976TopoDS_Shell S2 = BRepPrimAPI_MakeTorus(R1,R2,ang);
1977TopoDS_Shell S3 = BRepPrimAPI_MakeTorus(R1,R2,a1,a2);
1978TopoDS_Shell S4 =
1979 BRepPrimAPI_MakeTorus(R1,R2,a1,a2,ang);
1980~~~~~
1981
1982Note that we could equally well choose to create Solids instead of Shells.
1983
1984@subsubsection occt_modalg_4_1_8 Revolution
dba69de2 1985*BRepPrimAPI_MakeRevolution* class allows building a uniaxial primitive from a curve. As other uniaxial primitives it can be created in the default coordinate system or in a given coordinate system.
72b7576f 1986
1987The curve can be any *Geom_Curve*, provided it is planar and lies in the same plane as the Z-axis of local coordinate system. There are four modes of construction:
1988
1989 * From a curve, use the full curve and make a full rotation.
1990 * From a curve and an angle of rotation.
1991 * From a curve and two parameters to trim the curve. The two parameters must be growing and within the curve range.
1992 * From a curve, two parameters, and an angle. The two parameters must be growing and within the curve range.
1993
1994
1995@subsection occt_modalg_4_2 Sweeping: Prism, Revolution and Pipe
1996@subsubsection occt_modalg_4_2_1 Sweeping
1997
1998Sweeps are the objects you obtain by sweeping a **profile** along a **path**. The profile can be of any topology. The path is usually a curve or a wire. The profile generates objects according to the following rules:
1999
2000 * Vertices generate Edges
2001 * Edges generate Faces.
2002 * Wires generate Shells.
2003 * Faces generate Solids.
2004 * Shells generate Composite Solids
2005
2006It is forbidden to sweep Solids and Composite Solids. A Compound generates a Compound with the sweep of all its elements.
2007
d6b4d3d0 2008@figure{/user_guides/modeling_algos/images/modeling_algos_image033.png,"Generating a sweep",360}
72b7576f 2009
2010*BRepPrimAPI_MakeSweep class* is a deferred class used as a root of the the following sweep classes:
3f812249 2011* *BRepPrimAPI_MakePrism* -- produces a linear sweep
2012* *BRepPrimAPI_MakeRevol* -- produces a rotational sweep
2013* *BRepPrimAPI_MakePipe* -- produces a general sweep.
72b7576f 2014
2015
2016@subsubsection occt_modalg_4_2_2 Prism
dba69de2 2017*BRepPrimAPI_MakePrism* class allows creating a linear **prism** from a shape and a vector or a direction.
72b7576f 2018* A vector allows creating a finite prism;
2019* A direction allows creating an infinite or semi-infinite prism. The semi-infinite or infinite prism is toggled by a Boolean argument. All constructors have a boolean argument to copy the original shape or share it (by default).
dba69de2 2020
e5bd0d98 2021The following code creates a finite, an infinite and a semi-infinite solid using a face, a direction and a length.
2022
72b7576f 2023~~~~~
2024TopoDS_Face F = ..; // The swept face
2025gp_Dir direc(0,0,1);
2026Standard_Real l = 10;
2027// create a vector from the direction and the length
2028gp_Vec v = direc;
2029v *= l;
2030TopoDS_Solid P1 = BRepPrimAPI_MakePrism(F,v);
2031// finite
2032TopoDS_Solid P2 = BRepPrimAPI_MakePrism(F,direc);
2033// infinite
2034TopoDS_Solid P3 = BRepPrimAPI_MakePrism(F,direc,Standard_False);
2035// semi-infinite
2036~~~~~
2037
d6b4d3d0 2038@figure{/user_guides/modeling_algos/images/modeling_algos_image034.png,"Finite, infinite, and semi-infinite prisms",420}
72b7576f 2039
e2b55410 2040@subsubsection occt_modalg_4_2_3 Rotational Sweep
dba69de2 2041*BRepPrimAPI_MakeRevol* class allows creating a rotational sweep from a shape, an axis (gp_Ax1), and an angle. The angle has a default value of 2*PI which means a closed revolution.
72b7576f 2042
dba69de2 2043*BRepPrimAPI_MakeRevol* constructors have a last argument to copy or share the original shape. The following code creates a a full and a partial rotation using a face, an axis and an angle.
72b7576f 2044
2045~~~~~
2046TopoDS_Face F = ...; // the profile
2047gp_Ax1 axis(gp_Pnt(0,0,0),gp_Dir(0,0,1));
2048Standard_Real ang = PI/3;
2049TopoDS_Solid R1 = BRepPrimAPI_MakeRevol(F,axis);
2050// Full revol
2051TopoDS_Solid R2 = BRepPrimAPI_MakeRevol(F,axis,ang);
2052~~~~~
2053
d6b4d3d0 2054@figure{/user_guides/modeling_algos/images/modeling_algos_image035.png,"Full and partial rotation",420}
72b7576f 2055
2056@section occt_modalg_5 Boolean Operations
2057
948fe6ca 2058Boolean operations are used to create new shapes from the combinations of two groups of shapes.
dba69de2 2059
e5bd0d98 2060| Operation | Result |
2061| :---- | :------ |
dba69de2 2062| Fuse | all points in S1 or S2 |
2063| Common | all points in S1 and S2 |
2064| Cut S1 by S2| all points in S1 and not in S2 |
72b7576f 2065
d6b4d3d0 2066@figure{/user_guides/modeling_algos/images/modeling_algos_image036.png,"Boolean Operations",420}
72b7576f 2067
e2b55410 2068From the viewpoint of Topology these are topological operations followed by blending (putting fillets onto edges created after the topological operation).
2069
2070Topological operations are the most convenient way to create real industrial parts. As most industrial parts consist of several simple elements such as gear wheels, arms, holes, ribs, tubes and pipes. It is usually easy to create those elements separately and then to combine them by Boolean operations in the whole final part.
2071
2072See @ref occt_user_guides__boolean_operations "Boolean Operations" for detailed documentation.
2073
2074@subsection occt_modalg_5_1 Input and Result Arguments
2075
2076Boolean Operations have the following types of the arguments and produce the following results:
2077* For arguments having the same shape type (e.g. SOLID / SOLID) the type of the resulting shape will be a COMPOUND, containing shapes of this type;
2078* For arguments having different shape types (e.g. SHELL / SOLID) the type of the resulting shape will be a COMPOUND, containing shapes of the type that is the same as that of the low type of the argument. Example: For SHELL/SOLID the result is a COMPOUND of SHELLs.
2079* For arguments with different shape types some of Boolean Operations can not be done using the default implementation, because of a non-manifold type of the result. Example: the FUSE operation for SHELL and SOLID can not be done, but the CUT operation can be done, where SHELL is the object and SOLID is the tool.
2080* It is possible to perform Boolean Operations on arguments of the COMPOUND shape type. In this case each compound must not be heterogeneous, i.e. it must contain equidimensional shapes (EDGEs or/and WIREs, FACEs or/and SHELLs, SOLIDs). SOLIDs inside the COMPOUND must not contact (intersect or touch) each other. The same condition should be respected for SHELLs or FACEs, WIREs or EDGEs.
2081* Boolean Operations for COMPSOLID type of shape are not supported.
2082
2083@subsection occt_modalg_5_2 Implementation
2084
2085*BRepAlgoAPI_BooleanOperation* class is the deferred root class for Boolean operations.
2086
2087#### Fuse
72b7576f 2088
dba69de2 2089*BRepAlgoAPI_Fuse* performs the Fuse operation.
e5bd0d98 2090
72b7576f 2091~~~~~
2092TopoDS_Shape A = ..., B = ...;
2093TopoDS_Shape S = BRepAlgoAPI_Fuse(A,B);
2094~~~~~
2095
e2b55410 2096#### Common
e5bd0d98 2097
dba69de2 2098*BRepAlgoAPI_Common* performs the Common operation.
72b7576f 2099
2100~~~~~
2101TopoDS_Shape A = ..., B = ...;
2102TopoDS_Shape S = BRepAlgoAPI_Common(A,B);
2103~~~~~
2104
e2b55410 2105#### Cut
dba69de2 2106*BRepAlgoAPI_Cut* performs the Cut operation.
72b7576f 2107
2108~~~~~
2109TopoDS_Shape A = ..., B = ...;
2110TopoDS_Shape S = BRepAlgoAPI_Cut(A,B);
2111~~~~~
2112
e2b55410 2113#### Section
72b7576f 2114
dba69de2 2115*BRepAlgoAPI_Section* performs the section, described as a *TopoDS_Compound* made of *TopoDS_Edge*.
72b7576f 2116
d6b4d3d0 2117@figure{/user_guides/modeling_algos/images/modeling_algos_image037.png,"Section operation",220}
72b7576f 2118
2119~~~~~
2120TopoDS_Shape A = ..., TopoDS_ShapeB = ...;
2121TopoDS_Shape S = BRepAlgoAPI_Section(A,B);
2122~~~~~
2123
2124@section occt_modalg_6 Fillets and Chamfers
e2b55410 2125
2126This library provides algorithms to make fillets and chamfers on shape edges.
2128
2129 * Corners and apexes with different radii;
2130 * Corners and apexes with different concavity.
2131
2132If there is a concavity, both surfaces that need to be extended and those, which do not, are processed.
2133
72b7576f 2134@subsection occt_modalg_6_1 Fillets
2135@subsection occt_modalg_6_1_1 Fillet on shape
2136
2137A fillet is a smooth face replacing a sharp edge.
2138
2139*BRepFilletAPI_MakeFillet* class allows filleting a shape.
2140
2141To produce a fillet, it is necessary to define the filleted shape at the construction of the class and add fillet descriptions using the *Add* method.
72b7576f 2142
dba69de2 2143A fillet description contains an edge and a radius. The edge must be shared by two faces. The fillet is automatically extended to all edges in a smooth continuity with the original edge. It is not an error to add a fillet twice, the last description holds.
2144
d6b4d3d0 2145@figure{/user_guides/modeling_algos/images/modeling_algos_image038.png,"Filleting two edges using radii r1 and r2.",360}
72b7576f 2146
2147In the following example a filleted box with dimensions a,b,c and radius r is created.
2148
2150
72b7576f 2151
2152~~~~~
2153#include <TopoDS_Shape.hxx>
2154#include <TopoDS.hxx>
2155#include <BRepPrimAPI_MakeBox.hxx>
2156#include <TopoDS_Solid.hxx>
2157#include <BRepFilletAPI_MakeFillet.hxx>
2158#include <TopExp_Explorer.hxx>
2159
2160TopoDS_Shape FilletedBox(const Standard_Real a,
2161 const Standard_Real b,
2162 const Standard_Real c,
2163 const Standard_Real r)
2164{
2165 TopoDS_Solid Box = BRepPrimAPI_MakeBox(a,b,c);
2166 BRepFilletAPI_MakeFillet MF(Box);
2167
2168 // add all the edges to fillet
2169 TopExp_Explorer ex(Box,TopAbs_EDGE);
2170 while (ex.More())
2171 {
2173 ex.Next();
2174 }
2175 return MF.Shape();
2176 }
2177~~~~~
2178
dba69de2 2180
72b7576f 2182
72b7576f 2183
2184~~~~~
2185void CSampleTopologicalOperationsDoc::OnEvolvedblend1()
2186{
2187 TopoDS_Shape theBox = BRepPrimAPI_MakeBox(200,200,200);
2188
2189 BRepFilletAPI_MakeFillet Rake(theBox);
2190 ChFi3d_FilletShape FSh = ChFi3d_Rational;
2191 Rake.SetFilletShape(FSh);
2192
2200
2201 TopExp_Explorer ex(theBox,TopAbs_EDGE);
2203 TopoDS_Shape evolvedBox = Rake.Shape();
2204}
2205~~~~~
2206
72b7576f 2208
2209@subsection occt_modalg_6_1_2 Chamfer
2210
2211A chamfer is a rectilinear edge replacing a sharp vertex of the face.
2212
2213The use of *BRepFilletAPI_MakeChamfer* class is similar to the use of *BRepFilletAPI_MakeFillet*, except for the following:
dba69de2 2214* The surfaces created are ruled and not smooth.
2215* The *Add* syntax for selecting edges requires one or two distances, one edge and one face (contiguous to the edge).
72b7576f 2216
2217~~~~~
2219Add(d1, d2, E, F) with d1 on the face F.
2220~~~~~
2221
d6b4d3d0 2222@figure{/user_guides/modeling_algos/images/modeling_algos_image041.png,"Chamfer",360}
72b7576f 2223
2224@subsection occt_modalg_6_1_3 Fillet on a planar face
2225
dba69de2 2226*BRepFilletAPI_MakeFillet2d* class allows constructing fillets and chamfers on planar faces.
72b7576f 2227To create a fillet on planar face: define it, indicate, which vertex is to be deleted, and give the fillet radius with *AddFillet* method.
dba69de2 2228
72b7576f 2229A chamfer can be calculated with *AddChamfer* method. It can be described by
2230 * two edges and two distances
2231 * one edge, one vertex, one distance and one angle.
2232Fillets and chamfers are calculated when addition is complete.
2233
2234If face F2 is created by 2D fillet and chamfer builder from face F1, the builder can be rebuilt (the builder recovers the status it had before deletion). To do so, use the following syntax:
2235~~~~~
2236BRepFilletAPI_MakeFillet2d builder;
2237builder.Init(F1,F2);
2238~~~~~
2239
2240Planar Fillet
2241-------------
2242
2243~~~~~
2244#include “BRepPrimAPI_MakeBox.hxx”
2245#include “TopoDS_Shape.hxx”
2246#include “TopExp_Explorer.hxx”
2247#include “BRepFilletAPI_MakeFillet2d.hxx”
2248#include “TopoDS.hxx”
2249#include “TopoDS_Solid.hxx”
2250
2251TopoDS_Shape FilletFace(const Standard_Real a,
2252 const Standard_Real b,
2253 const Standard_Real c,
2254 const Standard_Real r)
2255
2256{
2257 TopoDS_Solid Box = BRepPrimAPI_MakeBox (a,b,c);
2258 TopExp_Explorer ex1(Box,TopAbs_FACE);
2259
e5bd0d98 2260 const TopoDS_Face& F = TopoDS::Face(ex1.Current());
72b7576f 2261 BRepFilletAPI_MakeFillet2d MF(F);
2262 TopExp_Explorer ex2(F, TopAbs_VERTEX);
2263 while (ex2.More())
2264 {
2266 ex2.Next();
2267 }
2268 // while...
2269 return MF.Shape();
2270}
2271~~~~~
2272
2273@section occt_modalg_7 Offsets, Drafts, Pipes and Evolved shapes
e2b55410 2274
2275These classes provide the following services:
2276
2277 * Creation of offset shapes and their variants such as:
2278 * Hollowing;
2279 * Shelling;
2280 * Lofting;
2281 * Creation of tapered shapes using draft angles;
2282 * Creation of sweeps.
2283
8013367c 2284@subsection occt_modalg_7_1 Offset computation
2285
2286Offset computation can be performed using *BRepOffsetAPI_MakeOffsetShape*. This class provides API to the two different offset algorithms:
2287
2288Offset algorithm based on computation of the analytical continuation. Meaning of the parameters can be found in *BRepOffsetAPI_MakeOffsetShape::PerformByJoin* method description. The list below demonstrates principal scheme of this algorithm:
2289
2290* At the first step, the offsets are computed.
2291* After this, the analytical continuations are computed for each offset.
2292* Pairwise intersection is computed according to the original topological information (sharing, number of neighbors, etc.).
2293* The offset shape is assembled.
2294
2295The second algorithm is based on the fact that the offset computation for a single face without continuation can always be built. The list below shows simple offset algorithm:
2296* Each surface is mapped to its geometric offset surface.
2297* For each edge, pcurves are mapped to the same pcurves on offset surfaces.
2298* For each edge, 3d curve is constructed by re-approximation of pcurve on the first offset face.
2299* Position of each vertex in a result shell is computed as average point of all ends of edges sharing that vertex.
2300* Tolerances are updated according to the resulting geometry.
2301The possible drawback of the simple algorithm is that it leads, in general case, to tolerance increasing. The tolerances have to grow in order to cover the gaps between the neighbor faces in the output. It should be noted that the actual tolerance growth depends on the offset distance and the quality of joints between the input faces. Anyway the good input shell (smooth connections between adjacent faces) will lead to good result.
2302
2303The snippets below show usage examples:
2304~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
2305 BRepOffsetAPI_MakeOffsetShape OffsetMaker1;
2306 // Computes offset shape using analytical continuation mechanism.
2307 OffsetMaker1.PerformByJoin(Shape, OffsetValue, Tolerance);
2308 if (OffsetMaker1.IsDone())
2309 NewShape = OffsetMaker1.Shape();
2310
2311 BRepOffsetAPI_MakeOffsetShape OffsetMaker2;
2312 // Computes offset shape using simple algorithm.
2313 OffsetMaker2.PerformBySimple(Shape, OffsetValue);
2314 if (OffsetMaker2.IsDone())
2315 NewShape = OffsetMaker2.Shape();
2316~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
72b7576f 2317
8013367c 2318@subsection occt_modalg_7_2 Shelling
72b7576f 2319
8013367c 2320Shelling is used to offset given faces of a solid by a specific value. It rounds or intersects adjacent faces along its edges depending on the convexity of the edge.
2321The MakeThickSolidByJoin method of the *BRepOffsetAPI_MakeThickSolid* takes the solid, the list of faces to remove and an offset value as input.
72b7576f 2322
2323~~~~~
2324TopoDS_Solid SolidInitial = ...;
2325
2326Standard_Real Of = ...;
2327TopTools_ListOfShape LCF;
2328TopoDS_Shape Result;
2329Standard_Real Tol = Precision::Confusion();
2330
2331for (Standard_Integer i = 1 ;i <= n; i++) {
2332 TopoDS_Face SF = ...; // a face from SolidInitial
2333 LCF.Append(SF);
2334}
2335
8013367c 2336BRepOffsetAPI_MakeThickSolid SolidMaker;
2337SolidMaker.MakeThickSolidByJoin(SolidInitial,
2338 LCF,
2339 Of,
2340 Tol);
2341if (SolidMaker.IsDone())
2342 Result = SolidMaker.Shape();
72b7576f 2343~~~~~
2344
d6b4d3d0 2345@figure{/user_guides/modeling_algos/images/modeling_algos_image042.png,"Shelling",420}
72b7576f 2346
8013367c 2347Also it is possible to create solid between shell, offset shell. This functionality can be called using *BRepOffsetAPI_MakeThickSolid::MakeThickSolidBySimple* method. The code below shows usage example:
2348
2349~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
2350 BRepOffsetAPI_MakeThickSolid SolidMaker;
2351 SolidMaker.MakeThickSolidBySimple(Shell, OffsetValue);
2352 if (myDone.IsDone())
2353 Solid = SolidMaker.Shape();
2354~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
72b7576f 2355
8013367c 2356@subsection occt_modalg_7_3 Draft Angle
72b7576f 2357
2358*BRepOffsetAPI_DraftAngle* class allows modifying a shape by applying draft angles to its planar, cylindrical and conical faces.
72b7576f 2359
dba69de2 2360
2361The class is created or initialized from a shape, then faces to be modified are added; for each face, three arguments are used:
72b7576f 2362 * Direction: the direction with which the draft angle is measured
2363 * Angle: value of the angle
2364 * Neutral plane: intersection between the face and the neutral plane is invariant.
2365
2366The following code places a draft angle on several faces of a shape; the same direction, angle and neutral plane are used for each face:
2367
2368~~~~~
2369TopoDS_Shape myShape = ...
2370// The original shape
2371TopTools_ListOfShape ListOfFace;
2372// Creation of the list of faces to be modified
2373...
2374
2375gp_Dir Direc(0.,0.,1.);
2376// Z direction
2377Standard_Real Angle = 5.*PI/180.;
2378// 5 degree angle
2379gp_Pln Neutral(gp_Pnt(0.,0.,5.), Direc);
2380// Neutral plane Z=5
2381BRepOffsetAPI_DraftAngle theDraft(myShape);
2382TopTools_ListIteratorOfListOfShape itl;
2383for (itl.Initialize(ListOfFace); itl.More(); itl.Next()) {
2386 // An error has occurred. The faulty face is given by // ProblematicShape
2387 break;
2388 }
2389}
2391 // An error has occurred
2392 TopoDS_Face guilty = theDraft.ProblematicShape();
2393 ...
2394}
2395theDraft.Build();
2396if (!theDraft.IsDone()) {
2397 // Problem encountered during reconstruction
2398 ...
2399}
2400else {
2401 TopoDS_Shape myResult = theDraft.Shape();
2402 ...
2403}
2404~~~~~
2405
d6b4d3d0 2406@figure{/user_guides/modeling_algos/images/modeling_algos_image043.png,"DraftAngle",420}
72b7576f 2407
8013367c 2408@subsection occt_modalg_7_4 Pipe Constructor
72b7576f 2409
2410*BRepOffsetAPI_MakePipe* class allows creating a pipe from a Spine, which is a Wire and a Profile which is a Shape. This implementation is limited to spines with smooth transitions, sharp transitions are precessed by *BRepOffsetAPI_MakePipeShell*. To be more precise the continuity must be G1, which means that the tangent must have the same direction, though not necessarily the same magnitude, at neighboring edges.
dba69de2 2411
72b7576f 2412The angle between the spine and the profile is preserved throughout the pipe.
2413
2414~~~~~
2415TopoDS_Wire Spine = ...;
2416TopoDS_Shape Profile = ...;
2417TopoDS_Shape Pipe = BRepOffsetAPI_MakePipe(Spine,Profile);
2418~~~~~
2419
d6b4d3d0 2420@figure{/user_guides/modeling_algos/images/modeling_algos_image044.png,"Example of a Pipe",320}
72b7576f 2421
8013367c 2422@subsection occt_modalg_7_5 Evolved Solid
72b7576f 2423
2424*BRepOffsetAPI_MakeEvolved* class allows creating an evolved solid from a Spine (planar face or wire) and a profile (wire).
dba69de2 2425
72b7576f 2426The evolved solid is an unlooped sweep generated by the spine and the profile.
dba69de2 2427
72b7576f 2428The evolved solid is created by sweeping the profile’s reference axes on the spine. The origin of the axes moves to the spine, the X axis and the local tangent coincide and the Z axis is normal to the face.
2429
2430The reference axes of the profile can be defined following two distinct modes:
2431
2432* The reference axes of the profile are the origin axes.
2433* The references axes of the profile are calculated as follows:
2434 + the origin is given by the point on the spine which is the closest to the profile
2435 + the X axis is given by the tangent to the spine at the point defined above
2436 + the Z axis is the normal to the plane which contains the spine.
2437
2438~~~~~
2439TopoDS_Face Spine = ...;
2440TopoDS_Wire Profile = ...;
2441TopoDS_Shape Evol =
2442BRepOffsetAPI_MakeEvolved(Spine,Profile);
2443~~~~~
2444
e2b55410 2445@section occt_modalg_8 Sewing
2446
2447@subsection occt_modalg_8_1 Introduction
72b7576f 2448
e2b55410 2449Sewing allows creation of connected topology (shells and wires) from a set of separate topological elements (faces and edges). For example, Sewing can be used to create of shell from a compound of separate faces.
72b7576f 2450
d6b4d3d0 2451@figure{/user_guides/modeling_algos/images/modeling_algos_image045.png,"Shapes with partially shared edges",320}
72b7576f 2452
e2b55410 2453It is important to distinguish between sewing and other procedures, which modify the geometry, such as filling holes or gaps, gluing, bending curves and surfaces, etc.
dba69de2 2454
e2b55410 2455Sewing does not change geometrical representation of the shapes. Sewing applies to topological elements (faces, edges) which are not connected but can be connected because they are geometrically coincident : it adds the information about topological connectivity. Already connected elements are left untouched in case of manifold sewing.
72b7576f 2456
e2b55410 2457Let us define several terms:
2458* **Floating edges** do not belong to any face;
2459* **Free boundaries** belong to one face only;
2460* **Shared edges** belong to several faces, (i.e. two faces in a manifold topology).
2461* **Sewn faces** should have edges shared with each other.
2462* **Sewn edges** should have vertices shared with each other.
72b7576f 2463
e2b55410 2464@subsection occt_modalg_8_2 Sewing Algorithm
2465
2466The sewing algorithm is one of the basic algorithms used for shape processing, therefore its quality is very important.
2467
2468Sewing algorithm is implemented in the class *BRepBuilder_Sewing*. This class provides the following methods:
2470* setting customization parameters, such as special operation modes, tolerances and output results;
2471* applying analysis methods that can be used to obtain connectivity data required by external algorithms;
2472* sewing of the loaded shapes.
2473
2474Sewing supports working mode with big value tolerance. It is not necessary to repeat sewing step by step while smoothly increasing tolerance.
2475
2476It is also possible to sew edges to wire and to sew locally separate faces and edges from a shape.
2477
2478The Sewing algorithm can be subdivided into several independent stages, some of which can be turned on or off using Boolean or other flags.
2479
2480In brief, the algorithm should find a set of merge candidates for each free boundary, filter them according to certain criteria, and finally merge the found candidates and build the resulting sewn shape.
2481
2482Each stage of the algorithm or the whole algorithm can be adjusted with the following parameters:
2483* **Working tolerance** defines the maximal distance between topological elements which can be sewn. It is not ultimate that such elements will be actually sewn as many other criteria are applied to make the final decision.
2484* **Minimal tolerance** defines the size of the smallest element (edge) in the resulting shape. It is declared that no edges with size less than this value are created after sewing. If encountered, such topology becomes degenerated.
2485* **Non-manifold mode** enables sewing of non-manifold topology.
2486
2487#### Example
2488
2489To connect a set of *n* contiguous but independent faces, do the following:
2490
2491~~~~~
2492 BRepBuilderAPI_Sewing Sew;
2495 ...
2497 Sew.Perform();
2498 TopoDS_Shape result= Sew.SewedShape();
2499~~~~~
dba69de2 2500
e2b55410 2501If all faces have been sewn correctly, the result is a shell. Otherwise, it is a compound. After a successful sewing operation all faces have a coherent orientation.
2502
2503@subsection occt_modalg_8_3 Tolerance Management
2504
2505To produce a closed shell, Sewing allows specifying the value of working tolerance, exceeding the size of small faces belonging to the shape.
2506
2507However, if we produce an open shell, it is possible to get incorrect sewing results if the value of working tolerance is too large (i.e. it exceeds the size of faces lying on an open boundary).
2508
2509The following recommendations can be proposed for tuning-up the sewing process:
2510- Use as small working tolerance as possible. This will reduce the sewing time and, consequently, the number of incorrectly sewn edges for shells with free boundaries.
2511- Use as large minimal tolerance as possible. This will reduce the number of small geometry in the shape, both original and appearing after cutting.
2512- If it is expected to obtain a shell with holes (free boundaries) as a result of sewing, the working tolerance should be set to a value not greater than the size of the smallest element (edge) or smallest distance between elements of such free boundary. Otherwise the free boundary may be sewn only partially.
2513- It should be mentioned that the Sewing algorithm is unable to understand which small (less than working tolerance) free boundary should be kept and which should be sewn.
2514
2515@subsection occt_modalg_8_4 Manifold and Non-manifold Sewing
2516
2517To create one or several shells from a set of faces, sewing merges edges, which belong to different faces or one closed face.
2518
2519Face sewing supports manifold and non manifold modes. Manifold mode can produce only a manifold shell. Sewing should be used in the non manifold mode to create non manifold shells.
2520
2521Manifold sewing of faces merges only two nearest edges belonging to different faces or one closed face with each other. Non manifold sewing of faces merges all edges at a distance less than the specified tolerance.
2522
2523For a complex topology it is advisable to apply first the manifold sewing and then the non manifold sewing a minimum possible working tolerance. However, this is not necessary for a easy topology.
2524
2525Giving a large tolerance value to non manifold sewing will cause a lot of incorrectness since all nearby geometry will be sewn.
2526
2527@subsection occt_modalg_8_5 Local Sewing
2528
2529If a shape still has some non-sewn faces or edges after sewing, it is possible to use local sewing with a greater tolerance.
2530
2531Local sewing is especially good for open shells. It allows sewing an unwanted hole in one part of the shape and keeping a required hole, which is smaller than the working tolerance specified for the local sewing in the other part of the shape. Local sewing is much faster than sewing on the whole shape.
2532
2533All preexisting connections of the whole shape are kept after local sewing.
2534
2535For example, if you want to sew two open shells having coincided free edges using local sewing, it is necessary to create a compound from two shells then load the full compound using method *BRepBuilderAPI_Sewing::Load()*. After that it is necessary to add local sub-shapes, which should be sewn using method *BRepBuilderAPI_Sewing::Add()*. The result of sewing can be obtained using method *BRepBuilderAPI_Sewing::SewedShape()*.
2536
2537See the example:
2538
2539~~~~
2540
2541//initial sewn shapes
2542TopoDS_Shape aS1, aS2; // these shapes are expected to be well sewn shells
2543TopoDS_Shape aComp;
2544BRep_Builder aB;
2545aB.MakeCompound(aComp);
2548................................
2550
2551//sub shapes which should be locally sewed
2554//performing sewing
2555aSewing.Perform();
2556//result shape
2557TopoDS_Shape aRes = aSewing.SewedShape();
2558
2559~~~~
72b7576f 2560
2561@section occt_modalg_9 Features
2562
e2b55410 2563This library contained in *BRepFeat* package is necessary for creation and manipulation of form and mechanical features that go beyond the classical boundary representation of shapes. In that sense, *BRepFeat* is an extension of *BRepBuilderAPI* package.
2564
2565@subsection occt_modalg_9_1 Form Features
2566
2567The form features are depressions or protrusions including the following types:
2568
2569 * Cylinder;
2570 * Draft Prism;
2571 * Prism;
2572 * Revolved feature;
2573 * Pipe.
2574
2575Depending on whether you wish to make a depression or a protrusion,
2576you can choose either to remove matter (Boolean cut: Fuse equal to 0) or to add it (Boolean fusion: Fuse equal to 1).
72b7576f 2577
e2b55410 2578The semantics of form feature creation is based on the construction of shapes:
72b7576f 2579
e2b55410 2580 * for a certain length in a certain direction;
2581 * up to the limiting face;
2582 * from the limiting face at a height;
2583 * above and/or below a plane.
dba69de2 2584
e2b55410 2585The shape defining the construction of a feature can be either a supporting edge or a concerned area of a face.
2586
2587In case of supporting edge, this contour can be attached to a face of the basis shape by binding. When the contour is bound to this face, the information that the contour will slide on the face becomes available
2588to the relevant class methods. In case of the concerned area of a face, you can, for example, cut it out and move it at a different height, which defines the limiting face of a protrusion or depression.
2589
2590Topological definition with local operations of this sort makes calculations simpler
2591and faster than a global operation. The latter would entail a second phase
2592of removing unwanted matter to get the same result.
2593
2594The *Form* from *BRepFeat* package is a deferred class used as a root for form features. It inherits *MakeShape* from *BRepBuilderAPI* and provides implementation of methods keep track of all sub-shapes.
2595
2596@subsubsection occt_modalg_9_1_1 Prism
2597
2598The class *BRepFeat_MakePrism* is used to build a prism interacting with a shape. It is created or initialized from
72b7576f 2599 * a shape (the basic shape),
2600 * the base of the prism,
2601 * a face (the face of sketch on which the base has been defined and used to determine whether the base has been defined on the basic shape or not),
2602 * a direction,
2603 * a Boolean indicating the type of operation (fusion=protrusion or cut=depression) on the basic shape,
2604 * another Boolean indicating if the self-intersections have to be found (not used in every case).
2605
2606There are six Perform methods:
e5bd0d98 2607| Method | Description |
2608| :---------------------- | :------------------------------------- |
dba69de2 2609| *Perform(Height)* | The resulting prism is of the given length. |
2610| *Perform(Until)* | The prism is defined between the position of the base and the given face. |
2611| *Perform(From, Until)* | The prism is defined between the two faces From and Until. |
2612| *PerformUntilEnd()* | The prism is semi-infinite, limited by the actual position of the base. |
2613| *PerformFromEnd(Until)* | The prism is semi-infinite, limited by the face Until. |
2614| *PerformThruAll()* | The prism is infinite. In the case of a depression, the result is similar to a cut with an infinite prism. In the case of a protrusion, infinite parts are not kept in the result. |
72b7576f 2615
dba69de2 2616**Note** that *Add* method can be used before *Perform* methods to indicate that a face generated by an edge slides onto a face of the base shape.
72b7576f 2617
2618In the following sequence, a protrusion is performed, i.e. a face of the shape is changed into a prism.
2619
2620~~~~~
dba69de2 2621TopoDS_Shape Sbase = ...; // an initial shape
72b7576f 2622TopoDS_Face Fbase = ....; // a base of prism
2623
2624gp_Dir Extrusion (.,.,.);
2625
2626// An empty face is given as the sketch face
2627
2628BRepFeat_MakePrism thePrism(Sbase, Fbase, TopoDS_Face(), Extrusion, Standard_True, Standard_True);
2629
2630thePrism, Perform(100.);
2631if (thePrism.IsDone()) {
2632 TopoDS_Shape theResult = thePrism;
2633 ...
2634}
2635~~~~~
2636
d6b4d3d0 2637@figure{/user_guides/modeling_algos/images/modeling_algos_image047.png,"Fusion with MakePrism",320}
dba69de2 2638
d6b4d3d0 2639@figure{/user_guides/modeling_algos/images/modeling_algos_image048.png,"Creating a prism between two faces with Perform()",320}
72b7576f 2640
e2b55410 2641@subsubsection occt_modalg_9_1_2 Draft Prism
72b7576f 2642
e2b55410 2643The class *BRepFeat_MakeDPrism* is used to build draft prism topologies interacting with a basis shape. These can be depressions or protrusions. A class object is created or initialized from:
72b7576f 2644 * a shape (basic shape),
2645 * the base of the prism,
2646 * a face (face of sketch on which the base has been defined and used to determine whether the base has been defined on the basic shape or not),
2647 * an angle,
2648 * a Boolean indicating the type of operation (fusion=protrusion or cut=depression) on the basic shape,
2649 * another Boolean indicating if self-intersections have to be found (not used in every case).
2650
2651Evidently the input data for MakeDPrism are the same as for MakePrism except for a new parameter Angle and a missing parameter Direction: the direction of the prism generation is determined automatically as the normal to the base of the prism.
2652The semantics of draft prism feature creation is based on the construction of shapes:
2653 * along a length
2654 * up to a limiting face
2655 * from a limiting face to a height.
2656
2657The shape defining construction of the draft prism feature can be either the supporting edge or the concerned area of a face.
2658
2659In case of the supporting edge, this contour can be attached to a face of the basis shape by binding. When the contour is bound to this face, the information that the contour will slide on the face becomes available to the relevant class methods.
2660In case of the concerned area of a face, it is possible to cut it out and move it to a different height, which will define the limiting face of a protrusion or depression direction .
2661
2662The *Perform* methods are the same as for *MakePrism*.
2663
2664~~~~~
2665TopoDS_Shape S = BRepPrimAPI_MakeBox(400.,250.,300.);
2666TopExp_Explorer Ex;
2667Ex.Init(S,TopAbs_FACE);
2668Ex.Next();
2669Ex.Next();
2670Ex.Next();
2671Ex.Next();
2672Ex.Next();
2673TopoDS_Face F = TopoDS::Face(Ex.Current());
2674Handle(Geom_Surface) surf = BRep_Tool::Surface(F);
2675gp_Circ2d
2676c(gp_Ax2d(gp_Pnt2d(200.,130.),gp_Dir2d(1.,0.)),50.);
2677BRepBuilderAPI_MakeWire MW;
2678Handle(Geom2d_Curve) aline = new Geom2d_Circle(c);
2681BRepBuilderAPI_MakeFace MKF;
2682MKF.Init(surf,Standard_False);
2684TopoDS_Face FP = MKF.Face();
2685BRepLib::BuildCurves3d(FP);
2686BRepFeat_MakeDPrism MKDP (S,FP,F,10*PI180,Standard_True,
2687 Standard_True);
2688MKDP.Perform(200);
2689TopoDS_Shape res1 = MKDP.Shape();
2690~~~~~
2691
d6b4d3d0 2692@figure{/user_guides/modeling_algos/images/modeling_algos_image049.png,"A tapered prism",320}
dba69de2 2693
e2b55410 2694@subsubsection occt_modalg_9_1_3 Revolution
72b7576f 2695
e2b55410 2696The class *BRepFeat_MakeRevol* is used to build a revolution interacting with a shape. It is created or initialized from:
72b7576f 2697 * a shape (the basic shape,)
2698 * the base of the revolution,
2699 * a face (the face of sketch on which the base has been defined and used to determine whether the base has been defined on the basic shape or not),
2700 * an axis of revolution,
2701 * a boolean indicating the type of operation (fusion=protrusion or cut=depression) on the basic shape,
2702 * another boolean indicating whether the self-intersections have to be found (not used in every case).
2703
2704There are four Perform methods:
e5bd0d98 2705| Method | Description |
2706| :--------------- | :------------ |
dba69de2 2707| *Perform(Angle)* | The resulting revolution is of the given magnitude. |
2708| *Perform(Until)* | The revolution is defined between the actual position of the base and the given face. |
2709| *Perform(From, Until)* | The revolution is defined between the two faces, From and Until. |
2710| *PerformThruAll()* | The result is similar to Perform(2*PI). |
2711
2712**Note** that *Add* method can be used before *Perform* methods to indicate that a face generated by an edge slides onto a face of the base shape.
72b7576f 2713
2714
2715In the following sequence, a face is revolved and the revolution is limited by a face of the base shape.
2716
2717~~~~~
dba69de2 2718TopoDS_Shape Sbase = ...; // an initial shape
72b7576f 2719TopoDS_Face Frevol = ....; // a base of prism
2720TopoDS_Face FUntil = ....; // face limiting the revol
2721
2722gp_Dir RevolDir (.,.,.);
2723gp_Ax1 RevolAx(gp_Pnt(.,.,.), RevolDir);
2724
2725// An empty face is given as the sketch face
2726
2727BRepFeat_MakeRevol theRevol(Sbase, Frevol, TopoDS_Face(), RevolAx, Standard_True, Standard_True);
2728
2729theRevol.Perform(FUntil);
2730if (theRevol.IsDone()) {
2731 TopoDS_Shape theResult = theRevol;
2732 ...
2733}
2734~~~~~
2735
e2b55410 2736@subsubsection occt_modalg_9_1_4 Pipe
dba69de2 2737
e2b55410 2738The class *BRepFeat_MakePipe* constructs compound shapes with pipe features: depressions or protrusions. A class object is created or initialized from:
72b7576f 2739 * a shape (basic shape),
2740 * a base face (profile of the pipe)
2741 * a face (face of sketch on which the base has been defined and used to determine whether the base has been defined on the basic shape or not),
2742 * a spine wire
2743 * a Boolean indicating the type of operation (fusion=protrusion or cut=depression) on the basic shape,
2744 * another Boolean indicating if self-intersections have to be found (not used in every case).
2745
2746There are three Perform methods:
e5bd0d98 2747| Method | Description |
2748| :-------- | :---------- |
dba69de2 2749| *Perform()* | The pipe is defined along the entire path (spine wire) |
2750| *Perform(Until)* | The pipe is defined along the path until a given face |
2751| *Perform(From, Until)* | The pipe is defined between the two faces From and Until |
72b7576f 2752
e2b55410 2753Let us have a look at the example:
2754
72b7576f 2755~~~~~
2756TopoDS_Shape S = BRepPrimAPI_MakeBox(400.,250.,300.);
2757TopExp_Explorer Ex;
2758Ex.Init(S,TopAbs_FACE);
2759Ex.Next();
2760Ex.Next();
2761TopoDS_Face F1 = TopoDS::Face(Ex.Current());
2762Handle(Geom_Surface) surf = BRep_Tool::Surface(F1);
2763BRepBuilderAPI_MakeWire MW1;
2764gp_Pnt2d p1,p2;
2765p1 = gp_Pnt2d(100.,100.);
2766p2 = gp_Pnt2d(200.,100.);
2767Handle(Geom2d_Line) aline = GCE2d_MakeLine(p1,p2).Value();
2768
2770p1 = p2;
2771p2 = gp_Pnt2d(150.,200.);
2772aline = GCE2d_MakeLine(p1,p2).Value();
2773
2775p1 = p2;
2776p2 = gp_Pnt2d(100.,100.);
2777aline = GCE2d_MakeLine(p1,p2).Value();
2778
2780BRepBuilderAPI_MakeFace MKF1;
2781MKF1.Init(surf,Standard_False);
2783TopoDS_Face FP = MKF1.Face();
2784BRepLib::BuildCurves3d(FP);
2785TColgp_Array1OfPnt CurvePoles(1,3);
2786gp_Pnt pt = gp_Pnt(150.,0.,150.);
2787CurvePoles(1) = pt;
2788pt = gp_Pnt(200.,100.,150.);
2789CurvePoles(2) = pt;
2790pt = gp_Pnt(150.,200.,150.);
2791CurvePoles(3) = pt;
2792Handle(Geom_BezierCurve) curve = new Geom_BezierCurve
2793(CurvePoles);
2794TopoDS_Edge E = BRepBuilderAPI_MakeEdge(curve);
2795TopoDS_Wire W = BRepBuilderAPI_MakeWire(E);
2796BRepFeat_MakePipe MKPipe (S,FP,F1,W,Standard_False,
2797Standard_True);
2798MKPipe.Perform();
2799TopoDS_Shape res1 = MKPipe.Shape();
2800~~~~~
2801
d6b4d3d0 2802@figure{/user_guides/modeling_algos/images/modeling_algos_image050.png,"Pipe depression",240}
dba69de2 2803
e2b55410 2804@subsection occt_modalg_9_2 Mechanical Features
dba69de2 2805
e2b55410 2806Mechanical features include ribs, protrusions and grooves (or slots), depressions along planar (linear) surfaces or revolution surfaces.
dba69de2 2807
3f812249 2808The semantics of mechanical features is built around giving thickness to a contour. This thickness can either be symmetrical -- on one side of the contour -- or dissymmetrical -- on both sides. As in the semantics of form features, the thickness is defined by construction of shapes in specific contexts.
72b7576f 2809
2810The development contexts differ, however, in the case of mechanical features.
2811Here they include extrusion:
2812 * to a limiting face of the basis shape;
2813 * to or from a limiting plane;
2814 * to a height.
e2b55410 2815
72b7576f 2816A class object is created or initialized from
2817 * a shape (basic shape);
2818 * a wire (base of rib or groove);
2819 * a plane (plane of the wire);
2820 * direction1 (a vector along which thickness will be built up);
2821 * direction2 (vector opposite to the previous one along which thickness will be built up, may be null);
2822 * a Boolean indicating the type of operation (fusion=rib or cut=groove) on the basic shape;
2823 * another Boolean indicating if self-intersections have to be found (not used in every case).
e2b55410 2824
2825@subsubsection occt_modalg_9_2_1 Linear Form
2826
2827Linear form is implemented in *MakeLinearForm* class, which creates a rib or a groove along a planar surface. There is one *Perform()* method, which performs a prism from the wire along the *direction1* and *direction2* interacting with base shape *Sbase*. The height of the prism is *Magnitude(Direction1)+Magnitude(direction2)*.
72b7576f 2828
2829~~~~~
2830BRepBuilderAPI_MakeWire mkw;
2831gp_Pnt p1 = gp_Pnt(0.,0.,0.);
2832gp_Pnt p2 = gp_Pnt(200.,0.,0.);
2834p1 = p2;
2835p2 = gp_Pnt(200.,0.,50.);
2837p1 = p2;
2838p2 = gp_Pnt(50.,0.,50.);
2840p1 = p2;
2841p2 = gp_Pnt(50.,0.,200.);
2843p1 = p2;
2844p2 = gp_Pnt(0.,0.,200.);
2846p1 = p2;
2848TopoDS_Shape S = BRepBuilderAPI_MakePrism(BRepBuilderAPI_MakeFace
2849 (mkw.Wire()),gp_Vec(gp_Pnt(0.,0.,0.),gp_P
dba69de2 2850 nt(0.,100.,0.)));
72b7576f 2851TopoDS_Wire W = BRepBuilderAPI_MakeWire(BRepBuilderAPI_MakeEdge(gp_Pnt
2852 (50.,45.,100.),
2853gp_Pnt(100.,45.,50.)));
2854Handle(Geom_Plane) aplane =
2855 new Geom_Plane(gp_Pnt(0.,45.,0.), gp_Vec(0.,1.,0.));
2856BRepFeat_MakeLinearForm aform(S, W, aplane, gp_Dir
2857 (0.,5.,0.), gp_Dir(0.,-3.,0.), 1, Standard_True);
2858aform.Perform();
2859TopoDS_Shape res = aform.Shape();
2860~~~~~
2861
d6b4d3d0 2862@figure{/user_guides/modeling_algos/images/modeling_algos_image051.png,"Creating a rib",240}
72b7576f 2863
e2b55410 2864@subsubsection occt_modalg_9_2_3 Gluer
2865
2866The class *BRepFeat_Gluer* allows gluing two solids along faces. The contact faces of the glued shape must not have parts outside the contact faces of the basic shape. Upon completion the algorithm gives the glued shape with cut out parts of faces inside the shape.
72b7576f 2867
72b7576f 2868The class is created or initialized from two shapes: the “glued” shape and the basic shape (on which the other shape is glued).
dba69de2 2869Two *Bind* methods are used to bind a face of the glued shape to a face of the basic shape and an edge of the glued shape to an edge of the basic shape.
72b7576f 2870
dba69de2 2871**Note** that every face and edge has to be bounded, if two edges of two glued faces are coincident they must be explicitly bounded.
72b7576f 2872
2873~~~~~
2874TopoDS_Shape Sbase = ...; // the basic shape
2875TopoDS_Shape Sglued = ...; // the glued shape
2876
2877TopTools_ListOfShape Lfbase;
2878TopTools_ListOfShape Lfglued;
2879// Determination of the glued faces
2880...
2881
2882BRepFeat_Gluer theGlue(Sglue, Sbase);
2883TopTools_ListIteratorOfListOfShape itlb(Lfbase);
2884TopTools_ListIteratorOfListOfShape itlg(Lfglued);
2885for (; itlb.More(); itlb.Next(), itlg(Next()) {
e5bd0d98 2886const TopoDS_Face& f1 = TopoDS::Face(itlg.Value());
2887const TopoDS_Face& f2 = TopoDS::Face(itlb.Value());
72b7576f 2888theGlue.Bind(f1,f2);
2889// for example, use the class FindEdges from LocOpe to
2890// determine coincident edges
2891LocOpe_FindEdge fined(f1,f2);
2892for (fined.InitIterator(); fined.More(); fined.Next()) {
2893theGlue.Bind(fined.EdgeFrom(),fined.EdgeTo());
2894}
2895}
2896theGlue.Build();
2897if (theGlue.IsDone() {
2898TopoDS_Shape theResult = theGlue;
2899...
2900}
2901~~~~~
2902
e2b55410 2903@subsubsection occt_modalg_9_2_4 Split Shape
72b7576f 2904
e2b55410 2905The class *BRepFeat_SplitShape* is used to split faces of a shape into wires or edges. The shape containing the new entities is rebuilt, sharing the unmodified ones.
72b7576f 2906
2907The class is created or initialized from a shape (the basic shape).
3f812249 2909* *Add(Wire, Face)* -- adds a new wire on a face of the basic shape.
2910* *Add(Edge, Face)* -- adds a new edge on a face of the basic shape.
2911* *Add(EdgeNew, EdgeOld)* -- adds a new edge on an existing one (the old edge must contain the new edge).
72b7576f 2912
2913**Note** The added wires and edges must define closed wires on faces or wires located between two existing edges. Existing edges must not be intersected.
2914
2915~~~~~
2916TopoDS_Shape Sbase = ...; // basic shape
2917TopoDS_Face Fsplit = ...; // face of Sbase
2918TopoDS_Wire Wsplit = ...; // new wire contained in Fsplit
2919BRepFeat_SplitShape Spls(Sbase);
2921TopoDS_Shape theResult = Spls;
2922...
2923~~~~~
2924
2925
2926@section occt_modalg_10 Hidden Line Removal
2927
2928To provide the precision required in industrial design, drawings need to offer the possibility of removing lines, which are hidden in a given projection.
2929
e2b55410 2930For this the Hidden Line Removal component provides two algorithms: *HLRBRep_Algo* and *HLRBRep_PolyAlgo*.
72b7576f 2931
2932These algorithms are based on the principle of comparing each edge of the shape to be visualized with each of its faces, and calculating the visible and the hidden parts of each edge. Note that these are not the algorithms used in generating shading, which calculate the visible and hidden parts of each face in a shape to be visualized by comparing each face in the shape with every other face in the same shape.
2933These algorithms operate on a shape and remove or indicate edges hidden by faces. For a given projection, they calculate a set of lines characteristic of the object being represented. They are also used in conjunction with extraction utilities, which reconstruct a new, simplified shape from a selection of the results of the calculation. This new shape is made up of edges, which represent the shape visualized in the projection.
2934
e2b55410 2935*HLRBRep_Algo* allows working with the shape itself, whereas *HLRBRep_PolyAlgo* works with a polyhedral simplification of the shape. When you use *HLRBRep_Algo*, you obtain an exact result, whereas, when you use *HLRBRep_PolyAlgo*, you reduce the computation time, but obtain polygonal segments.
72b7576f 2936
dba69de2 2937No smoothing algorithm is provided. Consequently, a polyhedron will be treated as such and the algorithms will give the results in form of line segments conforming to the mathematical definition of the polyhedron. This is always the case with *HLRBRep_PolyAlgo*.
72b7576f 2938
dba69de2 2939*HLRBRep_Algo* and *HLRBRep_PolyAlgo* can deal with any kind of object, for example, assemblies of volumes, surfaces, and lines, as long as there are no unfinished objects or points within it.
72b7576f 2940
2941However, there some restrictions in HLR use:
2942 * Points are not processed;
72b7576f 2943 * Infinite faces or lines are not processed.
2944
2945
d6b4d3d0 2946@figure{/user_guides/modeling_algos/images/modeling_algos_image052.png,"Sharp, smooth and sewn edges in a simple screw shape",320}
72b7576f 2947
d6b4d3d0 2948@figure{/user_guides/modeling_algos/images/modeling_algos_image053.png,"Outline edges and isoparameters in the same shape",320}
72b7576f 2949
d6b4d3d0 2950@figure{/user_guides/modeling_algos/images/modeling_algos_image054.png,"A simple screw shape seen with shading",320}
72b7576f 2951
d6b4d3d0 2952@figure{/user_guides/modeling_algos/images/modeling_algos_image055.png,"An extraction showing hidden sharp edges",320}
72b7576f 2953
2954
72b7576f 2955The following services are related to Hidden Lines Removal :
2956
2958
72b7576f 2959To pass a *TopoDS_Shape* to an *HLRBRep_Algo* object, use *HLRBRep_Algo::Add*. With an *HLRBRep_PolyAlgo* object, use *HLRBRep_PolyAlgo::Load*. If you wish to add several shapes, use Add or Load as often as necessary.
2960
dba69de2 2961### Setting view parameters
2962
2963*HLRBRep_Algo::Projector* and *HLRBRep_PolyAlgo::Projector* set a projector object which defines the parameters of the view. This object is an *HLRAlgo_Projector*.
2964
2965### Computing the projections
2966
2967*HLRBRep_PolyAlgo::Update* launches the calculation of outlines of the shape visualized by the *HLRBRep_PolyAlgo* framework.
72b7576f 2968
dba69de2 2969In the case of *HLRBRep_Algo*, use *HLRBRep_Algo::Update*. With this algorithm, you must also call the method *HLRBRep_Algo::Hide* to calculate visible and hidden lines of the shape to be visualized. With an *HLRBRep_PolyAlgo* object, visible and hidden lines are computed by *HLRBRep_PolyHLRToShape*.
72b7576f 2970
dba69de2 2971### Extracting edges
2972
2973The classes *HLRBRep_HLRToShape* and *HLRBRep_PolyHLRToShape* present a range of extraction filters for an *HLRBRep_Algo object* and an *HLRBRep_PolyAlgo* object, respectively. They highlight the type of edge from the results calculated by the algorithm on a shape. With both extraction classes, you can highlight the following types of output:
72b7576f 2974 * visible/hidden sharp edges;
2975 * visible/hidden smooth edges;
2976 * visible/hidden sewn edges;
2977 * visible/hidden outline edges.
2978
2979To perform extraction on an *HLRBRep_PolyHLRToShape* object, use *HLRBRep_PolyHLRToShape::Update* function.
dba69de2 2980
72b7576f 2981For an *HLRBRep_HLRToShape* object built from an *HLRBRepAlgo* object you can also highlight:
2982 * visible isoparameters and
2983 * hidden isoparameters.
2984
dba69de2 2985@subsection occt_modalg_10_1 Examples
2986
2987### HLRBRep_Algo
72b7576f 2988
72b7576f 2989~~~~~
2990// Build The algorithm object
2991myAlgo = new HLRBRep_Algo();
2992
2993// Add Shapes into the algorithm
2994TopTools_ListIteratorOfListOfShape anIterator(myListOfShape);
2995for (;anIterator.More();anIterator.Next())