1 Modeling Algorithms {#user_guides__modeling_algos}
2 =========================
4 @section occt_modalg_1 Introduction
6 @subsection occt_modalg_1_1 The Modeling Algorithms Module
9 This manual explains how to use the Modeling Algorithms. It provides basic documentation on modeling algorithms. For advanced information on Modeling Algorithms, see our offerings on our web site at <a href="http://www.opencascade.org/support/training/">www.opencascade.org/support/training/</a>
11 The 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.
13 The algorithms available are divided into:
18 @subsection occt_modalg_1_2 The Topology API
20 The Topology API of Open CASCADE Technology (**OCCT**) includes the following six packages:
29 The classes in these six packages provide the user with a simple and powerful interface.
30 * A simple interface: a function call works ideally,
31 * A powerful interface: including error handling and access to extra information provided by the algorithms.
33 As an example, the class BRepBuilderAPI_MakeEdge can be used to create a linear edge from two points.
36 gp_Pnt P1(10,0,0), P2(20,0,0);
37 TopoDS_Edge E = BRepBuilderAPI_MakeEdge(P1,P2);
40 This 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.
44 #include <TopoDS_Edge.hxx>
45 #include <BRepBuilderAPI_MakeEdge.hxx>
50 BRepBuilderAPI_MakeEdge ME(P1,P2);
53 // doing ME.Edge() or E = ME here
54 // would raise StdFail_NotDone
55 Standard_DomainError::Raise
56 (“ProcessPoints::Failed to createan edge”);
62 In 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.
64 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.
67 void MakeEdgeAndVertices(const gp_Pnt& P1,
70 TopoDS_Vertex& V1,
71 TopoDS_Vertex& V2)
73 BRepBuilderAPI_MakeEdge ME(P1,P2);
75 Standard_DomainError::Raise
76 (“MakeEdgeAndVerices::Failed to create an edge”);
83 The BRepBuilderAPI_MakeEdge class provides the two methods Vertex1 and Vertex2, which return the two vertices used to create the edge.
85 How 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 E = ME could have been written.
91 This 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.
93 This 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.
96 @subsubsection occt_modalg_1_2_1 Error Handling in the Topology API
98 A method can report an error in the two following situations:
99 * 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.
100 * 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).
102 The 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.
104 In 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.
106 Making 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.
107 As the test involves a great deal of computation, performing it twice is also time-consuming.
109 Consequently, you might be tempted to adopt the highly inadvisable style of programming illustrated in the following example:
112 #include <Standard_ErrorHandler.hxx>
114 TopoDS_Edge E = BRepBuilderAPI_MakeEdge(P1,P2);
115 // go on with the edge
118 // process the error.
122 To 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.
124 The *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.
127 BRepBuilderAPI_MakeEdge ME(P1,P2);
129 // doing ME.Edge() or E = ME here
130 // would raise StdFail_NotDone
131 Standard_DomainError::Raise
132 (“ProcessPoints::Failed to create an edge”);
137 @section occt_modalg_2 Geometric Tools
139 @subsection occt_modalg_2_1 Overview
141 Open CASCADE Technology geometric tools include:
143 * Computation of intersections
145 * Computation of curves and surfaces from constraints
146 * Computation of lines and circles from constraints
149 @subsection occt_modalg_2_2 Intersections
151 The *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.
153 @image html /user_guides/modeling_algos/images/modeling_algos_image003.jpg "Intersection and self-intersection of curves"
154 @image latex /user_guides/modeling_algos/images/modeling_algos_image003.jpg "Intersection and self-intersection of curves"
156 In 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.*
158 @image html /user_guides/modeling_algos/images/modeling_algos_image004.jpg "Intersection and tangent intersection"
159 @image latex /user_guides/modeling_algos/images/modeling_algos_image004.jpg "Intersection and tangent intersection"
161 The algorithm returns a point in the case of an intersection and a segment in the case of tangent intersection.
163 @subsubsection occt_modalg_2_2_1 Geom2dAPI_InterCurveCurve
165 This class may be instantiated either for intersection of curves C1 and C2.
167 Geom2dAPI_InterCurveCurve Intersector(C1,C2,tolerance);
170 or for self-intersection of curve C3.
172 Geom2dAPI_InterCurveCurve Intersector(C3,tolerance);
176 Standard_Integer N = Intersector.NbPoints();
178 Calls the number of intersection points
180 To select the desired intersection point, pass an integer index value in argument.
182 gp_Pnt2d P = Intersector.Point(Index);
185 To call the number of intersection segments, use
187 Standard_Integer M = Intersector.NbSegments();
190 To select the desired intersection segment pass integer index values in argument.
192 Handle(Geom2d_Curve) Seg1, Seg2;
193 Intersector.Segment(Index,Seg1,Seg2);
194 // if intersection of 2 curves
195 Intersector.Segment(Index,Seg1);
196 // if self-intersection of a curve
199 If you need access to a wider range of functionalities the following method will return the algorithmic object for the calculation of intersections:
202 Geom2dInt_GInter& TheIntersector = Intersector.Intersector();
205 @subsubsection occt_modalg_2_2_2 Intersection of Curves and Surfaces
206 The *GeomAPI_IntCS* class is used to compute the intersection points between a curve and a surface.
208 This class is instantiated as follows:
210 GeomAPI_IntCS Intersector(C, S);
214 Standard_Integer nb = Intersector.NbPoints();
216 Calls the number of intersection points.
219 gp_Pnt& P = Intersector.Point(Index);
222 Where *Index* is an integer between 1 and *nb*, calls the intersection points.
224 @subsubsection occt_modalg_2_2_3 Intersection of two Surfaces
225 The *GeomAPI_IntSS* class is used to compute the intersection of two surfaces from *Geom_Surface* with respect to a given tolerance.
227 This class is instantiated as follows:
229 GeomAPI_IntSS Intersector(S1, S2, Tolerance);
231 Once the *GeomAPI_IntSS* object has been created, it can be interpreted.
234 Standard_Integer nb = Intersector. NbLines();
236 Calls the number of intersection curves.
239 Handle(Geom_Curve) C = Intersector.Line(Index)
241 Where *Index* is an integer between 1 and *nb*, calls the intersection curves.
243 @subsection occt_modalg_2_3 Interpolations
244 *Interpolation* provides functionalities for interpolating BSpline curves, whether in 2D, using *Geom2dAPI_Interpolate*, or 3D using *GeomAPI_Interpolate*.
247 @subsubsection occt_modalg_2_3_1 Geom2dAPI_Interpolate
248 This 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.
249 This class may be instantiated as follows:
251 Geom2dAPI_Interpolate
252 (const Handle_TColgp_HArray1OfPnt2d& Points,
253 const Standard_Boolean PeriodicFlag,
254 const Standard_Real Tolerance);
256 Geom2dAPI_Interpolate Interp(Points, Standard_False,
257 Precision::Confusion());
261 It is possible to call the BSpline curve from the object defined above it.
263 Handle(Geom2d_BSplineCurve) C = Interp.Curve();
266 Note 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.
269 Handle(Geom2d_BSplineCurve) C =
270 Geom2dAPI_Interpolate(Points,
272 Precision::Confusion());
275 @subsubsection occt_modalg_2_3_2 GeomAPI_Interpolate
277 This class may be instantiated as follows:
280 (const Handle_TColgp_HArray1OfPnt& Points,
281 const Standard_Boolean PeriodicFlag,
282 const Standard_Real Tolerance);
284 GeomAPI_Interpolate Interp(Points, Standard_False,
285 Precision::Confusion());
288 It is possible to call the BSpline curve from the object defined above it.
290 Handle(Geom_BSplineCurve) C = Interp.Curve();
292 Note 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.
294 Handle(Geom_BSplineCurve) C =
295 GeomAPI_Interpolate(Points,
299 Boundary conditions may be imposed with the method Load.
301 GeomAPI_Interpolate AnInterpolator
302 (Points, Standard_False, 1.0e-5);
303 AnInterpolator.Load (StartingTangent, EndingTangent);
306 @subsection occt_modalg_2_4 Lines and Circles from Constraints
308 There are two packages to create lines and circles from constraints: *Geom2dGcc* and *GccAna*. *Geom2dGcc* deals with reference-handled geometric objects from the *Geom2d* package, while *GccAna* deals with value-handled geometric objects from the *gp* package.
310 The *Geom2dGcc* package solves geometric constructions of lines and circles expressed by constraints such as tangency or parallelism, that is, a constraint expressed in geometric terms. As a simple example the following figure shows a line which is constrained to pass through a point and be tangent to a circle.
312 @image html /user_guides/modeling_algos/images/modeling_algos_image005.jpg "A constrained line"
313 @image latex /user_guides/modeling_algos/images/modeling_algos_image005.jpg "A constrained line"
315 The *Geom2dGcc* package focuses on algorithms; it is useful for finding results, but it does not offer any management or modification functions, which could be applied to the constraints or their arguments. This package is designed to offer optimum performance, both in rapidity and precision. Trivial cases (for example, a circle centered on one point and passing through another) are not treated.
317 The *Geom2dGcc* package deals only with 2d objects from the *Geom2d* package. These objects are the points, lines and circles available.
319 All other lines such as Bezier curves and conic sections except for circles are considered general curves and must be differentiable twice.
321 The *GccAna* package deals with points, lines, and circles from the *gp* package. Apart from constructors for lines and circles, it also allows the creation of conics from the bisection of other geometric objects.
323 @subsection occt_modalg_2_5 Provided algorithms
325 The following analytic algorithms using value-handled entities for creation of 2D lines or circles with geometric constraints are available:
327 * circle tangent to three elements (lines, circles, curves, points),
328 * circle tangent to two elements and having a radius,
329 * circle tangent to two elements and centered on a third element,
330 * circle tangent to two elements and centered on a point,
331 * circle tangent to one element and centered on a second,
332 * bisector of two points,
333 * bisector of two lines,
334 * bisector of two circles,
335 * bisector of a line and a point,
336 * bisector of a circle and a point,
337 * bisector of a line and a circle,
338 * line tangent to two elements (points, circles, curves),
339 * line tangent to one element and parallel to a line,
340 * line tangent to one element and perpendicular to a line,
341 * line tangent to one element and forming angle with a line.
343 @subsection occt_modalg_2_6 Types of algorithms
344 There are three categories of available algorithms, which complement each other:
349 An analytic algorithm will solve a system of equations, whereas a geometric algorithm works with notions of parallelism, tangency, intersection and so on.
351 Both methods can provide solutions. An iterative algorithm, however, seeks to refine an approximate solution.
353 @subsection occt_modalg_2_7 Performance factors
355 The appropriate algorithm is the one, which reaches a solution of the required accuracy in the least time. Only the solutions actually requested by the user should be calculated. A simple means to reduce the number of solutions is the notion of a "qualifier". There are four qualifiers, which are:
357 * Unqualified: the position of the solution is undefined with respect to this argument.
358 * Enclosing: the solution encompasses this argument.
359 * Enclosed: the solution is encompassed by this argument.
360 * Outside: the solution and argument are outside each other.
363 @subsection occt_modalg_2_8 Conventions
365 @subsubsection occt_modalg_2_8_1 Exterior/Interior
366 It 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 "material").
368 @image html /user_guides/modeling_algos/images/modeling_algos_image006.jpg "Exterior/Interior of a Circle"
369 @image latex /user_guides/modeling_algos/images/modeling_algos_image006.jpg "Exterior/Interior of a Circle"
371 By 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:
373 @image html /user_guides/modeling_algos/images/modeling_algos_image007.jpg "Exterior/Interior of a Line and a Curve"
374 @image latex /user_guides/modeling_algos/images/modeling_algos_image007.jpg "Exterior/Interior of a Line and a Curve"
376 @subsubsection occt_modalg_2_8_2 Orientation of a Line
377 It 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.
379 The following figure shows a line, which is first tangent to circle C1 which is interior to the line, and then passes through point P1.
381 @image html /user_guides/modeling_algos/images/modeling_algos_image008.jpg "An Oriented Line"
382 @image latex /user_guides/modeling_algos/images/modeling_algos_image008.jpg "An Oriented Line"
384 @subsection occt_modalg_2_9 Examples
386 @subsubsection occt_modalg_2_9_1 Line tangent to two circles
387 The 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.
389 Note that the qualifier "Outside" is used to mean "Mutually exterior".
393 @image html /user_guides/modeling_algos/images/modeling_algos_image009.jpg "Both circles outside"
394 @image latex /user_guides/modeling_algos/images/modeling_algos_image009.jpg "Both circles outside"
397 Tangent and Exterior to C1.
398 Tangent and Exterior to C2.
404 Solver(GccEnt::Outside(C1),
411 @image html /user_guides/modeling_algos/images/modeling_algos_image010.jpg "Both circles enclosed"
412 @image latex /user_guides/modeling_algos/images/modeling_algos_image010.jpg "Both circles enclosed"
415 Tangent and Including C1.
416 Tangent and Including C2.
422 Solver(GccEnt::Enclosing(C1),
423 GccEnt::Enclosing(C2),
429 @image html /user_guides/modeling_algos/images/modeling_algos_image011.jpg "C1 enclosed, C2 outside"
430 @image latex /user_guides/modeling_algos/images/modeling_algos_image011.jpg "C1 enclosed, C2 outside"
433 Tangent and Including C1.
434 Tangent and Exterior to C2.
439 Solver(GccEnt::Enclosing(C1),
446 @image html /user_guides/modeling_algos/images/modeling_algos_image012.jpg "C1 outside, C2 enclosed"
447 @image latex /user_guides/modeling_algos/images/modeling_algos_image012.jpg "C1 outside, C2 enclosed"
449 Tangent and Exterior to C1.
450 Tangent and Including C2.
455 Solver(GccEnt::Outside(C1),
456 GccEnt::Enclosing(C2),
462 @image html /user_guides/modeling_algos/images/modeling_algos_image013.jpg "With no qualifiers specified"
463 @image latex /user_guides/modeling_algos/images/modeling_algos_image013.jpg "With no qualifiers specified"
466 Tangent and Undefined with respect to C1.
467 Tangent and Undefined with respect to C2.
472 Solver(GccEnt::Unqualified(C1),
473 GccEnt::Unqualified(C2),
477 @subsubsection occt_modalg_2_9_2 Circle of given radius tangent to two circles
478 The following four diagrams show the four cases in using qualifiers in the creation of a circle.
481 @image html /user_guides/modeling_algos/images/modeling_algos_image014.jpg "Both solutions outside"
482 @image latex /user_guides/modeling_algos/images/modeling_algos_image014.jpg "Both solutions outside"
485 Tangent and Exterior to C1.
486 Tangent and Exterior to C2.
491 Solver(GccEnt::Outside(C1),
492 GccEnt::Outside(C2), Rad, Tolerance);
497 @image html /user_guides/modeling_algos/images/modeling_algos_image015.jpg "C2 encompasses C1"
498 @image latex /user_guides/modeling_algos/images/modeling_algos_image015.jpg "C2 encompasses C1"
501 Tangent and Exterior to C1.
502 Tangent and Included by C2.
507 Solver(GccEnt::Outside(C1),
508 GccEnt::Enclosed(C2), Rad, Tolerance);
512 @image html /user_guides/modeling_algos/images/modeling_algos_image016.jpg "Solutions enclose C2"
513 @image latex /user_guides/modeling_algos/images/modeling_algos_image016.jpg "Solutions enclose C2"
516 Tangent and Exterior to C1.
517 Tangent and Including C2.
522 Solver(GccEnt::Outside(C1),
523 GccEnt::Enclosing(C2), Rad, Tolerance);
527 @image html /user_guides/modeling_algos/images/modeling_algos_image017.jpg "Solutions enclose C1"
528 @image latex /user_guides/modeling_algos/images/modeling_algos_image017.jpg "Solutions enclose C1"
531 Tangent and Enclosing C1.
532 Tangent and Enclosing C2.
537 Solver(GccEnt::Enclosing(C1),
538 GccEnt::Enclosing(C2), Rad, Tolerance);
543 The following syntax will give all the circles of radius *Rad*, which are tangent to *C1* and *C2* without discrimination of relative position:
546 GccAna_Circ2d2TanRad Solver(GccEnt::Unqualified(C1),
547 GccEnt::Unqualified(C2),
551 @subsection occt_modalg_2_10 Algorithms
553 The objects created by this toolkit are non-persistent.
555 @subsubsection occt_modalg_2_10_1 Qualifiers
556 The *GccEnt* package contains the following package methods:
562 This enables creation of expressions, for example:
565 Solver(GccEnt::Outside(C1),
566 GccEnt::Enclosing(C2), Rad, Tolerance);
569 The objective in this case is to find all circles of radius *Rad*, which are tangent to both circle *C1* and *C2*, C1 being outside and C2 being inside.
571 @subsubsection occt_modalg_2_10_2 General Remarks about Algorithms
573 We consider the following to be the case:
574 * If a circle passes through a point then the circle is tangential to it.
575 * A distinction is made between the trivial case of the center at a point and the complex case of the center on a line.
577 @subsubsection occt_modalg_2_10_3 Analytic Algorithms
578 *GccAna* package implements analytic algorithms. It deals only with points, lines, and circles from *gp* package. Here is a list of the services offered:
580 #### Creation of a Line
584 Tangent ( point | circle ) & Parallel ( line )
585 Tangent ( point | circle ) & Perpendicular ( line | circle )
586 Tangent ( point | circle ) & Oblique ( line )
587 Tangent ( 2 { point | circle } )
588 Bisector( line | line )
591 #### Creation of Conics
595 Bisector ( point | point )
596 Bisector ( line | point )
597 Bisector ( circle | point )
598 Bisector ( line | line )
599 Bisector ( circle | line )
600 Bisector ( circle | circle )
603 #### Creation of a Circle
606 Tangent ( point | line | circle ) & Center ( point )
607 Tangent ( 3 { point | line | circle } )
608 Tangent ( 2 { point | line | circle } ) & Radius ( real )
609 Tangent ( 2 { point | line | circle } ) & Center ( line | circle )
610 Tangent ( point | line | circle ) & Center ( line | circle ) & Radius ( real )
613 For each algorithm, the tolerance (and angular tolerance if appropriate) is given as an argument. Calculation is done with the highest precision available from the hardware.
615 @subsubsection occt_modalg_2_10_4 Geometric Algorithms
617 *Geom2dGcc *package offers algorithms, which produce 2d lines or circles with geometric constraints. For arguments, it takes curves for which an approximate solution is not requested. A tolerance value on the result is given as a starting parameter. The following services are provided:
619 #### Creation of a Circle
622 Tangent ( curve ) & Center ( point )
623 Tangent ( curve , point | line | circle | curve ) & Radius ( real )
624 Tangent ( 2 {point | line | circle} ) & Center ( curve )
625 Tangent ( curve ) & Center ( line | circle | curve ) & Radius ( real )
626 Tangent ( point | line | circle ) & Center ( curve ) & Radius ( real )
629 All calculations will be done to the highest precision available from the hardware.
631 @subsubsection occt_modalg_2_10_5 Iterative Algorithms
632 *Geom2dGcc* package offers iterative algorithms find a solution by refining an approximate solution. It produces 2d lines or circles with geometric constraints. For all geometric arguments except points, an approximate solution may be given as a starting parameter. The tolerance or angular tolerance value is given as an argument. The following services are provided:
634 #### Creation of a Line
637 Tangent ( curve ) & Oblique ( line )
638 Tangent ( curve , { point | circle | curve } )
641 #### Creation of a Circle
644 Tangent ( curve , 2 { point | circle | curve } )
645 Tangent ( curve , { point | circle | curve } )
646 & Center ( line | circle | curve )
649 @subsection occt_modalg_2_1 Curves and Surfaces from Constraints
651 @subsubsection occt_modalg_2_1_1 Fair Curve
653 *FairCurve* package provides a set of classes to create faired 2D curves or 2D curves with minimal variation in curvature.
655 #### Creation of Batten Curves
657 The class 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.
658 The following constraint orders are available:
660 * 0 the curve must pass through a point
661 * 1 the curve must pass through a point and have a given tangent
662 * 2 the curve must pass through a point, have a given tangent and a given curvature.
664 Only 0 and 1 constraint orders are used.
665 The function Curve returns the result as a 2D BSpline curve.
667 #### Creation of Minimal Variation Curves
669 The class *MinimalVariation* allows producing curves with minimal variation in curvature at each reference point. The following constraint orders are available:
671 * 0 the curve must pass through a point
672 * 1 the curve must pass through a point and have a given tangent
673 * 2 the curve must pass through a point, have a given tangent and a given curvature.
675 Constraint orders of 0, 1 and 2 can be used. The algorithm minimizes tension, sagging and jerk energy.
677 The function *Curve* returns the result as a 2D BSpline curve.
679 #### Specifying the length of the curve
681 If you want to give a specific length to a batten curve, use:
684 b.SetSlidingFactor(L / b.SlidingOfReference())
686 where *b* is the name of the batten curve object
690 Free sliding is generally more aesthetically pleasing than constrained sliding.
691 However, the computation can fail with values such as angles greater than p/2, because in this case, the length is theoretically infinite.
693 In other cases, when sliding is imposed and the sliding factor is too large, the batten can collapse.
695 #### Computation Time
697 The constructor parameters, *Tolerance* and *NbIterations*, control how precise the computation is, and how long it will take.
699 @subsubsection occt_modalg_2_11_2 Surfaces from Boundary Curves
701 The *GeomFill* package provides the following services for creating surfaces from boundary curves:
703 #### Creation of Bezier surfaces
705 The class *BezierCurves* allows producing a Bezier surface from contiguous Bezier curves. Note that problems may occur with rational Bezier Curves.
707 #### Creation of BSpline surfaces
709 The class *BSplineCurves* allows producing a BSpline surface from contiguous BSpline curves. Note that problems may occur with rational BSplines.
711 #### Creation of a Pipe
713 The class *Pipe* allows producing a pipe by sweeping a curve (the section) along another curve (the path). The result is a BSpline surface.
715 #### Filling a contour
717 The class *GeomFill_ConstrainedFilling* allows filling a contour defined by two, three or four curves as well as by tangency constraints. The resulting surface is a BSpline.
719 #### Creation of a Boundary
721 The class *GeomFill_SimpleBound* allows you defining a boundary for the surface to be constructed.
723 #### Creation of a Boundary with an adjoining surface
725 The class *GeomFill_BoundWithSurf* allows defining a boundary for the surface to be constructed. This boundary will already be joined to another surface.
729 The enumerations *FillingStyle* specify the styles used to build the surface. These include:
731 * *Stretch* - the style with the flattest patches
732 * *Coons* - a rounded style with less depth than *Curved*
733 * *Curved* - the style with the most rounded patches.
735 @image html /user_guides/modeling_algos/images/modeling_algos_image018.jpg "Intersecting filleted edges with different radii leave a gap, is filled by a surface"
736 @image latex /user_guides/modeling_algos/images/modeling_algos_image018.jpg "Intersecting filleted edges with different radii leave a gap, is filled by a surface"
739 @subsubsection occt_modalg_2_11_3 Surfaces from curve and point constraints
740 The *GeomPlate* package provides the following services for creating surfaces respecting curve and point constraints:
742 #### Definition of a Framework
744 The 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*.
746 Note 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.
748 #### Definition of a Curve Constraint
750 The class *CurveConstraint* allows defining curves as constraints to the surface, which you want to build.
752 #### Definition of a Point Constraint
754 The class *PointConstraint* allows defining points as constraints to the surface, which you want to build.
756 #### Applying Geom_Surface to Plate Surfaces
758 The class *Surface* allows describing the characteristics of plate surface objects returned by **BuildPlateSurface::Surface** using the methods of *Geom_Surface*
760 #### Approximating a Plate surface to a BSpline
762 The class *MakeApprox* allows converting a *GeomPlate* surface into a *Geom_BSplineSurface*.
764 @image html /user_guides/modeling_algos/images/modeling_algos_image019.jpg "Surface generated from four curves and a point"
765 @image latex /user_guides/modeling_algos/images/modeling_algos_image019.jpg "Surface generated from four curves and a point"
767 Let us create a Plate surface and approximate it from a polyline as a curve constraint and a point constraint
770 Standard_Integer NbCurFront=4,
773 gp_Pnt P2(0.,10.,0.);
774 gp_Pnt P3(0.,10.,10.);
775 gp_Pnt P4(0.,0.,10.);
777 BRepBuilderAPI_MakePolygon W;
783 // Initialize a BuildPlateSurface
784 GeomPlate_BuildPlateSurface BPSurf(3,15,2);
785 // Create the curve constraints
786 BRepTools_WireExplorer anExp;
787 for(anExp.Init(W); anExp.More(); anExp.Next())
789 TopoDS_Edge E = anExp.Current();
790 Handle(BRepAdaptor_HCurve) C = new
791 BRepAdaptor_HCurve();
792 C-ChangeCurve().Initialize(E);
793 Handle(BRepFill_CurveConstraint) Cont= new
794 BRepFill_CurveConstraint(C,0);
798 Handle(GeomPlate_PointConstraint) PCont= new
799 GeomPlate_PointConstraint(P5,0);
801 // Compute the Plate surface
803 // Approximation of the Plate surface
804 Standard_Integer MaxSeg=9;
805 Standard_Integer MaxDegree=8;
806 Standard_Integer CritOrder=0;
807 Standard_Real dmax,Tol;
808 Handle(GeomPlate_Surface) PSurf = BPSurf.Surface();
809 dmax = Max(0.0001,10*BPSurf.G0Error());
812 Mapp(PSurf,Tol,MaxSeg,MaxDegree,dmax,CritOrder);
813 Handle (Geom_Surface) Surf (Mapp.Surface());
814 // create a face corresponding to the approximated Plate
816 Standard_Real Umin, Umax, Vmin, Vmax;
817 PSurf-Bounds( Umin, Umax, Vmin, Vmax);
818 BRepBuilderAPI_MakeFace MF(Surf,Umin, Umax, Vmin, Vmax);
821 @subsection occt_modalg_2_12 Projections
822 This package provides functionality for projecting points onto 2D and 3D curves and surfaces.
824 @subsubsection occt_modalg_2_12_1 Projection of a Point onto a Curve
825 *Geom2dAPI_ProjectPointOnCurve* allows calculation of all the normals projected from a point (*gp_Pnt2d*) onto a geometric curve (*Geom2d_Curve*). The calculation may be restricted to a given domain.
828 @image html /user_guides/modeling_algos/images/modeling_algos_image020.jpg "Normals from a point to a curve"
829 @image latex /user_guides/modeling_algos/images/modeling_algos_image020.jpg "Normals from a point to a curve"
832 The curve does not have to be a *Geom2d_TrimmedCurve*. The algorithm will function with any
833 class inheriting Geom2d_Curve.
835 @subsubsection occt_modalg_2_12_2 Geom2dAPI_ProjectPointOnCurve
836 This class may be instantiated as in the following example:
840 Handle(Geom2d_BezierCurve) C =
841 new Geom2d_BezierCurve(args);
842 Geom2dAPI_ProjectPointOnCurve Projector (P, C);
845 To restrict the search for normals to a given domain *[U1,U2]*, use the following constructor:
847 Geom2dAPI_ProjectPointOnCurve Projector (P, C, U1, U2);
849 Having thus created the *Geom2dAPI_ProjectPointOnCurve* object, we can now interrogate it.
851 #### Calling the number of solution points
854 Standard_Integer NumSolutions = Projector.NbPoints();
857 #### Calling the location of a solution point
859 The solutions are indexed in a range from *1* to *Projector.NbPoints()*. The point, which corresponds to a given *Index* may be found:
861 gp_Pnt2d Pn = Projector.Point(Index);
864 #### Calling the parameter of a solution point
866 For a given point corresponding to a given *Index*:
869 Standard_Real U = Projector.Parameter(Index);
872 This can also be programmed as:
876 Projector.Parameter(Index,U);
879 #### Calling the distance between the start and end points
881 We can find the distance between the initial point and a point, which corresponds to the given *Index*:
884 Standard_Real D = Projector.Distance(Index);
887 #### Calling the nearest solution point
890 This class offers a method to return the closest solution point to the starting point. This solution is accessed as follows:
892 gp_Pnt2d P1 = Projector.NearestPoint();
895 #### Calling the parameter of the nearest solution point
898 Standard_Real U = Projector.LowerDistanceParameter();
901 #### Calling the minimum distance from the point to the curve
904 Standard_Real D = Projector.LowerDistance();
907 @subsubsection occt_modalg_2_12_3 Redefined operators
909 Some operators have been redefined to find the closest solution.
911 *Standard_Real()* returns the minimum distance from the point to the curve.
914 Standard_Real D = Geom2dAPI_ProjectPointOnCurve (P,C);
917 *Standard_Integer()* returns the number of solutions.
921 Geom2dAPI_ProjectPointOnCurve (P,C);
924 *gp_Pnt2d()* returns the nearest solution point.
927 gp_Pnt2d P1 = Geom2dAPI_ProjectPointOnCurve (P,C);
930 Using these operators makes coding easier when you only need the nearest point. Thus:
932 Geom2dAPI_ProjectPointOnCurve Projector (P, C);
933 gp_Pnt2d P1 = Projector.NearestPoint();
935 can be written more concisely as:
937 gp_Pnt2d P1 = Geom2dAPI_ProjectPointOnCurve (P,C);
939 However, 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.
942 @subsubsection occt_modalg_2_12_4 Access to lower-level functionalities
944 If 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:
947 Extrema_ExtPC2d& TheExtrema = Projector.Extrema();
950 @subsubsection occt_modalg_2_12_5 GeomAPI_ProjectPointOnCurve
952 This class is instantiated as in the following example:
955 Handle(Geom_BezierCurve) C =
956 new Geom_BezierCurve(args);
957 GeomAPI_ProjectPointOnCurve Projector (P, C);
959 If you wish to restrict the search for normals to the given domain [U1,U2], use the following constructor:
961 GeomAPI_ProjectPointOnCurve Projector (P, C, U1, U2);
963 Having thus created the *GeomAPI_ProjectPointOnCurve* object, you can now interrogate it.
965 #### Calling the number of solution points
968 Standard_Integer NumSolutions = Projector.NbPoints();
971 #### Calling the location of a solution point
973 The solutions are indexed in a range from 1 to *Projector.NbPoints()*. The point, which corresponds to a given index, may be found:
975 gp_Pnt Pn = Projector.Point(Index);
978 #### Calling the parameter of a solution point
980 For a given point corresponding to a given index:
983 Standard_Real U = Projector.Parameter(Index);
986 This can also be programmed as:
989 Projector.Parameter(Index,U);
992 #### Calling the distance between the start and end point
994 The distance between the initial point and a point, which corresponds to a given index, may be found:
996 Standard_Real D = Projector.Distance(Index);
999 #### Calling the nearest solution point
1001 This class offers a method to return the closest solution point to the starting point. This solution is accessed as follows:
1003 gp_Pnt P1 = Projector.NearestPoint();
1006 #### Calling the parameter of the nearest solution point
1009 Standard_Real U = Projector.LowerDistanceParameter();
1012 #### Calling the minimum distance from the point to the curve
1015 Standard_Real D = Projector.LowerDistance();
1018 #### Redefined operators
1020 Some operators have been redefined to find the nearest solution.
1022 *Standard_Real()* returns the minimum distance from the point to the curve.
1025 Standard_Real D = GeomAPI_ProjectPointOnCurve (P,C);
1028 *Standard_Integer()* returns the number of solutions.
1030 Standard_Integer N = GeomAPI_ProjectPointOnCurve (P,C);
1033 *gp_Pnt2d()* returns the nearest solution point.
1036 gp_Pnt P1 = GeomAPI_ProjectPointOnCurve (P,C);
1038 Using these operators makes coding easier when you only need the nearest point. In this way,
1041 GeomAPI_ProjectPointOnCurve Projector (P, C);
1042 gp_Pnt P1 = Projector.NearestPoint();
1045 can be written more concisely as:
1047 gp_Pnt P1 = GeomAPI_ProjectPointOnCurve (P,C);
1049 In the second case, however, no intermediate *GeomAPI_ProjectPointOnCurve* object is created, and it is impossible to access other solutions points.
1051 #### Access to lower-level functionalities
1053 If 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:
1056 Extrema_ExtPC& TheExtrema = Projector.Extrema();
1059 @subsubsection occt_modalg_2_12_6 Projection of a Point on a Surface
1061 *GeomAPI_ProjectPointOnSurf* class allows calculation of all normals projected from a point from *gp_Pnt* onto a geometric surface from Geom_Surface.
1063 @image html /user_guides/modeling_algos/images/modeling_algos_image021.jpg "Projection of normals from a point to a surface"
1064 @image latex /user_guides/modeling_algos/images/modeling_algos_image021.jpg "Projection of normals from a point to a surface"
1066 Note that the surface does not have to be of *Geom_RectangularTrimmedSurface* type.
1067 The algorithm will function with any class inheriting Geom_Surface.
1069 *GeomAPI_ProjectPointOnSurf* is instantiated as in the following example:
1072 Handle (Geom_Surface) S = new Geom_BezierSurface(args);
1073 GeomAPI_ProjectPointOnSurf Proj (P, S);
1076 To restrict the search for normals within the given rectangular domain [U1, U2, V1, V2], use the following constructor:
1079 GeomAPI_ProjectPointOnSurf Proj (P, S, U1, U2, V1, V2);
1082 The values of U1, U2, V1 and V2 lie at or within their maximum and minimum limits, i.e.:
1084 Umin <= U1 < U2 <= Umax
1085 Vmin <= V1 < V2 <= Vmax
1087 Having thus created the *GeomAPI_ProjectPointOnSurf* object, you can interrogate it.
1089 #### Calling the number of solution points
1092 Standard_Integer NumSolutions = Proj.NbPoints();
1095 #### Calling the location of a solution point
1097 The solutions are indexed in a range from 1 to *Proj.NbPoints()*. The point corresponding to the given index may be found:
1100 gp_Pnt Pn = Proj.Point(Index);
1103 #### Calling the parameters of a solution point
1105 For a given point corresponding to the given index:
1109 Proj.Parameters(Index, U, V);
1112 #### Calling the distance between the start and end point
1115 The distance between the initial point and a point corresponding to the given index may be found:
1117 Standard_Real D = Projector.Distance(Index);
1120 #### Calling the nearest solution point
1122 This class offers a method, which returns the closest solution point to the starting point. This solution is accessed as follows:
1124 gp_Pnt P1 = Proj.NearestPoint();
1127 #### Calling the parameters of the nearest solution point
1131 Proj.LowerDistanceParameters (U, V);
1134 #### Calling the minimum distance from a point to the surface
1137 Standard_Real D = Proj.LowerDistance();
1140 #### Redefined operators
1142 Some operators have been redefined to help you find the nearest solution.
1144 *Standard_Real()* returns the minimum distance from the point to the surface.
1147 Standard_Real D = GeomAPI_ProjectPointOnSurf (P,S);
1150 *Standard_Integer()* returns the number of solutions.
1153 Standard_Integer N = GeomAPI_ProjectPointOnSurf (P,S);
1156 *gp_Pnt2d()* returns the nearest solution point.
1159 gp_Pnt P1 = GeomAPI_ProjectPointOnSurf (P,S);
1162 Using these operators makes coding easier when you only need the nearest point. In this way,
1165 GeomAPI_ProjectPointOnSurface Proj (P, S);
1166 gp_Pnt P1 = Proj.NearestPoint();
1169 can be written more concisely as:
1172 gp_Pnt P1 = GeomAPI_ProjectPointOnSurface (P,S);
1175 In the second case, however, no intermediate *GeomAPI_ProjectPointOnSurf* object is created, and it is impossible to access other solution points.
1177 @subsubsection occt_modalg_2_12_7 Access to lower-level functionalities
1179 If 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:
1182 Extrema_ExtPS& TheExtrema = Proj.Extrema();
1186 @subsubsection occt_modalg_2_12_8 Switching from 2d and 3d Curves
1187 The To2d and To3d methods are used to;
1189 * build a 2d curve from a 3d *Geom_Curve* lying on a *gp_Pln* plane
1190 * build a 3d curve from a *Geom2d_Curve* and a *gp_Pln* plane.
1192 These methods are called as follows:
1194 Handle(Geom2d_Curve) C2d = GeomAPI::To2d(C3d, Pln);
1195 Handle(Geom_Curve) C3d = GeomAPI::To3d(C2d, Pln);
1199 @section occt_modalg_3 Topological Tools
1201 Open CASCADE Technology topological tools include:
1203 * Standard topological objects combining topological data structure and boundary representation
1204 * Geometric Transformations
1205 * Conversion to NURBS geometry
1207 * Duplicating Shapes
1211 @subsection occt_modalg_3_1 Creation of Standard Topological Objects
1213 The standard topological objects include
1221 There are two root classes for their construction and modification:
1222 * 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.
1223 * The deferred *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.
1225 @subsubsection occt_modalg_3_1_1 Vertex
1227 *BRepBuilderAPI_MakeVertex* creates a new vertex from a 3D point from gp.
1230 TopoDS_Vertex V = BRepBuilderAPI_MakeVertex(P);
1233 This class always creates a new vertex and has no other methods.
1235 @subsubsection occt_modalg_3_1_2 Edge
1237 Use *BRepBuilderAPI_MakeEdge* to create from a curve and vertices. The basic method is to construct an edge from a curve, two vertices, and two parameters. All other constructions are derived from this one. The basic method and its arguments are described first, followed by the other methods. The BRepBuilderAPI_MakeEdge class can provide extra information and return an error status.
1239 #### Basic Edge construction
1242 Handle(Geom_Curve) C = ...; // a curve
1243 TopoDS_Vertex V1 = ...,V2 = ...;// two Vertices
1244 Standard_Real p1 = ..., p2 = ..;// two parameters
1245 TopoDS_Edge E = BRepBuilderAPI_MakeEdge(C,V1,V2,p1,p2);
1248 where 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.
1250 @image html /user_guides/modeling_algos/images/modeling_algos_image022.jpg "Basic Edge Construction"
1251 @image latex /user_guides/modeling_algos/images/modeling_algos_image022.jpg "Basic Edge Construction"
1253 The following rules apply to the arguments:
1256 * Must not be a Null Handle.
1257 * If the curve is a trimmed curve, the basis curve is used.
1260 * 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()).
1261 * 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).
1264 * Must be increasing and in the range of the curve, i.e.:
1266 C->FirstParameter() <= p1 < p2 <= C->LastParameter()
1269 * If the parameters are decreasing, the Vertices are switched, i.e. V2 becomes V1 and V1 becomes V2.
1270 * 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.
1271 * Can be infinite but the corresponding vertex must be Null (see above).
1272 * The distance between the Vertex 3d location and the point evaluated on the curve with the parameter must be lower than the default precision.
1274 The figure below illustrates two special cases, a semi-infinite edge and an edge on a periodic curve.
1276 @image html /user_guides/modeling_algos/images/modeling_algos_image023.jpg "Infinite and Periodic Edges"
1277 @image latex /user_guides/modeling_algos/images/modeling_algos_image023.jpg "Infinite and Periodic Edges"
1280 #### Other Edge constructions
1282 *BRepBuilderAPI_MakeEdge* class provides methods, which are all simplified calls of the previous one:
1284 * The parameters can be omitted. They are computed by projecting the vertices on the curve.
1285 * 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.
1286 * The vertices or points can be omitted if the parameters are given. The points are computed by evaluating the parameters on the curve.
1287 * The vertices or points and the parameters can be omitted. The first and the last parameters of the curve are used.
1289 The five following methods are thus derived from the basic construction:
1292 Handle(Geom_Curve) C = ...; // a curve
1293 TopoDS_Vertex V1 = ...,V2 = ...;// two Vertices
1294 Standard_Real p1 = ..., p2 = ..;// two parameters
1295 gp_Pnt P1 = ..., P2 = ...;// two points
1297 // project the vertices on the curve
1298 E = BRepBuilderAPI_MakeEdge(C,V1,V2);
1299 // Make vertices from points
1300 E = BRepBuilderAPI_MakeEdge(C,P1,P2,p1,p2);
1301 // Make vertices from points and project them
1302 E = BRepBuilderAPI_MakeEdge(C,P1,P2);
1303 // Computes the points from the parameters
1304 E = BRepBuilderAPI_MakeEdge(C,p1,p2);
1305 // Make an edge from the whole curve
1306 E = BRepBuilderAPI_MakeEdge(C);
1310 Six 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:
1312 *gp_Lin* creates a *Geom_Line*
1313 *gp_Circ* creates a *Geom_Circle*
1314 *gp_Elips* creates a *Geom_Ellipse*
1315 *gp_Hypr* creates a *Geom_Hyperbola*
1316 *gp_Parab* creates a *Geom_Parabola*
1318 There 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.
1322 TopoDS_Vertex V1 = ...,V2 = ...;// two Vertices
1323 gp_Pnt P1 = ..., P2 = ...;// two points
1326 // linear edge from two vertices
1327 E = BRepBuilderAPI_MakeEdge(V1,V2);
1329 // linear edge from two points
1330 E = BRepBuilderAPI_MakeEdge(P1,P2);
1333 #### Other information and error status
1335 If *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.
1337 The *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:
1339 * **EdgeDone** - No error occurred, *IsDone* returns True.
1340 * **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.
1341 * **ParameterOutOfRange** - The given parameters are not in the range *C->FirstParameter()*, *C->LastParameter()*
1342 * **DifferentPointsOnClosedCurve** - The two vertices or points have different locations but they are the extremities of a closed curve.
1343 * **PointWithInfiniteParameter** - A finite coordinate point was associated with an infinite parameter (see the Precision package for a definition of infinite values).
1344 * **DifferentsPointAndParameter** - The distance of the 3D point and the point evaluated on the curve with the parameter is greater than the precision.
1345 * **LineThroughIdenticPoints** - Two identical points were given to define a line (construction of an edge without curve), *gp::Resolution* is used to test confusion .
1347 The 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.
1349 @image html /user_guides/modeling_algos/images/modeling_algos_image024.jpg "Creating a Wire"
1350 @image latex /user_guides/modeling_algos/images/modeling_algos_image024.jpg "Creating a Wire"
1353 #include <BRepBuilderAPI_MakeEdge.hxx>
1354 #include <TopoDS_Shape.hxx>
1355 #include <gp_Circ.hxx>
1357 #include <TopoDS_Wire.hxx>
1358 #include <TopTools_Array1OfShape.hxx>
1359 #include <BRepBuilderAPI_MakeWire.hxx>
1361 // Use MakeArc method to make an edge and two vertices
1362 void MakeArc(Standard_Real x,Standard_Real y,
1365 TopoDS_Shape& E,
1366 TopoDS_Shape& V1,
1367 TopoDS_Shape& V2)
1369 gp_Ax2 Origin = gp::XOY();
1370 gp_Vec Offset(x, y, 0.);
1371 Origin.Translate(Offset);
1372 BRepBuilderAPI_MakeEdge
1373 ME(gp_Circ(Origin,R), ang, ang+PI/2);
1379 TopoDS_Wire MakeFilletedRectangle(const Standard_Real H,
1380 const Standard_Real L,
1381 const Standard_Real R)
1383 TopTools_Array1OfShape theEdges(1,8);
1384 TopTools_Array1OfShape theVertices(1,8);
1386 // First create the circular edges and the vertices
1387 // using the MakeArc function described above.
1388 void MakeArc(Standard_Real, Standard_Real,
1389 Standard_Real, Standard_Real,
1390 TopoDS_Shape&, TopoDS_Shape&, TopoDS_Shape&);
1392 Standard_Real x = L/2 - R, y = H/2 - R;
1393 MakeArc(x,-y,R,3.*PI/2.,theEdges(2),theVertices(2),
1395 MakeArc(x,y,R,0.,theEdges(4),theVertices(4),
1397 MakeArc(-x,y,R,PI/2.,theEdges(6),theVertices(6),
1399 MakeArc(-x,-y,R,PI,theEdges(8),theVertices(8),
1401 // Create the linear edges
1402 for (Standard_Integer i = 1; i <= 7; i += 2)
1404 theEdges(i) = BRepBuilderAPI_MakeEdge
1405 (TopoDS::Vertex(theVertices(i)),TopoDS::Vertex
1406 (theVertices(i+1)));
1408 // Create the wire using the BRepBuilderAPI_MakeWire
1409 BRepBuilderAPI_MakeWire MW;
1410 for (i = 1; i <= 8; i++)
1412 MW.Add(TopoDS::Edge(theEdges(i)));
1418 @subsubsection occt_modalg_3_1_3 Edge 2D
1420 Use *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).
1422 *BRepBuilderAPI_MakeEdge2d* class is strictly similar to BRepBuilderAPI_MakeEdge, but it uses 2D geometry from gp and Geom2d instead of 3D geometry.
1424 @subsubsection occt_modalg_3_1_4 Polygon
1426 *BRepBuilderAPI_MakePolygon* class is used to build polygonal wires from vertices or points. Points are automatically changed to vertices as in *BRepBuilderAPI_MakeEdge*.
1428 The 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.
1431 #include <TopoDS_Wire.hxx>
1432 #include <BRepBuilderAPI_MakePolygon.hxx>
1433 #include <TColgp_Array1OfPnt.hxx>
1435 TopoDS_Wire ClosedPolygon(const TColgp_Array1OfPnt& Points)
1437 BRepBuilderAPI_MakePolygon MP;
1438 for(Standard_Integer i=Points.Lower();i=Points.Upper();i++)
1447 Short-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.
1451 Example of a closed triangle from three vertices:
1453 TopoDS_Wire W = BRepBuilderAPI_MakePolygon(V1,V2,V3,Standard_True);
1456 Example of an open polygon from four points:
1458 TopoDS_Wire W = BRepBuilderAPI_MakePolygon(P1,P2,P3,P4);
1461 *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*.
1463 When 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.
1465 @subsubsection occt_modalg_3_1_5 Face
1467 Use *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.
1469 #### Basic face construction
1471 A 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.
1474 Handle(Geom_Surface) S = ...; // a surface
1475 Standard_Real umin,umax,vmin,vmax; // parameters
1476 TopoDS_Face F = BRepBuilderAPI_MakeFace(S,umin,umax,vmin,vmax);
1479 @image html /user_guides/modeling_algos/images/modeling_algos_image025.jpg "Basic Face Construction"
1480 @image latex /user_guides/modeling_algos/images/modeling_algos_image025.jpg "Basic Face Construction"
1482 To make a face from the natural boundary of a surface, the parameters are not required:
1485 Handle(Geom_Surface) S = ...; // a surface
1486 TopoDS_Face F = BRepBuilderAPI_MakeFace(S);
1489 Constraints on the parameters are similar to the constraints in *BRepBuilderAPI_MakeEdge*.
1490 * *umin,umax (vmin,vmax)* must be in the range of the surface and must be increasing.
1491 * On a *U (V)* periodic surface *umin* and *umax (vmin,vmax)* are adjusted.
1492 * *umin, umax, vmin, vmax* can be infinite. There will be no edge in the corresponding direction.
1495 #### Other face constructions
1497 The two basic constructions (from a surface and from a surface and parameters) are implemented for all the gp package surfaces, which are transformed in the corresponding Surface from Geom.
1499 | :------------------- | :----------- | :------------- |
1500 | *gp_Pln* | | *Geom_Plane* |
1501 | *gp_Cylinder* | | *Geom_CylindricalSurface* |
1502 | *gp_Cone* | creates a | *Geom_ConicalSurface* |
1503 | *gp_Sphere* | | *Geom_SphericalSurface* |
1504 | *gp_Torus* | | *Geom_ToroidalSurface* |
1506 Once 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.
1509 gp_Cylinder C = ..; // a cylinder
1510 TopoDS_Wire W = ...;// a wire
1511 BRepBuilderAPI_MakeFace MF(C);
1516 More 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.
1518 If there is no parametric curve for an edge of the wire on the Face it is computed by projection.
1520 For one wire, a simple syntax is provided to construct the face from the surface and the wire. The above lines could be written:
1523 TopoDS_Face F = BRepBuilderAPI_MakeFace(C,W);
1526 A 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*.
1529 #include <TopoDS_Face.hxx>
1530 #include <TColgp_Array1OfPnt.hxx>
1531 #include <BRepBuilderAPI_MakePolygon.hxx>
1532 #include <BRepBuilderAPI_MakeFace.hxx>
1534 TopoDS_Face PolygonalFace(const TColgp_Array1OfPnt& thePnts)
1536 BRepBuilderAPI_MakePolygon MP;
1537 for(Standard_Integer i=thePnts.Lower();
1538 i<=thePnts.Upper(); i++)
1543 TopoDS_Face F = BRepBuilderAPI_MakeFace(MP.Wire());
1548 The 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:
1551 TopoDS_Face F = ...; // a face
1552 TopoDS_Wire W = ...; // a wire
1553 F = BRepBuilderAPI_MakeFace(F,W);
1556 To 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.
1560 The Error method returns an error status, which is a term from the *BRepBuilderAPI_FaceError* enumeration.
1562 * *FaceDone* - no error occurred.
1563 * *NoFace* - no initialization of the algorithm; an empty constructor was used.
1564 * *NotPlanar* - no surface was given and the wire was not planar.
1565 * *CurveProjectionFailed* - no curve was found in the parametric space of the surface for an edge.
1566 * *ParametersOutOfRange* - the parameters *umin, umax, vmin, vmax* are out of the surface.
1568 @subsubsection occt_modalg_3_1_6 Wire
1569 The 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.
1571 Up to four edges can be used directly, for example:
1574 TopoDS_Wire W = BRepBuilderAPI_MakeWire(E1,E2,E3,E4);
1577 For 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).
1580 TopTools_Array1OfShapes theEdges;
1581 BRepBuilderAPI_MakeWire MW;
1582 for (Standard_Integer i = theEdge.Lower();
1583 i <= theEdges.Upper(); i++)
1584 MW.Add(TopoDS::Edge(theEdges(i));
1588 The 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:
1591 #include <TopoDS_Wire.hxx>
1592 #include <BRepBuilderAPI_MakeWire.hxx>
1594 TopoDS_Wire MergeWires (const TopoDS_Wire& W1,
1595 const TopoDS_Wire& W2)
1597 BRepBuilderAPI_MakeWire MW(W1);
1603 *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.
1605 BRepBuilderAPI_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.
1607 The Error method returns a term of the *BRepBuilderAPI_WireError* enumeration:
1608 *WireDone* - no error occurred.
1609 *EmptyWire* - no initialization of the algorithm, an empty constructor was used.
1610 *DisconnectedWire* - the last added edge was not connected to the wire.
1611 *NonManifoldWire* - the wire with some singularity.
1613 @subsubsection occt_modalg_3_1_7 Shell
1614 The shell is a composite shape built not from a geometry, but by the assembly of faces.
1615 Use *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.
1617 @subsubsection occt_modalg_3_1_8 Solid
1618 The 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.
1621 @subsubsection occt_modalg_3_2 Modification Operators
1623 @subsubsection occt_modalg_3_2_1 Transformation
1624 *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.
1626 The following example deals with the rotation of shapes.
1630 TopoDS_Shape myShape1 = ...;
1631 // The original shape 1
1632 TopoDS_Shape myShape2 = ...;
1633 // The original shape2
1635 T.SetRotation(gp_Ax1(gp_Pnt(0.,0.,0.),gp_Vec(0.,0.,1.)),
1637 BRepBuilderAPI_Transformation theTrsf(T);
1638 theTrsf.Perform(myShape1);
1639 TopoDS_Shape myNewShape1 = theTrsf.Shape()
1640 theTrsf.Perform(myShape2,Standard_True);
1641 // Here duplication is forced
1642 TopoDS_Shape myNewShape2 = theTrsf.Shape()
1645 @subsubsection occt_modalg_3_2_2 Duplication
1647 Use the *BRepBuilderAPI_Copy* class to duplicate a shape. A new shape is thus created.
1648 In the following example, a solid is copied:
1651 TopoDS Solid MySolid;
1652 ....// Creates a solid
1654 TopoDS_Solid myCopy = BRepBuilderAPI_Copy(mySolid);
1657 @section occt_modalg_4 Construction of Primitives
1658 @subsection occt_modalg_4_1 Making Primitives
1659 @subsubsection occt_modalg_4_1_1 Box
1661 BRepPrimAPI_MakeBox class allows building a parallelepiped box. The result is either a Shell or a Solid. There are four ways to build a box:
1663 * From three dimensions dx,dy,dz. The box is parallel to the axes and extends for [0,dx] [0,dy] [0,dz].
1664 * From a point and three dimensions. The same as above but the point is the new origin.
1665 * From two points, the box is parallel to the axes and extends on the intervals defined by the coordinates of the two points.
1666 * 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.
1668 An error is raised if the box is flat in any dimension using the default precision. The following code shows how to create a box:
1670 TopoDS_Solid theBox = BRepPrimAPI_MakeBox(10.,20.,30.);
1673 The four methods to build a box are shown in the figure:
1675 @image html /user_guides/modeling_algos/images/modeling_algos_image026.jpg "Making Boxes"
1676 @image latex /user_guides/modeling_algos/images/modeling_algos_image026.jpg "Making Boxes"
1678 @subsubsection occt_modalg_4_1_2 Wedge
1679 *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.
1681 The following figure shows two ways to build wedges. One is to add an ltx dimension, which is the length in x of the face at dy. The second is to add xmin, xmax, zmin, zmax to describe the face at dy.
1683 The first method is a particular case of the second with xmin = 0, xmax = ltx, zmin = 0, zmax = dz.
1684 To make a centered pyramid you can use xmin = xmax = dx / 2, zmin = zmax = dz / 2.
1686 @image html /user_guides/modeling_algos/images/modeling_algos_image027.jpg "Making Wedges"
1687 @image latex /user_guides/modeling_algos/images/modeling_algos_image027.jpg "Making Wedges"
1689 @subsubsection occt_modalg_4_1_3 Rotation object
1690 *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.
1692 The particular constructions of these primitives are described, but they all have some common arguments, which are:
1694 * A system of coordinates, where the Z axis is the rotation axis..
1695 * An angle in the range [0,2*PI].
1696 * A vmin, vmax parameter range on the curve.
1698 The 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.
1700 @image html /user_guides/modeling_algos/images/modeling_algos_image028.jpg "MakeOneAxis arguments"
1701 @image latex /user_guides/modeling_algos/images/modeling_algos_image028.jpg "MakeOneAxis arguments"
1703 @subsubsection occt_modalg_4_1_4 Cylinder
1704 *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:
1706 * Radius and height, to build a full cylinder.
1707 * Radius, height and angle to build a portion of a cylinder.
1709 The 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, a length of DY, and a radius R.
1713 Standard_Real X = 20, Y = 10, Z = 15, R = 10, DY = 30;
1714 // Make the system of coordinates
1715 gp_Ax2 axes = gp::ZOX();
1716 axes.Translate(gp_Vec(X,Y,Z));
1718 BRepPrimAPI_MakeCylinder(axes,R,DY,PI/2.);
1720 @image html /user_guides/modeling_algos/images/modeling_algos_image029.jpg "Cylinder"
1721 @image latex /user_guides/modeling_algos/images/modeling_algos_image029.jpg "Cylinder"
1723 @subsubsection occt_modalg_4_1_5 Cone
1724 *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:
1726 * Two radii and height, to build a full cone. One of the radii can be null to make a sharp cone.
1727 * Radii, height and angle to build a truncated cone.
1729 The following code builds the solid cone of the figure, which is located in the default system with radii R1 and R2 and height H.
1732 Standard_Real R1 = 30, R2 = 10, H = 15;
1733 TopoDS_Solid S = BRepPrimAPI_MakeCone(R1,R2,H);
1736 @image html /user_guides/modeling_algos/images/modeling_algos_image030.jpg "Cone"
1737 @image latex /user_guides/modeling_algos/images/modeling_algos_image030.jpg "Cone"
1739 @subsubsection occt_modalg_4_1_6 Sphere
1740 *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:
1742 * From a radius - builds a full sphere.
1743 * From a radius and an angle - builds a lune (digon).
1744 * From a radius and two angles - builds a wraparound spherical segment between two latitudes. The angles a1, a2 must follow the relation: PI/2 <= a1 < a2 <= PI/2.
1745 * From a radius and three angles - a combination of two previous methods builds a portion of spherical segment.
1747 The following code builds four spheres from a radius and three angles.
1750 Standard_Real R = 30, ang =
1751 PI/2, a1 = -PI/2.3, a2 = PI/4;
1752 TopoDS_Solid S1 = BRepPrimAPI_MakeSphere(R);
1753 TopoDS_Solid S2 = BRepPrimAPI_MakeSphere(R,ang);
1754 TopoDS_Solid S3 = BRepPrimAPI_MakeSphere(R,a1,a2);
1755 TopoDS_Solid S4 = BRepPrimAPI_MakeSphere(R,a1,a2,ang);
1758 Note that we could equally well choose to create Shells instead of Solids.
1760 @image html /user_guides/modeling_algos/images/modeling_algos_image031.jpg "Examples of Spheres"
1761 @image latex /user_guides/modeling_algos/images/modeling_algos_image031.jpg "Examples of Spheres"
1764 @subsubsection occt_modalg_4_1_7 Torus
1765 *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:
1767 * Two radii - builds a full torus.
1768 * Two radii and an angle - builds an angular torus segment.
1769 * 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.
1770 * Two radii and three angles - a combination of two previous methods builds a portion of torus segment.
1772 @image html /user_guides/modeling_algos/images/modeling_algos_image032.gif "Examples of Tori"
1773 @image latex /user_guides/modeling_algos/images/modeling_algos_image032.gif "Examples of Tori"
1775 The following code builds four toroidal shells from two radii and three angles.
1778 Standard_Real R1 = 30, R2 = 10, ang = PI, a1 = 0,
1780 TopoDS_Shell S1 = BRepPrimAPI_MakeTorus(R1,R2);
1781 TopoDS_Shell S2 = BRepPrimAPI_MakeTorus(R1,R2,ang);
1782 TopoDS_Shell S3 = BRepPrimAPI_MakeTorus(R1,R2,a1,a2);
1784 BRepPrimAPI_MakeTorus(R1,R2,a1,a2,ang);
1787 Note that we could equally well choose to create Solids instead of Shells.
1789 @subsubsection occt_modalg_4_1_8 Revolution
1790 *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.
1792 The 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:
1794 * From a curve, use the full curve and make a full rotation.
1795 * From a curve and an angle of rotation.
1796 * From a curve and two parameters to trim the curve. The two parameters must be growing and within the curve range.
1797 * From a curve, two parameters, and an angle. The two parameters must be growing and within the curve range.
1800 @subsection occt_modalg_4_2 Sweeping: Prism, Revolution and Pipe
1801 @subsubsection occt_modalg_4_2_1 Sweeping
1803 Sweeps 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:
1805 * Vertices generate Edges
1806 * Edges generate Faces.
1807 * Wires generate Shells.
1808 * Faces generate Solids.
1809 * Shells generate Composite Solids
1811 It is forbidden to sweep Solids and Composite Solids. A Compound generates a Compound with the sweep of all its elements.
1813 @image html /user_guides/modeling_algos/images/modeling_algos_image033.jpg "Generating a sweep"
1814 @image latex /user_guides/modeling_algos/images/modeling_algos_image033.jpg "Generating a sweep"
1816 *BRepPrimAPI_MakeSweep class* is a deferred class used as a root of the the following sweep classes:
1817 * *BRepPrimAPI_MakePrism* - produces a linear sweep
1818 * *BRepPrimAPI_MakeRevol* - produces a rotational sweep
1819 * *BRepPrimAPI_MakePipe* - produces a general sweep.
1822 @subsubsection occt_modalg_4_2_2 Prism
1823 *BRepPrimAPI_MakePrism* class allows creating a linear **prism** from a shape and a vector or a direction.
1824 * A vector allows creating a finite prism;
1825 * 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).
1827 The following code creates a finite, an infinite and a semi-infinite solid using a face, a direction and a length
1830 TopoDS_Face F = ..; // The swept face
1831 gp_Dir direc(0,0,1);
1832 Standard_Real l = 10;
1833 // create a vector from the direction and the length
1836 TopoDS_Solid P1 = BRepPrimAPI_MakePrism(F,v);
1838 TopoDS_Solid P2 = BRepPrimAPI_MakePrism(F,direc);
1840 TopoDS_Solid P3 = BRepPrimAPI_MakePrism(F,direc,Standard_False);
1844 @image html /user_guides/modeling_algos/images/modeling_algos_image034.jpg "Finite, infinite, and semi-infinite prisms"
1845 @image latex /user_guides/modeling_algos/images/modeling_algos_image034.jpg "Finite, infinite, and semi-infinite prisms"
1847 @subsubsection occt_modalg_4_2_3 Rotation
1848 *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.
1850 *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.
1853 TopoDS_Face F = ...; // the profile
1854 gp_Ax1 axis(gp_Pnt(0,0,0),gp_Dir(0,0,1));
1855 Standard_Real ang = PI/3;
1856 TopoDS_Solid R1 = BRepPrimAPI_MakeRevol(F,axis);
1858 TopoDS_Solid R2 = BRepPrimAPI_MakeRevol(F,axis,ang);
1861 @image html /user_guides/modeling_algos/images/modeling_algos_image035.jpg "Full and partial rotation"
1862 @image latex /user_guides/modeling_algos/images/modeling_algos_image035.jpg "Full and partial rotation"
1864 @section occt_modalg_5 Boolean Operations
1866 Boolean operations are used to create new shapes from the combinations of two shapes.
1868 | Fuse | all points in S1 or S2 |
1869 | Common | all points in S1 and S2 |
1870 | Cut S1 by S2| all points in S1 and not in S2 |
1872 BRepAlgoAPI_BooleanOperation class is the deferred root class for Boolean operations.
1874 @image html /user_guides/modeling_algos/images/modeling_algos_image036.jpg "Boolean Operations"
1875 @image latex /user_guides/modeling_algos/images/modeling_algos_image036.jpg "Boolean Operations"
1877 @subsection occt_modalg_5_1 Fuse
1879 *BRepAlgoAPI_Fuse* performs the Fuse operation.
1881 TopoDS_Shape A = ..., B = ...;
1882 TopoDS_Shape S = BRepAlgoAPI_Fuse(A,B);
1885 @subsection occt_modalg_5_2 Common
1886 *BRepAlgoAPI_Common* performs the Common operation.
1889 TopoDS_Shape A = ..., B = ...;
1890 TopoDS_Shape S = BRepAlgoAPI_Common(A,B);
1893 @subsection occt_modalg_5_3 Cut
1894 *BRepAlgoAPI_Cut* performs the Cut operation.
1897 TopoDS_Shape A = ..., B = ...;
1898 TopoDS_Shape S = BRepAlgoAPI_Cut(A,B);
1901 @subsection occt_modalg_5_4 Section
1903 *BRepAlgoAPI_Section* performs the section, described as a *TopoDS_Compound* made of *TopoDS_Edge*.
1905 @image html /user_guides/modeling_algos/images/modeling_algos_image037.jpg "Section operation"
1906 @image latex /user_guides/modeling_algos/images/modeling_algos_image037.jpg "Section operation"
1909 TopoDS_Shape A = ..., TopoDS_ShapeB = ...;
1910 TopoDS_Shape S = BRepAlgoAPI_Section(A,B);
1913 @section occt_modalg_6 Fillets and Chamfers
1914 @subsection occt_modalg_6_1 Fillets
1915 @subsection occt_modalg_6_1_1 Fillet on shape
1917 A fillet is a smooth face replacing a sharp edge.
1919 *BRepFilletAPI_MakeFillet* class allows filleting a shape.
1921 To 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.
1923 A 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.
1925 @image html /user_guides/modeling_algos/images/modeling_algos_image038.jpg "Filleting two edges using radii r1 and r2."
1926 @image latex /user_guides/modeling_algos/images/modeling_algos_image038.jpg "Filleting two edges using radii r1 and r2."
1928 In the following example a filleted box with dimensions a,b,c and radius r is created.
1934 #include <TopoDS_Shape.hxx>
1935 #include <TopoDS.hxx>
1936 #include <BRepPrimAPI_MakeBox.hxx>
1937 #include <TopoDS_Solid.hxx>
1938 #include <BRepFilletAPI_MakeFillet.hxx>
1939 #include <TopExp_Explorer.hxx>
1941 TopoDS_Shape FilletedBox(const Standard_Real a,
1942 const Standard_Real b,
1943 const Standard_Real c,
1944 const Standard_Real r)
1946 TopoDS_Solid Box = BRepPrimAPI_MakeBox(a,b,c);
1947 BRepFilletAPI_MakeFillet MF(Box);
1949 // add all the edges to fillet
1950 TopExp_Explorer ex(Box,TopAbs_EDGE);
1953 MF.Add(r,TopoDS::Edge(ex.Current()));
1960 @image html /user_guides/modeling_algos/images/modeling_algos_image039.jpg "Fillet with constant radius"
1961 @image latex /user_guides/modeling_algos/images/modeling_algos_image039.jpg "Fillet with constant radius"
1963 #### Changing radius
1967 void CSampleTopologicalOperationsDoc::OnEvolvedblend1()
1969 TopoDS_Shape theBox = BRepPrimAPI_MakeBox(200,200,200);
1971 BRepFilletAPI_MakeFillet Rake(theBox);
1972 ChFi3d_FilletShape FSh = ChFi3d_Rational;
1973 Rake.SetFilletShape(FSh);
1975 TColgp_Array1OfPnt2d ParAndRad(1, 6);
1976 ParAndRad(1).SetCoord(0., 10.);
1977 ParAndRad(1).SetCoord(50., 20.);
1978 ParAndRad(1).SetCoord(70., 20.);
1979 ParAndRad(1).SetCoord(130., 60.);
1980 ParAndRad(1).SetCoord(160., 30.);
1981 ParAndRad(1).SetCoord(200., 20.);
1983 TopExp_Explorer ex(theBox,TopAbs_EDGE);
1984 Rake.Add(ParAndRad, TopoDS::Edge(ex.Current()));
1985 TopoDS_Shape evolvedBox = Rake.Shape();
1989 @image html /user_guides/modeling_algos/images/modeling_algos_image040.jpg "Fillet with changing radius"
1990 @image latex /user_guides/modeling_algos/images/modeling_algos_image040.jpg "Fillet with changing radius"
1992 @subsection occt_modalg_6_1_2 Chamfer
1994 A chamfer is a rectilinear edge replacing a sharp vertex of the face.
1996 The use of *BRepFilletAPI_MakeChamfer* class is similar to the use of *BRepFilletAPI_MakeFillet*, except for the following:
1997 * The surfaces created are ruled and not smooth.
1998 * The *Add* syntax for selecting edges requires one or two distances, one edge and one face (contiguous to the edge).
2002 Add(d1, d2, E, F) with d1 on the face F.
2005 @image html /user_guides/modeling_algos/images/modeling_algos_image041.jpg "Chamfer"
2006 @image latex /user_guides/modeling_algos/images/modeling_algos_image041.jpg "Chamfer"
2008 @subsection occt_modalg_6_1_3 Fillet on a planar face
2010 *BRepFilletAPI_MakeFillet2d* class allows constructing fillets and chamfers on planar faces.
2011 To create a fillet on planar face: define it, indicate, which vertex is to be deleted, and give the fillet radius with *AddFillet* method.
2013 A chamfer can be calculated with *AddChamfer* method. It can be described by
2014 * two edges and two distances
2015 * one edge, one vertex, one distance and one angle.
2016 Fillets and chamfers are calculated when addition is complete.
2018 If 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:
2020 BRepFilletAPI_MakeFillet2d builder;
2021 builder.Init(F1,F2);
2028 #include “BRepPrimAPI_MakeBox.hxx”
2029 #include “TopoDS_Shape.hxx”
2030 #include “TopExp_Explorer.hxx”
2031 #include “BRepFilletAPI_MakeFillet2d.hxx”
2032 #include “TopoDS.hxx”
2033 #include “TopoDS_Solid.hxx”
2035 TopoDS_Shape FilletFace(const Standard_Real a,
2036 const Standard_Real b,
2037 const Standard_Real c,
2038 const Standard_Real r)
2041 TopoDS_Solid Box = BRepPrimAPI_MakeBox (a,b,c);
2042 TopExp_Explorer ex1(Box,TopAbs_FACE);
2044 const TopoDS_Face& F = TopoDS::Face(ex1.Current());
2045 BRepFilletAPI_MakeFillet2d MF(F);
2046 TopExp_Explorer ex2(F, TopAbs_VERTEX);
2049 MF.AddFillet(TopoDS::Vertex(ex2.Current()),r);
2057 @section occt_modalg_7 Offsets, Drafts, Pipes and Evolved shapes
2058 @subsection occt_modalg_7_1 Shelling
2060 Shelling 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.
2062 The constructor *BRepOffsetAPI_MakeThickSolid* shelling operator takes the solid, the list of faces to remove and an offset value as input.
2065 TopoDS_Solid SolidInitial = ...;
2067 Standard_Real Of = ...;
2068 TopTools_ListOfShape LCF;
2069 TopoDS_Shape Result;
2070 Standard_Real Tol = Precision::Confusion();
2072 for (Standard_Integer i = 1 ;i <= n; i++) {
2073 TopoDS_Face SF = ...; // a face from SolidInitial
2077 Result = BRepOffsetAPI_MakeThickSolid (SolidInitial,
2083 @image html /user_guides/modeling_algos/images/modeling_algos_image042.jpg "Shelling"
2084 @image latex /user_guides/modeling_algos/images/modeling_algos_image042.jpg "Shelling"
2087 @subsection occt_modalg_7_2 Draft Angle
2089 *BRepOffsetAPI_DraftAngle* class allows modifying a shape by applying draft angles to its planar, cylindrical and conical faces.
2092 The class is created or initialized from a shape, then faces to be modified are added; for each face, three arguments are used:
2093 * Direction: the direction with which the draft angle is measured
2094 * Angle: value of the angle
2095 * Neutral plane: intersection between the face and the neutral plane is invariant.
2097 The following code places a draft angle on several faces of a shape; the same direction, angle and neutral plane are used for each face:
2100 TopoDS_Shape myShape = ...
2101 // The original shape
2102 TopTools_ListOfShape ListOfFace;
2103 // Creation of the list of faces to be modified
2106 gp_Dir Direc(0.,0.,1.);
2108 Standard_Real Angle = 5.*PI/180.;
2110 gp_Pln Neutral(gp_Pnt(0.,0.,5.), Direc);
2111 // Neutral plane Z=5
2112 BRepOffsetAPI_DraftAngle theDraft(myShape);
2113 TopTools_ListIteratorOfListOfShape itl;
2114 for (itl.Initialize(ListOfFace); itl.More(); itl.Next()) {
2115 theDraft.Add(TopoDS::Face(itl.Value()),Direc,Angle,Neutral);
2116 if (!theDraft.AddDone()) {
2117 // An error has occurred. The faulty face is given by // ProblematicShape
2121 if (!theDraft.AddDone()) {
2122 // An error has occurred
2123 TopoDS_Face guilty = theDraft.ProblematicShape();
2127 if (!theDraft.IsDone()) {
2128 // Problem encountered during reconstruction
2132 TopoDS_Shape myResult = theDraft.Shape();
2137 @image html /user_guides/modeling_algos/images/modeling_algos_image043.jpg "DraftAngle"
2138 @image latex /user_guides/modeling_algos/images/modeling_algos_image043.jpg "DraftAngle"
2140 @subsection occt_modalg_7_3 Pipe Constructor
2142 *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.
2144 The angle between the spine and the profile is preserved throughout the pipe.
2147 TopoDS_Wire Spine = ...;
2148 TopoDS_Shape Profile = ...;
2149 TopoDS_Shape Pipe = BRepOffsetAPI_MakePipe(Spine,Profile);
2152 @image html /user_guides/modeling_algos/images/modeling_algos_image044.jpg "Example of a Pipe"
2153 @image latex /user_guides/modeling_algos/images/modeling_algos_image044.jpg "Example of a Pipe"
2155 @subsection occt_modalg_7_4 Evolved Solid
2157 *BRepOffsetAPI_MakeEvolved* class allows creating an evolved solid from a Spine (planar face or wire) and a profile (wire).
2159 The evolved solid is an unlooped sweep generated by the spine and the profile.
2161 The 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.
2163 The reference axes of the profile can be defined following two distinct modes:
2165 * The reference axes of the profile are the origin axes.
2166 * The references axes of the profile are calculated as follows:
2167 + the origin is given by the point on the spine which is the closest to the profile
2168 + the X axis is given by the tangent to the spine at the point defined above
2169 + the Z axis is the normal to the plane which contains the spine.
2172 TopoDS_Face Spine = ...;
2173 TopoDS_Wire Profile = ...;
2175 BRepOffsetAPI_MakeEvolved(Spine,Profile);
2178 @section occt_modalg_8 Sewing operators
2179 @subsection occt_modalg_8_1 Sewing
2181 *BRepOffsetAPI_Sewing* class allows sewing TopoDS Shapes together along their common edges. The edges can be partially shared as in the following example.
2183 @image html /user_guides/modeling_algos/images/modeling_algos_image045.jpg "Shapes with partially shared edges"
2184 @image latex /user_guides/modeling_algos/images/modeling_algos_image045.jpg "Shapes with partially shared edges"
2186 The constructor takes as arguments the tolerance (default value is 10-6) and a flag, which is used to mark the degenerate shapes.
2188 The following methods are used in this class:
2189 * *Add* adds shapes, as it is needed;
2190 * *Perform* forces calculation of the sewed shape.
2191 * *SewedShape* returns the result.
2193 Additional methods can be used to give information on the number of free boundaries, multiple edges and degenerate shapes.
2195 @subsection occt_modalg_8_2 Find Contiguous Edges
2196 *BRepOffsetAPI_FindContiguousEdges* class is used to find edges, which coincide among a set of shapes within the given tolerance; these edges can be analyzed for tangency, continuity (C1, G2, etc.)...
2198 The constructor takes as arguments the tolerance defining the edge proximity (10-6 by default) and a flag used to mark degenerated shapes.
2200 The following methods are used in this class:
2201 * *Add* adds shapes, which are to be analyzed;
2202 * *NbEdges* returns the total number of edges;
2203 * *NbContiguousEdges* returns the number of contiguous edges within the given tolerance as defined above;
2204 * *ContiguousEdge* takes an edge number as an argument and returns the *TopoDS* edge contiguous to another edge;
2205 * *ContiguousEdgeCouple* gives all edges or sections, which are common to the edge with the number given above.
2206 * *SectionToBoundary* finds the original edge on the original shape from the section.
2208 @section occt_modalg_9 Features
2210 @subsection occt_modalg_9_1 The BRepFeat Classes and their use
2211 *BRepFeat* package is used to manipulate extensions of the classical boundary representation of shapes closer to features. In that sense, *BRepFeat* is an extension of *BRepBuilderAPI* package.
2213 @subsubsection occt_modalg_9_1_1 Form classes
2214 The *Form* from *BRepFeat* class 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.
2218 *MakePrism* from *BRepFeat* class is used to build a prism interacting with a shape. It is created or initialized from
2219 * a shape (the basic shape),
2220 * the base of the prism,
2221 * 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),
2223 * a Boolean indicating the type of operation (fusion=protrusion or cut=depression) on the basic shape,
2224 * another Boolean indicating if the self-intersections have to be found (not used in every case).
2226 There are six Perform methods:
2228 | ---------------------- | ------------------------------------- |
2229 | *Perform(Height)* | The resulting prism is of the given length. |
2230 | *Perform(Until)* | The prism is defined between the position of the base and the given face. |
2231 | *Perform(From, Until)* | The prism is defined between the two faces From and Until. |
2232 | *PerformUntilEnd()* | The prism is semi-infinite, limited by the actual position of the base. |
2233 | *PerformFromEnd(Until)* | The prism is semi-infinite, limited by the face Until. |
2234 | *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. |
2236 **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.
2238 In the following sequence, a protrusion is performed, i.e. a face of the shape is changed into a prism.
2241 TopoDS_Shape Sbase = ...; // an initial shape
2242 TopoDS_Face Fbase = ....; // a base of prism
2244 gp_Dir Extrusion (.,.,.);
2246 // An empty face is given as the sketch face
2248 BRepFeat_MakePrism thePrism(Sbase, Fbase, TopoDS_Face(), Extrusion, Standard_True, Standard_True);
2250 thePrism, Perform(100.);
2251 if (thePrism.IsDone()) {
2252 TopoDS_Shape theResult = thePrism;
2257 @image html /user_guides/modeling_algos/images/modeling_algos_image047.jpg "Fusion with MakePrism"
2258 @image latex /user_guides/modeling_algos/images/modeling_algos_image047.jpg "Fusion with MakePrism"
2260 @image html /user_guides/modeling_algos/images/modeling_algos_image048.jpg "Creating a prism between two faces with Perform(From, Until)"
2261 @image latex /user_guides/modeling_algos/images/modeling_algos_image048.jpg "Creating a prism between two faces with Perform(From, Until)"
2265 *MakeDPrism* from *BRepFeat* class 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
2266 * a shape (basic shape),
2267 * the base of the prism,
2268 * 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),
2270 * a Boolean indicating the type of operation (fusion=protrusion or cut=depression) on the basic shape,
2271 * another Boolean indicating if self-intersections have to be found (not used in every case).
2273 Evidently 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.
2274 The semantics of draft prism feature creation is based on the construction of shapes:
2276 * up to a limiting face
2277 * from a limiting face to a height.
2279 The shape defining construction of the draft prism feature can be either the supporting edge or the concerned area of a face.
2281 In 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.
2282 In 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 .
2284 The *Perform* methods are the same as for *MakePrism*.
2287 TopoDS_Shape S = BRepPrimAPI_MakeBox(400.,250.,300.);
2289 Ex.Init(S,TopAbs_FACE);
2295 TopoDS_Face F = TopoDS::Face(Ex.Current());
2296 Handle(Geom_Surface) surf = BRep_Tool::Surface(F);
2298 c(gp_Ax2d(gp_Pnt2d(200.,130.),gp_Dir2d(1.,0.)),50.);
2299 BRepBuilderAPI_MakeWire MW;
2300 Handle(Geom2d_Curve) aline = new Geom2d_Circle(c);
2301 MW.Add(BRepBuilderAPI_MakeEdge(aline,surf,0.,PI));
2302 MW.Add(BRepBuilderAPI_MakeEdge(aline,surf,PI,2.*PI));
2303 BRepBuilderAPI_MakeFace MKF;
2304 MKF.Init(surf,Standard_False);
2306 TopoDS_Face FP = MKF.Face();
2307 BRepLib::BuildCurves3d(FP);
2308 BRepFeat_MakeDPrism MKDP (S,FP,F,10*PI180,Standard_True,
2311 TopoDS_Shape res1 = MKDP.Shape();
2314 @image html /user_guides/modeling_algos/images/modeling_algos_image049.jpg "A tapered prism"
2315 @image latex /user_guides/modeling_algos/images/modeling_algos_image049.jpg "A tapered prism"
2319 The *MakeRevol* from *BRepFeat* class is used to build a revolution interacting with a
2320 shape. It is created or initialized from
2322 * a shape (the basic shape,)
2323 * the base of the revolution,
2324 * 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),
2325 * an axis of revolution,
2326 * a boolean indicating the type of operation (fusion=protrusion or cut=depression) on the basic shape,
2327 * another boolean indicating whether the self-intersections have to be found (not used in every case).
2329 There are four Perform methods:
2331 | *Perform(Angle)* | The resulting revolution is of the given magnitude. |
2332 | *Perform(Until)* | The revolution is defined between the actual position of the base and the given face. |
2333 | *Perform(From, Until)* | The revolution is defined between the two faces, From and Until. |
2334 | *PerformThruAll()* | The result is similar to Perform(2*PI). |
2336 **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.
2339 In the following sequence, a face is revolved and the revolution is limited by a face of the base shape.
2342 TopoDS_Shape Sbase = ...; // an initial shape
2343 TopoDS_Face Frevol = ....; // a base of prism
2344 TopoDS_Face FUntil = ....; // face limiting the revol
2346 gp_Dir RevolDir (.,.,.);
2347 gp_Ax1 RevolAx(gp_Pnt(.,.,.), RevolDir);
2349 // An empty face is given as the sketch face
2351 BRepFeat_MakeRevol theRevol(Sbase, Frevol, TopoDS_Face(), RevolAx, Standard_True, Standard_True);
2353 theRevol.Perform(FUntil);
2354 if (theRevol.IsDone()) {
2355 TopoDS_Shape theResult = theRevol;
2362 This method constructs compound shapes with pipe features: depressions or protrusions. A class object is created or initialized from
2363 * a shape (basic shape),
2364 * a base face (profile of the pipe)
2365 * 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),
2367 * a Boolean indicating the type of operation (fusion=protrusion or cut=depression) on the basic shape,
2368 * another Boolean indicating if self-intersections have to be found (not used in every case).
2370 There are three Perform methods:
2372 | *Perform()* | The pipe is defined along the entire path (spine wire) |
2373 | *Perform(Until)* | The pipe is defined along the path until a given face |
2374 | *Perform(From, Until)* | The pipe is defined between the two faces From and Until |
2377 TopoDS_Shape S = BRepPrimAPI_MakeBox(400.,250.,300.);
2379 Ex.Init(S,TopAbs_FACE);
2382 TopoDS_Face F1 = TopoDS::Face(Ex.Current());
2383 Handle(Geom_Surface) surf = BRep_Tool::Surface(F1);
2384 BRepBuilderAPI_MakeWire MW1;
2386 p1 = gp_Pnt2d(100.,100.);
2387 p2 = gp_Pnt2d(200.,100.);
2388 Handle(Geom2d_Line) aline = GCE2d_MakeLine(p1,p2).Value();
2390 MW1.Add(BRepBuilderAPI_MakeEdge(aline,surf,0.,p1.Distance(p2)));
2392 p2 = gp_Pnt2d(150.,200.);
2393 aline = GCE2d_MakeLine(p1,p2).Value();
2395 MW1.Add(BRepBuilderAPI_MakeEdge(aline,surf,0.,p1.Distance(p2)));
2397 p2 = gp_Pnt2d(100.,100.);
2398 aline = GCE2d_MakeLine(p1,p2).Value();
2400 MW1.Add(BRepBuilderAPI_MakeEdge(aline,surf,0.,p1.Distance(p2)));
2401 BRepBuilderAPI_MakeFace MKF1;
2402 MKF1.Init(surf,Standard_False);
2403 MKF1.Add(MW1.Wire());
2404 TopoDS_Face FP = MKF1.Face();
2405 BRepLib::BuildCurves3d(FP);
2406 TColgp_Array1OfPnt CurvePoles(1,3);
2407 gp_Pnt pt = gp_Pnt(150.,0.,150.);
2409 pt = gp_Pnt(200.,100.,150.);
2411 pt = gp_Pnt(150.,200.,150.);
2413 Handle(Geom_BezierCurve) curve = new Geom_BezierCurve
2415 TopoDS_Edge E = BRepBuilderAPI_MakeEdge(curve);
2416 TopoDS_Wire W = BRepBuilderAPI_MakeWire(E);
2417 BRepFeat_MakePipe MKPipe (S,FP,F1,W,Standard_False,
2420 TopoDS_Shape res1 = MKPipe.Shape();
2423 @image html /user_guides/modeling_algos/images/modeling_algos_image050.jpg "Pipe depression"
2424 @image latex /user_guides/modeling_algos/images/modeling_algos_image050.jpg "Pipe depression"
2428 @subsubsection occt_modalg_9_1_2 Linear Form
2430 *MakeLinearForm* class creates a rib or a groove along a planar surface.
2432 The 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.
2434 The development contexts differ, however, in the case of mechanical features.
2435 Here they include extrusion:
2436 * to a limiting face of the basis shape;
2437 * to or from a limiting plane;
2439 A class object is created or initialized from
2440 * a shape (basic shape);
2441 * a wire (base of rib or groove);
2442 * a plane (plane of the wire);
2443 * direction1 (a vector along which thickness will be built up);
2444 * direction2 (vector opposite to the previous one along which thickness will be built up, may be null);
2445 * a Boolean indicating the type of operation (fusion=rib or cut=groove) on the basic shape;
2446 * another Boolean indicating if self-intersections have to be found (not used in every case).
2448 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)*.
2451 BRepBuilderAPI_MakeWire mkw;
2452 gp_Pnt p1 = gp_Pnt(0.,0.,0.);
2453 gp_Pnt p2 = gp_Pnt(200.,0.,0.);
2454 mkw.Add(BRepBuilderAPI_MakeEdge(p1,p2));
2456 p2 = gp_Pnt(200.,0.,50.);
2457 mkw.Add(BRepBuilderAPI_MakeEdge(p1,p2));
2459 p2 = gp_Pnt(50.,0.,50.);
2460 mkw.Add(BRepBuilderAPI_MakeEdge(p1,p2));
2462 p2 = gp_Pnt(50.,0.,200.);
2463 mkw.Add(BRepBuilderAPI_MakeEdge(p1,p2));
2465 p2 = gp_Pnt(0.,0.,200.);
2466 mkw.Add(BRepBuilderAPI_MakeEdge(p1,p2));
2468 mkw.Add(BRepBuilderAPI_MakeEdge(p2,gp_Pnt(0.,0.,0.)));
2469 TopoDS_Shape S = BRepBuilderAPI_MakePrism(BRepBuilderAPI_MakeFace
2470 (mkw.Wire()),gp_Vec(gp_Pnt(0.,0.,0.),gp_P
2472 TopoDS_Wire W = BRepBuilderAPI_MakeWire(BRepBuilderAPI_MakeEdge(gp_Pnt
2474 gp_Pnt(100.,45.,50.)));
2475 Handle(Geom_Plane) aplane =
2476 new Geom_Plane(gp_Pnt(0.,45.,0.), gp_Vec(0.,1.,0.));
2477 BRepFeat_MakeLinearForm aform(S, W, aplane, gp_Dir
2478 (0.,5.,0.), gp_Dir(0.,-3.,0.), 1, Standard_True);
2480 TopoDS_Shape res = aform.Shape();
2483 @image html /user_guides/modeling_algos/images/modeling_algos_image051.jpg "Creating a rib"
2484 @image latex /user_guides/modeling_algos/images/modeling_algos_image051.jpg "Creating a rib"
2486 @subsubsection occt_modalg_9_1_3 Gluer
2488 The *Gluer* from *BRepFeat* class 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.
2489 The class is created or initialized from two shapes: the “glued” shape and the basic shape (on which the other shape is glued).
2490 Two *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.
2492 **Note** that every face and edge has to be bounded, if two edges of two glued faces are coincident they must be explicitly bounded.
2495 TopoDS_Shape Sbase = ...; // the basic shape
2496 TopoDS_Shape Sglued = ...; // the glued shape
2498 TopTools_ListOfShape Lfbase;
2499 TopTools_ListOfShape Lfglued;
2500 // Determination of the glued faces
2503 BRepFeat_Gluer theGlue(Sglue, Sbase);
2504 TopTools_ListIteratorOfListOfShape itlb(Lfbase);
2505 TopTools_ListIteratorOfListOfShape itlg(Lfglued);
2506 for (; itlb.More(); itlb.Next(), itlg(Next()) {
2507 const TopoDS_Face& f1 = TopoDS::Face(itlg.Value());
2508 const TopoDS_Face& f2 = TopoDS::Face(itlb.Value());
2509 theGlue.Bind(f1,f2);
2510 // for example, use the class FindEdges from LocOpe to
2511 // determine coincident edges
2512 LocOpe_FindEdge fined(f1,f2);
2513 for (fined.InitIterator(); fined.More(); fined.Next()) {
2514 theGlue.Bind(fined.EdgeFrom(),fined.EdgeTo());
2518 if (theGlue.IsDone() {
2519 TopoDS_Shape theResult = theGlue;
2524 @subsubsection occt_modalg_9_1_4 Split Shape
2526 *SplitShape* from *BRepFeat* class is used to split faces of a shape with wires or edges. The shape containing the new entities is rebuilt, sharing the unmodified ones.
2528 The class is created or initialized from a shape (the basic shape).
2529 Three Add methods are available:
2531 | *Add(Wire, Face)* | Adds a new wire on a face of the basic shape. |
2532 | *Add(Edge, Face)* | Adds a new edge on a face of the basic shape. |
2533 | *Add(EdgeNew, EdgeOld)* | Adds a new edge on an existing one (the old edge must contain the new edge). |
2535 **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.
2538 TopoDS_Shape Sbase = ...; // basic shape
2539 TopoDS_Face Fsplit = ...; // face of Sbase
2540 TopoDS_Wire Wsplit = ...; // new wire contained in Fsplit
2541 BRepFeat_SplitShape Spls(Sbase);
2542 Spls.Add(Wsplit, Fsplit);
2543 TopoDS_Shape theResult = Spls;
2548 @section occt_modalg_10 Hidden Line Removal
2550 To provide the precision required in industrial design, drawings need to offer the possibility of removing lines, which are hidden in a given projection.
2552 For this the Hidden Line Removal component provides two algorithms: *HLRBRep_Algo* and *HLRBRep_PolyAlgo*.
2554 These 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.
2555 These 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.
2557 *HLRBRep_Algo* takes the shape itself into account 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.
2559 No 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*.
2561 *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.
2563 However, there some restrictions in HLR use:
2564 * Points are not processed;
2565 * Z-clipping planes are not used;
2566 * Infinite faces or lines are not processed.
2569 @image html /user_guides/modeling_algos/images/modeling_algos_image052.jpg "Sharp, smooth and sewn edges in a simple screw shape"
2570 @image latex /user_guides/modeling_algos/images/modeling_algos_image052.jpg "Sharp, smooth and sewn edges in a simple screw shape"
2572 @image html /user_guides/modeling_algos/images/modeling_algos_image053.jpg "Outline edges and isoparameters in the same shape"
2573 @image latex /user_guides/modeling_algos/images/modeling_algos_image053.jpg "Outline edges and isoparameters in the same shape"
2575 @image html /user_guides/modeling_algos/images/modeling_algos_image054.jpg "A simple screw shape seen with shading"
2576 @image latex /user_guides/modeling_algos/images/modeling_algos_image054.jpg "A simple screw shape seen with shading"
2578 @image html /user_guides/modeling_algos/images/modeling_algos_image055.jpg "An extraction showing hidden sharp edges"
2579 @image latex /user_guides/modeling_algos/images/modeling_algos_image055.jpg "An extraction showing hidden sharp edges"
2582 The following services are related to Hidden Lines Removal :
2586 To 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.
2588 ### Setting view parameters
2590 *HLRBRep_Algo::Projector* and *HLRBRep_PolyAlgo::Projector* set a projector object which defines the parameters of the view. This object is an *HLRAlgo_Projector*.
2592 ### Computing the projections
2594 *HLRBRep_PolyAlgo::Update* launches the calculation of outlines of the shape visualized by the *HLRBRep_PolyAlgo* framework.
2596 In 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*.
2598 ### Extracting edges
2600 The 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:
2601 * visible/hidden sharp edges;
2602 * visible/hidden smooth edges;
2603 * visible/hidden sewn edges;
2604 * visible/hidden outline edges.
2606 To perform extraction on an *HLRBRep_PolyHLRToShape* object, use *HLRBRep_PolyHLRToShape::Update* function.
2608 For an *HLRBRep_HLRToShape* object built from an *HLRBRepAlgo* object you can also highlight:
2609 * visible isoparameters and
2610 * hidden isoparameters.
2612 @subsection occt_modalg_10_1 Examples
2617 // Build The algorithm object
2618 myAlgo = new HLRBRep_Algo();
2620 // Add Shapes into the algorithm
2621 TopTools_ListIteratorOfListOfShape anIterator(myListOfShape);
2622 for (;anIterator.More();anIterator.Next())
2623 myAlgo-Add(anIterator.Value(),myNbIsos);
2625 // Set The Projector (myProjector is a
2627 myAlgo-Projector(myProjector);
2632 // Set The Edge Status
2635 // Build the extraction object :
2636 HLRBRep_HLRToShape aHLRToShape(myAlgo);
2638 // extract the results :
2639 TopoDS_Shape VCompound = aHLRToShape.VCompound();
2640 TopoDS_Shape Rg1LineVCompound =
2641 aHLRToShape.Rg1LineVCompound();
2642 TopoDS_Shape RgNLineVCompound =
2643 aHLRToShape.RgNLineVCompound();
2644 TopoDS_Shape OutLineVCompound =
2645 aHLRToShape.OutLineVCompound();
2646 TopoDS_Shape IsoLineVCompound =
2647 aHLRToShape.IsoLineVCompound();
2648 TopoDS_Shape HCompound = aHLRToShape.HCompound();
2649 TopoDS_Shape Rg1LineHCompound =
2650 aHLRToShape.Rg1LineHCompound();
2651 TopoDS_Shape RgNLineHCompound =
2652 aHLRToShape.RgNLineHCompound();
2653 TopoDS_Shape OutLineHCompound =
2654 aHLRToShape.OutLineHCompound();
2655 TopoDS_Shape IsoLineHCompound =
2656 aHLRToShape.IsoLineHCompound();
2659 ### HLRBRep_PolyAlgo
2664 // Build The algorithm object
2665 myPolyAlgo = new HLRBRep_PolyAlgo();
2667 // Add Shapes into the algorithm
2668 TopTools_ListIteratorOfListOfShape
2669 anIterator(myListOfShape);
2670 for (;anIterator.More();anIterator.Next())
2671 myPolyAlgo-Load(anIterator.Value());
2673 // Set The Projector (myProjector is a
2675 myPolyAlgo->Projector(myProjector);
2678 myPolyAlgo->Update();
2680 // Build the extraction object :
2681 HLRBRep_PolyHLRToShape aPolyHLRToShape;
2682 aPolyHLRToShape.Update(myPolyAlgo);
2684 // extract the results :
2685 TopoDS_Shape VCompound =
2686 aPolyHLRToShape.VCompound();
2687 TopoDS_Shape Rg1LineVCompound =
2688 aPolyHLRToShape.Rg1LineVCompound();
2689 TopoDS_Shape RgNLineVCompound =
2690 aPolyHLRToShape.RgNLineVCompound();
2691 TopoDS_Shape OutLineVCompound =
2692 aPolyHLRToShape.OutLineVCompound();
2693 TopoDS_Shape HCompound =
2694 aPolyHLRToShape.HCompound();
2695 TopoDS_Shape Rg1LineHCompound =
2696 aPolyHLRToShape.Rg1LineHCompound();
2697 TopoDS_Shape RgNLineHCompound =
2698 aPolyHLRToShape.RgNLineHCompound();
2699 TopoDS_Shape OutLineHCompound =
2700 aPolyHLRToShape.OutLineHCompound();
2703 @section occt_modalg_10_2 Meshing of Shapes
2705 The *HLRBRep_PolyAlgo* algorithm works with triangulation of shapes. This is provided by the function *BRepMesh::Mesh*, which adds a triangulation of the shape to its topological data structure. This triangulation is computed with a given deflection.
2708 Standard_Real radius=10. ;
2709 Standard_Real height=25. ;
2710 BRepBuilderAPI_MakeCylinder myCyl (radius, height) ;
2711 TopoDS_Shape myShape = myCyl.Shape() ;
2712 Standard_Real Deflection = 0.01 ;
2713 BRepMesh::Mesh (myShape, Deflection);
2716 Meshing covers a shape with a triangular mesh. Other than hidden line removal, you can use meshing to transfer the shape to another tool: a manufacturing tool, a shading algorithm, a finite element algorithm, or a collision algorithm, for example.
2718 You can obtain information on the shape by first exploring it. To then access triangulation of a face in the shape, use *BRepTool::Triangulation*. To access a polygon which is the approximation of an edge of the face, use *BRepTool::PolygonOnTriangulation*.