0032137: Coding Rules - merge redundant .lxx files into header files within Package gp
[occt.git] / src / gp / gp_Hypr.lxx
1 // Copyright (c) 1995-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 #include <gp.hxx>
16 #include <Standard_DomainError.hxx>
17 #include <Standard_ConstructionError.hxx>
18
19 inline gp_Hypr::gp_Hypr () :
20 majorRadius(RealLast()),
21 minorRadius(RealFirst())
22 { }
23
24 inline gp_Hypr::gp_Hypr (const gp_Ax2& A2,
25                          const Standard_Real MajorRadius,
26                          const Standard_Real MinorRadius):
27                          pos(A2),
28                          majorRadius(MajorRadius),
29                          minorRadius(MinorRadius)
30
31   Standard_ConstructionError_Raise_if (MinorRadius < 0.0 || MajorRadius < 0.0,
32                                        "gp_Hypr() - invalid construction parameters");
33 }
34
35 inline void gp_Hypr::SetAxis (const gp_Ax1& A1)
36 { pos.SetAxis (A1); }
37
38 inline void gp_Hypr::SetLocation (const gp_Pnt& P)
39 { pos = gp_Ax2 (P, pos.Direction(), pos.XDirection()); }
40
41 inline void gp_Hypr::SetMajorRadius (const Standard_Real R)
42 {
43   Standard_ConstructionError_Raise_if (R < 0.0,
44                                        "gp_Hypr::SetMajorRadius() - major radius should be greater or equal zero");
45   majorRadius = R;
46 }
47
48 inline void gp_Hypr::SetMinorRadius (const Standard_Real R)
49 {
50   Standard_ConstructionError_Raise_if (R < 0.0,
51                                        "gp_Hypr::SetMinorRadius() - minor radius should be greater or equal zero");
52   minorRadius = R;
53 }
54
55 inline void gp_Hypr::SetPosition (const gp_Ax2& A2)
56 { pos = A2; }
57
58 inline gp_Ax1 gp_Hypr::Asymptote1 () const
59 {
60   Standard_ConstructionError_Raise_if (majorRadius <= gp::Resolution(),
61                                        "gp_Hypr::Asymptote1() - major radius is zero");
62   gp_Vec V1 = gp_Vec (pos.YDirection());
63   V1.Multiply (minorRadius / majorRadius);
64   gp_Vec V = gp_Vec (pos.XDirection());
65   V.Add (V1);
66   return  gp_Ax1(pos.Location(), gp_Dir(V));
67 }
68
69 inline gp_Ax1 gp_Hypr::Asymptote2 () const
70 {
71   Standard_ConstructionError_Raise_if (majorRadius <= gp::Resolution(),
72                                        "gp_Hypr::Asymptote1() - major radius is zero");
73   gp_Vec V1 = gp_Vec (pos.YDirection());
74   V1.Multiply (-minorRadius / majorRadius);
75   gp_Vec V = gp_Vec (pos.XDirection());
76   V.Add (V1);
77   return  gp_Ax1( pos.Location(), gp_Dir(V));
78 }
79
80 inline const gp_Ax1& gp_Hypr::Axis () const
81 { return pos.Axis(); }
82
83 inline gp_Hypr gp_Hypr::ConjugateBranch1 () const
84 {
85   return gp_Hypr (gp_Ax2(pos.Location(), pos.Direction(), pos.YDirection()),
86                   minorRadius, 
87                   majorRadius);
88 }
89
90 inline gp_Hypr gp_Hypr::ConjugateBranch2 () const
91 {
92   gp_Dir D = pos.YDirection();
93   D.Reverse ();
94   return gp_Hypr (gp_Ax2(pos.Location(), pos.Direction(), D),
95                   minorRadius, 
96                   majorRadius);
97 }
98
99 inline gp_Ax1 gp_Hypr::Directrix1 () const
100 {
101   Standard_Real E = Eccentricity();
102   gp_XYZ Orig = pos.XDirection().XYZ();
103   Orig.Multiply (majorRadius/E);
104   Orig.Add (pos.Location().XYZ());
105   return gp_Ax1 (gp_Pnt(Orig), pos.YDirection());
106 }
107
108 inline gp_Ax1 gp_Hypr::Directrix2 () const
109 {
110   Standard_Real E = Eccentricity();
111   gp_XYZ Orig = pos.XDirection().XYZ();
112   Orig.Multiply (-majorRadius/E);
113   Orig.Add (pos.Location().XYZ());
114   return gp_Ax1 (gp_Pnt(Orig), pos.YDirection());
115 }
116
117 inline Standard_Real gp_Hypr::Eccentricity () const
118 {
119   Standard_DomainError_Raise_if (majorRadius <= gp::Resolution(),
120                                  "gp_Hypr::Eccentricity() - major radius is zero");
121   return sqrt(majorRadius * majorRadius +
122               minorRadius * minorRadius) / majorRadius;
123 }
124
125 inline Standard_Real gp_Hypr::Focal () const
126 {
127   return 2.0 * sqrt(majorRadius * majorRadius +
128                     minorRadius * minorRadius);
129 }
130
131 inline gp_Pnt gp_Hypr::Focus1 () const
132 {
133   Standard_Real C = sqrt(majorRadius * majorRadius +
134                          minorRadius * minorRadius);
135   const gp_Pnt& PP = pos.Location  ();
136   const gp_Dir& DD = pos.XDirection();
137   return gp_Pnt (PP.X() + C * DD.X(),
138                  PP.Y() + C * DD.Y(),
139                  PP.Z() + C * DD.Z());
140 }
141
142 inline gp_Pnt gp_Hypr::Focus2 () const
143 {
144   Standard_Real C = sqrt(majorRadius * majorRadius +
145                          minorRadius * minorRadius);
146   const gp_Pnt& PP = pos.Location  ();
147   const gp_Dir& DD = pos.XDirection();
148   return gp_Pnt (PP.X() - C * DD.X(),
149                  PP.Y() - C * DD.Y(),
150                  PP.Z() - C * DD.Z());
151 }
152
153 inline const gp_Pnt& gp_Hypr::Location () const
154 { return pos.Location(); }
155
156 inline   Standard_Real gp_Hypr::MajorRadius() const
157 { return majorRadius; }
158
159 inline   Standard_Real gp_Hypr::MinorRadius() const
160 { return minorRadius; }
161
162 inline gp_Hypr gp_Hypr::OtherBranch () const
163 {
164   gp_Dir D = pos.XDirection ();
165   D.Reverse ();
166   return gp_Hypr (gp_Ax2(pos.Location(), pos.Direction(), D),
167                   majorRadius, minorRadius);
168 }
169
170 inline Standard_Real gp_Hypr::Parameter() const
171 {
172   Standard_DomainError_Raise_if (majorRadius <= gp::Resolution(),
173                                  "gp_Hypr::Parameter() - major radius is zero");
174   return (minorRadius * minorRadius) / majorRadius;
175 }
176
177 inline   const gp_Ax2& gp_Hypr::Position() const
178 { return pos; }
179
180 inline gp_Ax1 gp_Hypr::XAxis () const
181 {return gp_Ax1 (pos.Location(), pos.XDirection());}
182
183 inline gp_Ax1 gp_Hypr::YAxis () const
184 {return gp_Ax1 (pos.Location(), pos.YDirection());}
185
186 inline void gp_Hypr::Rotate (const gp_Ax1& A1,
187                              const Standard_Real Ang)
188 { pos.Rotate(A1, Ang); }
189
190 inline gp_Hypr gp_Hypr::Rotated (const gp_Ax1& A1,
191                                  const Standard_Real Ang) const
192 {
193   gp_Hypr H = *this;
194   H.pos.Rotate(A1, Ang);
195   return H; 
196 }
197
198 inline void gp_Hypr::Scale (const gp_Pnt& P,
199                             const Standard_Real S)
200 {
201   majorRadius *= S;
202   if (majorRadius < 0) majorRadius = - majorRadius;
203   minorRadius *= S;
204   if (minorRadius < 0) minorRadius = - minorRadius;
205   pos.Scale(P, S);
206 }
207
208 inline gp_Hypr gp_Hypr::Scaled (const gp_Pnt& P,
209                                 const Standard_Real S) const
210 {
211   gp_Hypr H = *this;
212   H.majorRadius *= S;
213   if (H.majorRadius < 0) H.majorRadius = - H.majorRadius;
214   H.minorRadius *= S;
215   if (H.minorRadius < 0) H.minorRadius = - H.minorRadius;
216   H.pos.Scale(P, S);
217   return H; 
218 }
219
220 inline void gp_Hypr::Transform (const gp_Trsf& T)
221
222   majorRadius *= T.ScaleFactor();
223   if (majorRadius < 0) majorRadius = - majorRadius;
224   minorRadius *= T.ScaleFactor();
225   if (minorRadius < 0) minorRadius = - minorRadius;
226   pos.Transform(T);
227 }
228
229 inline gp_Hypr gp_Hypr::Transformed (const gp_Trsf& T) const
230 {
231   gp_Hypr H = *this;
232   H.majorRadius *= T.ScaleFactor();
233   if (H.majorRadius < 0) H.majorRadius = - H.majorRadius;
234   H.minorRadius *= T.ScaleFactor();
235   if (H.minorRadius < 0) H.minorRadius = - H.minorRadius;
236   H.pos.Transform(T);
237   return H; 
238 }
239
240 inline void gp_Hypr::Translate (const gp_Vec& V)
241 { pos.Translate(V); }
242
243 inline gp_Hypr gp_Hypr::Translated (const gp_Vec& V) const
244 {
245   gp_Hypr H = *this;
246   H.pos.Translate(V);
247   return H; 
248 }
249
250 inline void gp_Hypr::Translate (const gp_Pnt& P1,
251                                 const gp_Pnt& P2)
252 {pos.Translate(P1,P2);}
253
254 inline gp_Hypr gp_Hypr::Translated (const gp_Pnt& P1,
255                                     const gp_Pnt& P2) const
256 {
257   gp_Hypr H = *this;
258   H.pos.Translate(P1, P2);
259   return H; 
260 }
261