0024002: Overall code and build procedure refactoring -- automatic
[occt.git] / src / BRepAlgo / BRepAlgo_Section.hxx
1 // Created on: 1994-02-18
2 // Created by: Remi LEQUETTE
3 // Copyright (c) 1994-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 #ifndef _BRepAlgo_Section_HeaderFile
18 #define _BRepAlgo_Section_HeaderFile
19
20 #include <Standard.hxx>
21 #include <Standard_DefineAlloc.hxx>
22 #include <Standard_Handle.hxx>
23
24 #include <Standard_Boolean.hxx>
25 #include <BRepAlgo_BooleanOperation.hxx>
26 class TopoDS_Shape;
27 class gp_Pln;
28 class Geom_Surface;
29
30
31 //! Construction of the section lines between two shapes.
32 //! For this Boolean operation, each face of the first
33 //! shape is intersected by each face of the second
34 //! shape. The resulting intersection edges are brought
35 //! together into a compound object, but not chained or
36 //! grouped into wires.
37 //! Computation of the intersection of two Shapes or Surfaces
38 //! The two parts involved in this Boolean operation may
39 //! be defined from geometric surfaces: the most common
40 //! use is the computation of the planar section of a shape.
41 //! A Section object provides the framework for:
42 //! - defining the shapes to be intersected, and the
43 //! computation options,
44 //! - implementing the construction algorithm, and
45 //! - consulting the result.
46 //! Example : giving two shapes S1,S2 accessing faces,
47 //! let compute the section edges R on S1,S2,
48 //! performing approximation on new curves,
49 //! performing PCurve on part 1 but not on part 2 :
50 //! Standard_Boolean PerformNow = Standard_False;
51 //! BRepBoolAPI_Section S(S1,S2,PerformNow);
52 //! S.ComputePCurveOn1(Standard_True);
53 //! S.Approximation(Standard_True);
54 //! S.Build();
55 //! TopoDS_Shape R = S.Shape();
56 //! On Null Shapes of geometries, NotDone() is called.
57 class BRepAlgo_Section  : public BRepAlgo_BooleanOperation
58 {
59 public:
60
61   DEFINE_STANDARD_ALLOC
62
63   
64   Standard_EXPORT BRepAlgo_Section(const TopoDS_Shape& Sh1, const TopoDS_Shape& Sh2, const Standard_Boolean PerformNow = Standard_True);
65   
66   Standard_EXPORT BRepAlgo_Section(const TopoDS_Shape& Sh, const gp_Pln& Pl, const Standard_Boolean PerformNow = Standard_True);
67   
68   Standard_EXPORT BRepAlgo_Section(const TopoDS_Shape& Sh, const Handle(Geom_Surface)& Sf, const Standard_Boolean PerformNow = Standard_True);
69   
70   Standard_EXPORT BRepAlgo_Section(const Handle(Geom_Surface)& Sf, const TopoDS_Shape& Sh, const Standard_Boolean PerformNow = Standard_True);
71   
72   //! This and the above algorithms construct a framework for computing the section lines of
73   //! - the two shapes Sh1 and Sh2, or
74   //! - the shape Sh and the plane Pl, or
75   //! - the shape Sh and the surface Sf, or
76   //! - the surface Sf and the shape Sh, or
77   //! - the two surfaces Sf1 and Sf2,
78   //! and builds the result if PerformNow equals true, its
79   //! default value. If PerformNow equals false, the
80   //! intersection will be computed later by the function Build.
81   //! The constructed shape will be returned by the
82   //! function Shape. This is a compound object
83   //! composed of edges. These intersection edges may be built:
84   //! - on new intersection lines, or
85   //! - on coincident portions of edges in the two intersected shapes.
86   //! These intersection edges are independent: they
87   //! are not chained or grouped in wires.
88   //! If no intersection edge exists, the result is an empty compound object.
89   //! Note that other objects than TopoDS_Shape
90   //! shapes involved in these syntaxes are converted
91   //! into faces or shells before performing the
92   //! computation of the intersection. A shape resulting
93   //! from this conversion can be retrieved with the
94   //! function Shape1 or Shape2.
95   //! Parametric 2D curves on intersection edges
96   //! No parametric 2D curve (pcurve) is defined for
97   //! each elementary edge of the result. To attach such
98   //! parametric curves to the constructed edges you
99   //! may use a constructor with the PerformNow flag
100   //! equal to false; then you use:
101   //! - the function ComputePCurveOn1 to ask for the
102   //! additional computation of a pcurve in the
103   //! parametric space of the first shape,
104   //! - the function ComputePCurveOn2 to ask for the
105   //! additional computation of a pcurve in the
106   //! parametric space of the second shape,
107   //! - in the end, the function Build to construct the result.
108   //! Note that as a result, pcurves will only be added on
109   //! edges built on new intersection lines.
110   //! Approximation of intersection edges
111   //! The underlying 3D geometry attached to each
112   //! elementary edge of the result is:
113   //! - analytic where possible, provided the
114   //! corresponding geometry corresponds to a type
115   //! of analytic curve defined in the Geom package;
116   //! for example, the intersection of a cylindrical
117   //! shape with a plane gives an ellipse or a circle;
118   //! - or elsewhere, given as a succession of points
119   //! grouped together in a BSpline curve of degree 1.
120   //! If you prefer to have an attached 3D geometry
121   //! which is a BSpline approximation of the computed
122   //! set of points on computed elementary intersection
123   //! edges whose underlying geometry is not analytic,
124   //! you may use a constructor with the PerformNow
125   //! flag equal to false. Then you use:
126   //! - the function Approximation to ask for this
127   //! computation option, and
128   //! - the function Build to construct the result.
129   //! Note that as a result, approximations will only be
130   //! computed on edges built on new intersection lines.
131   //! Example
132   //! You may also combine these computation options.
133   //! In the following example:
134   //! - each elementary edge of the computed
135   //! intersection, built on a new intersection line,
136   //! which does not correspond to an analytic Geom
137   //! curve, will be approximated by a BSpline curve
138   //! whose degree is not greater than 8.
139   //! - each elementary edge built on a new intersection line, will have:
140   //! - a pcurve in the parametric space of the shape S1,
141   //! - no pcurve in the parametric space of the shape S2.
142   //! // TopoDS_Shape S1 = ... , S2 = ... ;
143   //! Standard_Boolean PerformNow = Standard_False;
144   //! BRepAlgo_Section S ( S1, S2, PerformNow );
145   //! S.ComputePCurveOn1 (Standard_True);
146   //! S.Approximation (Standard_True);
147   //! S.Build();
148   //! TopoDS_Shape R = S.Shape();
149   Standard_EXPORT BRepAlgo_Section(const Handle(Geom_Surface)& Sf1, const Handle(Geom_Surface)& Sf2, const Standard_Boolean PerformNow = Standard_True);
150   
151   //! Initializes the first part
152   Standard_EXPORT void Init1 (const TopoDS_Shape& S1);
153   
154   //! Initializes the first part
155   Standard_EXPORT void Init1 (const gp_Pln& Pl);
156   
157   //! Initializes the first part
158   Standard_EXPORT void Init1 (const Handle(Geom_Surface)& Sf);
159   
160   //! initialize second part
161   Standard_EXPORT void Init2 (const TopoDS_Shape& S2);
162   
163   //! Initializes the second part
164   Standard_EXPORT void Init2 (const gp_Pln& Pl);
165   
166   //! This and the above algorithms
167   //! reinitialize the first and the second parts on which
168   //! this algorithm is going to perform the intersection
169   //! computation. This is done with either: the surface
170   //! Sf, the plane Pl or the shape Sh.
171   //! You use the function Build to construct the result.
172   Standard_EXPORT void Init2 (const Handle(Geom_Surface)& Sf);
173   
174   //! Defines an option for computation of further
175   //! intersections. This computation will be performed by
176   //! the function Build in this framework.
177   //! By default, the underlying 3D geometry attached to
178   //! each elementary edge of the result of a computed intersection is:
179   //! - analytic where possible, provided the
180   //! corresponding geometry corresponds to a type of
181   //! analytic curve defined in the Geom package; for
182   //! example the intersection of a cylindrical shape with
183   //! a plane gives an ellipse or a circle;
184   //! - or elsewhere, given as a succession of points
185   //! grouped together in a BSpline curve of degree 1. If
186   //! Approx equals true, when further computations are
187   //! performed in this framework with the function
188   //! Build, these edges will have an attached 3D
189   //! geometry which is a BSpline approximation of the
190   //! computed set of points.
191   //! Note that as a result, approximations will be computed
192   //! on edges built only on new intersection lines.
193   Standard_EXPORT void Approximation (const Standard_Boolean B);
194   
195   //! Indicates if the Pcurve must be (or not) performed on first part.
196   Standard_EXPORT void ComputePCurveOn1 (const Standard_Boolean B);
197   
198   //! Define options for the computation of further
199   //! intersections which will be performed by the function
200   //! Build in this framework.
201   //! By default, no parametric 2D curve (pcurve) is defined
202   //! for the elementary edges of the result.
203   //! If ComputePCurve1 equals true, further computations
204   //! performed in this framework with the function Build
205   //! will attach an additional pcurve in the parametric
206   //! space of the first shape to the constructed edges.
207   //! If ComputePCurve2 equals true, the additional pcurve
208   //! will be attached to the constructed edges in the
209   //! parametric space of the second shape.
210   //! These two functions may be used together.
211   //! Note that as a result, pcurves will only be added onto
212   //! edges built on new intersection lines.
213   Standard_EXPORT void ComputePCurveOn2 (const Standard_Boolean B);
214   
215   //! Performs the computation of the section lines
216   //! between the two parts defined at the time of
217   //! construction of this framework or reinitialized with the
218   //! Init1 and Init2 functions.
219   //! The constructed shape will be returned by the function
220   //! Shape. This is a compound object composed of
221   //! edges. These intersection edges may be built:
222   //! - on new intersection lines, or
223   //! - on coincident portions of edges in the two intersected shapes.
224   //! These intersection edges are independent: they are
225   //! not chained or grouped into wires.
226   //! If no intersection edge exists, the result is an empty compound object.
227   //! The shapes involved in the construction of the section
228   //! lines can be retrieved with the function Shape1 or
229   //! Shape2. Note that other objects than
230   //! TopoDS_Shape shapes given as arguments at the
231   //! construction time of this framework, or to the Init1 or
232   //! Init2 function, are converted into faces or shells
233   //! before performing the computation of the intersection.
234   //! Parametric 2D curves on intersection edges
235   //! No parametric 2D curve (pcurve) is defined for the
236   //! elementary edges of the result. To attach parametric
237   //! curves like this to the constructed edges you have to use:
238   //! - the function ComputePCurveOn1 to ask for the
239   //! additional computation of a pcurve in the
240   //! parametric space of the first shape,
241   //! - the function ComputePCurveOn2 to ask for the
242   //! additional computation of a pcurve in the
243   //! parametric space of the second shape.
244   //! This must be done before calling this function.
245   //! Note that as a result, pcurves are added on edges
246   //! built on new intersection lines only.
247   //! Approximation of intersection edges
248   //! The underlying 3D geometry attached to each
249   //! elementary edge of the result is:
250   //! - analytic where possible provided the corresponding
251   //! geometry corresponds to a type of analytic curve
252   //! defined in the Geom package; for example, the
253   //! intersection of a cylindrical shape with a plane
254   //! gives an ellipse or a circle; or
255   //! - elsewhere, given as a succession of points grouped
256   //! together in a BSpline curve of degree 1.
257   //! If, on computed elementary intersection edges whose
258   //! underlying geometry is not analytic, you prefer to
259   //! have an attached 3D geometry which is a BSpline
260   //! approximation of the computed set of points, you have
261   //! to use the function Approximation to ask for this
262   //! computation option before calling this function.
263   //! You may also have combined these computation
264   //! options: look at the example given above to illustrate
265   //! the use of the constructors.
266   Standard_EXPORT void Build() Standard_OVERRIDE;
267   
268   //! Identifies the ancestor faces of the new
269   //! intersection edge E resulting from the last
270   //! computation performed in this framework, that is,
271   //! the faces of the two original shapes on which the edge E lies:
272   //! - HasAncestorFaceOn1 gives the ancestor face
273   //! in the first shape, and
274   //! These functions return:
275   //! - true if an ancestor face F is found, or
276   //! - false if not.
277   //! An ancestor face is identifiable for the edge E if the
278   //! three following conditions are satisfied:
279   //! - the first part on which this algorithm performed
280   //! its last computation is a shape, that is, it was not
281   //! given as a surface or a plane at the time of
282   //! construction of this algorithm or at a later time by
283   //! the Init1 function,
284   //! - E is one of the elementary edges built by the last
285   //! computation of this section algorithm,
286   //! - the edge E is built on an intersection curve. In
287   //! other words, E is a new edge built on the
288   //! intersection curve, not on edges belonging to the
289   //! intersecting shapes.
290   //! To use these functions properly, you have to test
291   //! the returned Boolean value before using the
292   //! ancestor face: F is significant only if the returned
293   //! Boolean value equals true.
294   Standard_EXPORT Standard_Boolean HasAncestorFaceOn1 (const TopoDS_Shape& E, TopoDS_Shape& F) const;
295   
296   //! Identifies the ancestor faces of the new
297   //! intersection edge E resulting from the last
298   //! computation performed in this framework, that is,
299   //! the faces of the two original shapes on which the edge E lies:
300   //! - HasAncestorFaceOn2 gives the ancestor face in the second shape.
301   //! These functions return:
302   //! - true if an ancestor face F is found, or
303   //! - false if not.
304   //! An ancestor face is identifiable for the edge E if the
305   //! three following conditions are satisfied:
306   //! - the first part on which this algorithm performed
307   //! its last computation is a shape, that is, it was not
308   //! given as a surface or a plane at the time of
309   //! construction of this algorithm or at a later time by
310   //! the Init1 function,
311   //! - E is one of the elementary edges built by the last
312   //! computation of this section algorithm,
313   //! - the edge E is built on an intersection curve. In
314   //! other words, E is a new edge built on the
315   //! intersection curve, not on edges belonging to the
316   //! intersecting shapes.
317   //! To use these functions properly, you have to test
318   //! the returned Boolean value before using the
319   //! ancestor face: F is significant only if the returned
320   //! Boolean value equals true.
321   Standard_EXPORT Standard_Boolean HasAncestorFaceOn2 (const TopoDS_Shape& E, TopoDS_Shape& F) const;
322
323
324
325
326 protected:
327
328
329
330
331
332 private:
333
334   
335   Standard_EXPORT virtual void InitParameters() Standard_OVERRIDE;
336
337
338   Standard_Boolean myS1Changed;
339   Standard_Boolean myS2Changed;
340   Standard_Boolean myApproxChanged;
341   Standard_Boolean myPCurve1Changed;
342   Standard_Boolean myPCurve2Changed;
343   Standard_Boolean myshapeisnull;
344
345
346 };
347
348
349
350
351
352
353
354 #endif // _BRepAlgo_Section_HeaderFile