0024927: Getting rid of "Persistent" functionality -- Storable
[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
32     (MinorRadius < 0.0 || MajorRadius < 0.0,"");
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   majorRadius = R;
45 }
46
47 inline void gp_Hypr::SetMinorRadius (const Standard_Real R)
48 {
49   Standard_ConstructionError_Raise_if(R < 0.0,"");
50   minorRadius = R;
51 }
52
53 inline void gp_Hypr::SetPosition (const gp_Ax2& A2)
54 { pos = A2; }
55
56 inline gp_Ax1 gp_Hypr::Asymptote1 () const
57 {
58   Standard_ConstructionError_Raise_if
59     (majorRadius <= gp::Resolution(), "");
60   gp_Vec V1 = gp_Vec (pos.YDirection());
61   V1.Multiply (minorRadius / majorRadius);
62   gp_Vec V = gp_Vec (pos.XDirection());
63   V.Add (V1);
64   return  gp_Ax1(pos.Location(), gp_Dir(V));
65 }
66
67 inline gp_Ax1 gp_Hypr::Asymptote2 () const
68 {
69   Standard_ConstructionError_Raise_if (majorRadius <= gp::Resolution(), "");
70   gp_Vec V1 = gp_Vec (pos.YDirection());
71   V1.Multiply (-minorRadius / majorRadius);
72   gp_Vec V = gp_Vec (pos.XDirection());
73   V.Add (V1);
74   return  gp_Ax1( pos.Location(), gp_Dir(V));
75 }
76
77 inline const gp_Ax1& gp_Hypr::Axis () const
78 { return pos.Axis(); }
79
80 inline gp_Hypr gp_Hypr::ConjugateBranch1 () const
81 {
82   return gp_Hypr (gp_Ax2(pos.Location(), pos.Direction(), pos.YDirection()),
83                   minorRadius, 
84                   majorRadius);
85 }
86
87 inline gp_Hypr gp_Hypr::ConjugateBranch2 () const
88 {
89   gp_Dir D = pos.YDirection();
90   D.Reverse ();
91   return gp_Hypr (gp_Ax2(pos.Location(), pos.Direction(), D),
92                   minorRadius, 
93                   majorRadius);
94 }
95
96 inline gp_Ax1 gp_Hypr::Directrix1 () const
97 {
98   Standard_Real E = Eccentricity();
99   gp_XYZ Orig = pos.XDirection().XYZ();
100   Orig.Multiply (majorRadius/E);
101   Orig.Add (pos.Location().XYZ());
102   return gp_Ax1 (gp_Pnt(Orig), pos.YDirection());
103 }
104
105 inline gp_Ax1 gp_Hypr::Directrix2 () const
106 {
107   Standard_Real E = Eccentricity();
108   gp_XYZ Orig = pos.XDirection().XYZ();
109   Orig.Multiply (-majorRadius/E);
110   Orig.Add (pos.Location().XYZ());
111   return gp_Ax1 (gp_Pnt(Orig), pos.YDirection());
112 }
113
114 inline Standard_Real gp_Hypr::Eccentricity () const
115 {
116   Standard_DomainError_Raise_if (majorRadius <= gp::Resolution(), "");
117   return sqrt(majorRadius * majorRadius +
118               minorRadius * minorRadius) / majorRadius;
119 }
120
121 inline Standard_Real gp_Hypr::Focal () const
122 {
123   return 2.0 * sqrt(majorRadius * majorRadius +
124                     minorRadius * minorRadius);
125 }
126
127 inline gp_Pnt gp_Hypr::Focus1 () const
128 {
129   Standard_Real C = sqrt(majorRadius * majorRadius +
130                          minorRadius * minorRadius);
131   const gp_Pnt& PP = pos.Location  ();
132   const gp_Dir& DD = pos.XDirection();
133   return gp_Pnt (PP.X() + C * DD.X(),
134                  PP.Y() + C * DD.Y(),
135                  PP.Z() + C * DD.Z());
136 }
137
138 inline gp_Pnt gp_Hypr::Focus2 () const
139 {
140   Standard_Real C = sqrt(majorRadius * majorRadius +
141                          minorRadius * minorRadius);
142   const gp_Pnt& PP = pos.Location  ();
143   const gp_Dir& DD = pos.XDirection();
144   return gp_Pnt (PP.X() - C * DD.X(),
145                  PP.Y() - C * DD.Y(),
146                  PP.Z() - C * DD.Z());
147 }
148
149 inline const gp_Pnt& gp_Hypr::Location () const
150 { return pos.Location(); }
151
152 inline   Standard_Real gp_Hypr::MajorRadius() const
153 { return majorRadius; }
154
155 inline   Standard_Real gp_Hypr::MinorRadius() const
156 { return minorRadius; }
157
158 inline gp_Hypr gp_Hypr::OtherBranch () const
159 {
160   gp_Dir D = pos.XDirection ();
161   D.Reverse ();
162   return gp_Hypr (gp_Ax2(pos.Location(), pos.Direction(), D),
163                   majorRadius, minorRadius);
164 }
165
166 inline Standard_Real gp_Hypr::Parameter() const
167 {
168   Standard_DomainError_Raise_if (majorRadius <= gp::Resolution(), "");
169   return (minorRadius * minorRadius) / majorRadius;
170 }
171
172 inline   const gp_Ax2& gp_Hypr::Position() const
173 { return pos; }
174
175 inline gp_Ax1 gp_Hypr::XAxis () const
176 {return gp_Ax1 (pos.Location(), pos.XDirection());}
177
178 inline gp_Ax1 gp_Hypr::YAxis () const
179 {return gp_Ax1 (pos.Location(), pos.YDirection());}
180
181 inline void gp_Hypr::Rotate (const gp_Ax1& A1,
182                              const Standard_Real Ang)
183 { pos.Rotate(A1, Ang); }
184
185 inline gp_Hypr gp_Hypr::Rotated (const gp_Ax1& A1,
186                                  const Standard_Real Ang) const
187 {
188   gp_Hypr H = *this;
189   H.pos.Rotate(A1, Ang);
190   return H; 
191 }
192
193 inline void gp_Hypr::Scale (const gp_Pnt& P,
194                             const Standard_Real S)
195 {
196   majorRadius *= S;
197   if (majorRadius < 0) majorRadius = - majorRadius;
198   minorRadius *= S;
199   if (minorRadius < 0) minorRadius = - minorRadius;
200   pos.Scale(P, S);
201 }
202
203 inline gp_Hypr gp_Hypr::Scaled (const gp_Pnt& P,
204                                 const Standard_Real S) const
205 {
206   gp_Hypr H = *this;
207   H.majorRadius *= S;
208   if (H.majorRadius < 0) H.majorRadius = - H.majorRadius;
209   H.minorRadius *= S;
210   if (H.minorRadius < 0) H.minorRadius = - H.minorRadius;
211   H.pos.Scale(P, S);
212   return H; 
213 }
214
215 inline void gp_Hypr::Transform (const gp_Trsf& T)
216
217   majorRadius *= T.ScaleFactor();
218   if (majorRadius < 0) majorRadius = - majorRadius;
219   minorRadius *= T.ScaleFactor();
220   if (minorRadius < 0) minorRadius = - minorRadius;
221   pos.Transform(T);
222 }
223
224 inline gp_Hypr gp_Hypr::Transformed (const gp_Trsf& T) const
225 {
226   gp_Hypr H = *this;
227   H.majorRadius *= T.ScaleFactor();
228   if (H.majorRadius < 0) H.majorRadius = - H.majorRadius;
229   H.minorRadius *= T.ScaleFactor();
230   if (H.minorRadius < 0) H.minorRadius = - H.minorRadius;
231   H.pos.Transform(T);
232   return H; 
233 }
234
235 inline void gp_Hypr::Translate (const gp_Vec& V)
236 { pos.Translate(V); }
237
238 inline gp_Hypr gp_Hypr::Translated (const gp_Vec& V) const
239 {
240   gp_Hypr H = *this;
241   H.pos.Translate(V);
242   return H; 
243 }
244
245 inline void gp_Hypr::Translate (const gp_Pnt& P1,
246                                 const gp_Pnt& P2)
247 {pos.Translate(P1,P2);}
248
249 inline gp_Hypr gp_Hypr::Translated (const gp_Pnt& P1,
250                                     const gp_Pnt& P2) const
251 {
252   gp_Hypr H = *this;
253   H.pos.Translate(P1, P2);
254   return H; 
255 }
256