0032137: Coding Rules - merge redundant .lxx files into header files within Package gp
[occt.git] / src / gp / gp_Parab.hxx
1 // Copyright (c) 1991-1999 Matra Datavision
2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 #ifndef _gp_Parab_HeaderFile
16 #define _gp_Parab_HeaderFile
17
18 #include <gp_Ax1.hxx>
19 #include <gp_Ax2.hxx>
20 #include <gp_Lin.hxx>
21 #include <gp_Pnt.hxx>
22 #include <Standard_ConstructionError.hxx>
23
24 //! Describes a parabola in 3D space.
25 //! A parabola is defined by its focal length (that is, the
26 //! distance between its focus and apex) and positioned in
27 //! space with a coordinate system (a gp_Ax2 object)
28 //! where:
29 //! -   the origin of the coordinate system is on the apex of
30 //! the parabola,
31 //! -   the "X Axis" of the coordinate system is the axis of
32 //! symmetry; the parabola is on the positive side of this axis, and
33 //! -   the origin, "X Direction" and "Y Direction" of the
34 //! coordinate system define the plane of the parabola.
35 //! The equation of the parabola in this coordinate system,
36 //! which is the "local coordinate system" of the parabola, is:
37 //! @code
38 //! Y**2 = (2*P) * X.
39 //! @endcode
40 //! where P, referred to as the parameter of the parabola, is
41 //! the distance between the focus and the directrix (P is
42 //! twice the focal length).
43 //! The "main Direction" of the local coordinate system gives
44 //! the normal vector to the plane of the parabola.
45 //! See Also
46 //! gce_MakeParab which provides functions for more
47 //! complex parabola constructions
48 //! Geom_Parabola which provides additional functions for
49 //! constructing parabolas and works, in particular, with the
50 //! parametric equations of parabolas
51 class gp_Parab 
52 {
53 public:
54
55   DEFINE_STANDARD_ALLOC
56
57   //! Creates an indefinite Parabola.
58   gp_Parab()
59   : focalLength (RealLast())
60   {}
61
62   //! Creates a parabola with its local coordinate system "theA2"
63   //! and it's focal length "Focal".
64   //! The XDirection of theA2 defines the axis of symmetry of the
65   //! parabola. The YDirection of theA2 is parallel to the directrix
66   //! of the parabola. The Location point of theA2 is the vertex of
67   //! the parabola
68   //! Raises ConstructionError if theFocal < 0.0
69   //! Raised if theFocal < 0.0
70   gp_Parab (const gp_Ax2& theA2, const Standard_Real theFocal)
71   : pos (theA2),
72     focalLength (theFocal)
73   {
74     Standard_ConstructionError_Raise_if (theFocal < 0.0, "gp_Parab() - focal length should be >= 0");
75   }
76
77   //! theD is the directrix of the parabola and theF the focus point.
78   //! The symmetry axis (XAxis) of the parabola is normal to the
79   //! directrix and pass through the focus point theF, but its
80   //! location point is the vertex of the parabola.
81   //! The YAxis of the parabola is parallel to theD and its location
82   //! point is the vertex of the parabola. The normal to the plane
83   //! of the parabola is the cross product between the XAxis and the
84   //! YAxis.
85   gp_Parab (const gp_Ax1& theD, const gp_Pnt& theF);
86
87   //! Modifies this parabola by redefining its local coordinate system so that
88   //! -   its origin and "main Direction" become those of the
89   //! axis theA1 (the "X Direction" and "Y Direction" are then
90   //! recomputed in the same way as for any gp_Ax2)
91   //! Raises ConstructionError if the direction of theA1 is parallel to the previous
92   //! XAxis of the parabola.
93   void SetAxis (const gp_Ax1& theA1) { pos.SetAxis (theA1); }
94
95   //! Changes the focal distance of the parabola.
96   //! Raises ConstructionError if theFocal < 0.0
97   void SetFocal (const Standard_Real theFocal)
98   {
99     Standard_ConstructionError_Raise_if (theFocal < 0.0, "gp_Parab::SetFocal() - focal length should be >= 0");
100     focalLength = theFocal;
101   }
102
103   //! Changes the location of the parabola. It is the vertex of
104   //! the parabola.
105   void SetLocation (const gp_Pnt& theP) { pos.SetLocation (theP); }
106
107   //! Changes the local coordinate system of the parabola.
108   void SetPosition (const gp_Ax2& theA2) { pos = theA2; }
109
110   //! Returns the main axis of the parabola.
111   //! It is the axis normal to the plane of the parabola passing
112   //! through the vertex of the parabola.
113   const gp_Ax1& Axis() const { return pos.Axis(); }
114
115   //! Computes the directrix of this parabola.
116   //! The directrix is:
117   //! -   a line parallel to the "Y Direction" of the local
118   //! coordinate system of this parabola, and
119   //! -   located on the negative side of the axis of symmetry,
120   //! at a distance from the apex which is equal to the focal
121   //! length of this parabola.
122   //! The directrix is returned as an axis (a gp_Ax1 object),
123   //! the origin of which is situated on the "X Axis" of this parabola.
124   gp_Ax1 Directrix() const;
125
126   //! Returns the distance between the vertex and the focus
127   //! of the parabola.
128   Standard_Real Focal() const { return focalLength; }
129
130   //! -   Computes the focus of the parabola.
131   gp_Pnt Focus() const;
132
133   //! Returns the vertex of the parabola. It is the "Location"
134   //! point of the coordinate system of the parabola.
135   const gp_Pnt& Location() const { return pos.Location(); }
136
137   //! Computes the parameter of the parabola.
138   //! It is the distance between the focus and the directrix of
139   //! the parabola. This distance is twice the focal length.
140   Standard_Real Parameter() const { return 2.0 * focalLength; }
141
142   //! Returns the local coordinate system of the parabola.
143   const gp_Ax2& Position() const { return pos; }
144
145   //! Returns the symmetry axis of the parabola. The location point
146   //! of the axis is the vertex of the parabola.
147   gp_Ax1 XAxis() const  { return gp_Ax1 (pos.Location(), pos.XDirection()); }
148
149   //! It is an axis parallel to the directrix of the parabola.
150   //! The location point of this axis is the vertex of the parabola.
151   gp_Ax1 YAxis() const { return gp_Ax1 (pos.Location(), pos.YDirection()); }
152
153   Standard_EXPORT void Mirror (const gp_Pnt& theP);
154
155   //! Performs the symmetrical transformation of a parabola
156   //! with respect to the point theP which is the center of the
157   //! symmetry.
158   Standard_NODISCARD Standard_EXPORT gp_Parab Mirrored (const gp_Pnt& theP) const;
159
160   Standard_EXPORT void Mirror (const gp_Ax1& theA1);
161
162   //! Performs the symmetrical transformation of a parabola
163   //! with respect to an axis placement which is the axis of
164   //! the symmetry.
165   Standard_NODISCARD Standard_EXPORT gp_Parab Mirrored (const gp_Ax1& theA1) const;
166
167   Standard_EXPORT void Mirror (const gp_Ax2& theA2);
168
169   //! Performs the symmetrical transformation of a parabola
170   //! with respect to a plane. The axis placement theA2 locates
171   //! the plane of the symmetry (Location, XDirection, YDirection).
172   Standard_NODISCARD Standard_EXPORT gp_Parab Mirrored (const gp_Ax2& theA2) const;
173
174   void Rotate (const gp_Ax1& theA1, const Standard_Real theAng) { pos.Rotate (theA1, theAng); }
175
176   //! Rotates a parabola. theA1 is the axis of the rotation.
177   //! Ang is the angular value of the rotation in radians.
178   Standard_NODISCARD gp_Parab Rotated (const gp_Ax1& theA1, const Standard_Real theAng) const
179   {
180     gp_Parab aPrb = *this;
181     aPrb.pos.Rotate (theA1, theAng);
182     return aPrb;
183   }
184
185   void Scale (const gp_Pnt& theP, const Standard_Real theS);
186
187   //! Scales a parabola. theS is the scaling value.
188   //! If theS is negative the direction of the symmetry axis
189   //! XAxis is reversed and the direction of the YAxis too.
190   Standard_NODISCARD gp_Parab Scaled (const gp_Pnt& theP, const Standard_Real theS) const;
191
192   void Transform (const gp_Trsf& theT);
193
194   //! Transforms a parabola with the transformation theT from class Trsf.
195   Standard_NODISCARD gp_Parab Transformed (const gp_Trsf& theT) const;
196
197   void Translate (const gp_Vec& theV) { pos.Translate (theV); }
198
199   //! Translates a parabola in the direction of the vector theV.
200   //! The magnitude of the translation is the vector's magnitude.
201   Standard_NODISCARD gp_Parab Translated (const gp_Vec& theV) const
202   {
203     gp_Parab aPrb = *this;
204     aPrb.pos.Translate (theV);
205     return aPrb;
206   }
207
208   void Translate (const gp_Pnt& theP1, const gp_Pnt& theP2)  { pos.Translate (theP1, theP2); }
209
210   //! Translates a parabola from the point theP1 to the point theP2.
211   Standard_NODISCARD gp_Parab Translated (const gp_Pnt& theP1, const gp_Pnt& theP2) const
212   {
213     gp_Parab aPrb = *this;
214     aPrb.pos.Translate (theP1, theP2);
215     return aPrb;
216   }
217
218 private:
219
220   gp_Ax2 pos;
221   Standard_Real focalLength;
222
223 };
224
225 //=======================================================================
226 //function : gp_Parab
227 // purpose :
228 //=======================================================================
229 inline gp_Parab::gp_Parab (const gp_Ax1& theD,
230                            const gp_Pnt& theF)
231 {
232   gp_Lin aDroite (theD);
233   focalLength = aDroite.Distance (theF) / 2.;
234   gp_Ax1 anAx = aDroite.Normal (theF).Position();
235   gp_Ax1 anAy = aDroite.Position();     
236   const gp_Dir& aDD = anAx.Direction();
237   pos = gp_Ax2 (gp_Pnt (theF.X() - focalLength * aDD.X(),
238                         theF.Y() - focalLength * aDD.Y(),
239                         theF.Z() - focalLength * aDD.Z()),
240                 anAx.Direction().Crossed (anAy.Direction()),
241                 anAx.Direction());
242 }
243
244 //=======================================================================
245 //function : Directrix
246 // purpose :
247 //=======================================================================
248 inline gp_Ax1 gp_Parab::Directrix() const
249 {
250   const gp_Pnt& aPP = pos.Location  ();
251   const gp_Dir& aDD = pos.XDirection();
252   gp_Pnt aP (aPP.X() - focalLength * aDD.X(),
253              aPP.Y() - focalLength * aDD.Y(),
254              aPP.Z() - focalLength * aDD.Z());
255   return gp_Ax1 (aP, pos.YDirection());
256 }
257
258 //=======================================================================
259 //function : Focus
260 // purpose :
261 //=======================================================================
262 inline gp_Pnt gp_Parab::Focus() const
263 {
264   const gp_Pnt& aPP = pos.Location  ();
265   const gp_Dir& aDD = pos.XDirection();
266   return gp_Pnt (aPP.X() + focalLength * aDD.X(),
267                  aPP.Y() + focalLength * aDD.Y(),
268                  aPP.Z() + focalLength * aDD.Z());
269 }
270
271 //=======================================================================
272 //function : Scale
273 // purpose :
274 //=======================================================================
275 inline void gp_Parab::Scale (const gp_Pnt& theP, const Standard_Real theS)
276 {
277   focalLength *= theS;
278   if (focalLength < 0)
279   {
280     focalLength = -focalLength;
281   }
282   pos.Scale (theP, theS);
283 }
284
285 //=======================================================================
286 //function : Scaled
287 // purpose :
288 //=======================================================================
289 inline gp_Parab gp_Parab::Scaled (const gp_Pnt& theP, const Standard_Real theS) const
290 {
291   gp_Parab aPrb = *this;
292   aPrb.focalLength *= theS;
293   if (aPrb.focalLength < 0)
294   {
295     aPrb.focalLength = -aPrb.focalLength;
296   }
297   aPrb.pos.Scale (theP, theS);
298   return aPrb;
299 }
300
301 //=======================================================================
302 //function : Transform
303 // purpose :
304 //=======================================================================
305 inline void gp_Parab::Transform (const gp_Trsf& theT)
306 {
307   focalLength *= theT.ScaleFactor();
308   if (focalLength < 0)
309   {
310     focalLength = -focalLength;
311   }
312   pos.Transform (theT);
313 }
314
315 //=======================================================================
316 //function : Transformed
317 // purpose :
318 //=======================================================================
319 inline gp_Parab gp_Parab::Transformed (const gp_Trsf& theT) const
320 {
321   gp_Parab aPrb = *this;
322   aPrb.focalLength *= theT.ScaleFactor();
323   if (aPrb.focalLength < 0)
324   {
325     aPrb.focalLength = -aPrb.focalLength;
326   }
327   aPrb.pos.Transform (theT);
328   return aPrb;
329 }
330
331 #endif // _gp_Parab_HeaderFile