543cb712ad2b1d88c1983c53c8a820d37fb86acf
[occt.git] / src / gp / gp_Elips.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 //  Modified by skv - Fri Apr  8 10:28:10 2005 OCC8559
16
17
18 #include <gp.hxx>
19 #include <Standard_ConstructionError.hxx>
20
21 inline gp_Elips::gp_Elips () :
22 majorRadius (RealLast()),
23 minorRadius (RealSmall())
24 { }
25
26 inline gp_Elips::gp_Elips (const gp_Ax2& A2,
27                            const Standard_Real MajorRadius,
28                            const Standard_Real MinorRadius) :
29                            pos(A2),
30                            majorRadius (MajorRadius),
31                            minorRadius (MinorRadius)
32
33   Standard_ConstructionError_Raise_if (MinorRadius < 0.0 || MajorRadius < MinorRadius,
34                                        "gp_Elips() - invalid construction parameters");
35 }
36
37 inline Standard_Real gp_Elips::Area() const
38 { return M_PI * majorRadius * minorRadius; }
39
40 inline Standard_Real gp_Elips::MajorRadius() const
41 { return majorRadius; }
42
43 inline Standard_Real gp_Elips::MinorRadius() const
44 { return minorRadius; }
45
46 inline Standard_Real gp_Elips::Parameter() const
47
48   if (majorRadius == 0.0) return 0.0;
49   else                    return (minorRadius * minorRadius) / majorRadius;
50 }
51
52 inline const gp_Ax2& gp_Elips::Position() const
53 { return pos; }
54
55 inline const gp_Ax1& gp_Elips::Axis ()     const
56 { return pos.Axis(); }
57
58 inline gp_Ax1 gp_Elips::Directrix1() const
59 {
60   Standard_Real E = Eccentricity();
61   Standard_ConstructionError_Raise_if (E <= gp::Resolution(), "gp_Elips::Directrix1() - zero eccentricity");
62   gp_XYZ Orig = pos.XDirection().XYZ();
63   Orig.Multiply (majorRadius/E);
64   Orig.Add (pos.Location().XYZ());
65   return gp_Ax1 (gp_Pnt(Orig), pos.YDirection());
66 }
67
68 inline gp_Ax1 gp_Elips::Directrix2() const
69 {
70   Standard_Real E = Eccentricity();
71   Standard_ConstructionError_Raise_if (E <= gp::Resolution(), "gp_Elips::Directrix2() - zero eccentricity");
72   gp_XYZ Orig = pos.XDirection().XYZ();
73   Orig.Multiply (-majorRadius/E);
74   Orig.Add (pos.Location().XYZ());
75   return gp_Ax1 (gp_Pnt(Orig), pos.YDirection());
76 }
77
78 inline Standard_Real gp_Elips::Eccentricity() const
79 {
80   if (majorRadius == 0.0) { return 0.0; }
81   else {
82     return sqrt(majorRadius * majorRadius - 
83                 minorRadius * minorRadius) / majorRadius;
84   }
85 }
86
87 inline Standard_Real gp_Elips::Focal() const
88 {
89   return 2.0 * sqrt(majorRadius * majorRadius -
90                     minorRadius * minorRadius);
91 }
92
93 inline gp_Pnt gp_Elips::Focus1() const
94 {
95   Standard_Real C = sqrt(majorRadius * majorRadius -
96                          minorRadius * minorRadius);
97   const gp_Pnt& PP = pos.Location  ();
98   const gp_Dir& DD = pos.XDirection();
99   return gp_Pnt (PP.X() + C * DD.X(),
100                  PP.Y() + C * DD.Y(),
101                  PP.Z() + C * DD.Z());
102 }
103
104 inline gp_Pnt gp_Elips::Focus2() const
105 {
106   Standard_Real C = sqrt(majorRadius * majorRadius -
107                          minorRadius * minorRadius);
108   const gp_Pnt& PP = pos.Location  ();
109   const gp_Dir& DD = pos.XDirection();
110   return gp_Pnt (PP.X() - C * DD.X(),
111                  PP.Y() - C * DD.Y(),
112                  PP.Z() - C * DD.Z());
113 }
114
115 inline const gp_Pnt& gp_Elips::Location () const
116 { return pos.Location(); }
117
118 inline gp_Ax1 gp_Elips::XAxis () const
119 { return gp_Ax1 (pos.Location(), pos.XDirection()); }
120
121 inline gp_Ax1 gp_Elips::YAxis () const
122 { return gp_Ax1 (pos.Location(), pos.YDirection()); }
123
124 inline void gp_Elips::SetAxis (const gp_Ax1& A1)
125 { pos.SetAxis(A1); }
126
127 inline void gp_Elips::SetPosition (const gp_Ax2& A2)
128 { pos = A2; }
129
130 inline void gp_Elips::SetLocation (const gp_Pnt& P)
131 { pos.SetLocation (P); }
132
133 inline void gp_Elips::SetMajorRadius (const Standard_Real R)
134
135   Standard_ConstructionError_Raise_if (R < minorRadius,
136                                        "gp_Elips::SetMajorRadius() - major radius should be greater or equal to minor radius");
137   majorRadius = R;
138 }
139
140 inline void gp_Elips::SetMinorRadius (const Standard_Real R)
141
142   Standard_ConstructionError_Raise_if (R < 0.0 || majorRadius < R,
143                                        "gp_Elips::SetMinorRadius() - minor radius should be a positive number lesser or equal to major radius");
144   minorRadius = R;
145 }
146
147 inline void gp_Elips::Rotate (const gp_Ax1& A1,
148                               const Standard_Real Ang) { pos.Rotate(A1, Ang); }
149
150 inline gp_Elips gp_Elips::Rotated (const gp_Ax1& A1,
151                                    const Standard_Real Ang) const
152 {
153   gp_Elips E = *this;
154   E.pos.Rotate(A1, Ang);
155   return E; 
156 }
157
158 inline void gp_Elips::Scale (const gp_Pnt& P,
159                              const Standard_Real S)
160 //  Modified by skv - Fri Apr  8 10:28:10 2005 OCC8559 Begin
161 // { pos.Scale(P, S); }
162 {
163   majorRadius *= S;
164   if (majorRadius < 0) majorRadius = - majorRadius;
165   minorRadius *= S;
166   if (minorRadius < 0) minorRadius = - minorRadius;
167   pos.Scale(P, S);
168 }
169 //  Modified by skv - Fri Apr  8 10:28:10 2005 OCC8559 End
170
171 inline gp_Elips gp_Elips::Scaled (const gp_Pnt& P,
172                                   const Standard_Real S) const
173 {
174   gp_Elips E = *this;
175   E.majorRadius *= S;
176   if (E.majorRadius < 0) E.majorRadius = - E.majorRadius;
177   E.minorRadius *= S;
178   if (E.minorRadius < 0) E.minorRadius = - E.minorRadius;
179   E.pos.Scale(P, S);
180   return E; 
181 }
182
183 inline void gp_Elips::Transform (const gp_Trsf& T)
184 {
185   majorRadius *= T.ScaleFactor();
186   if (majorRadius < 0) majorRadius = - majorRadius;
187   minorRadius *= T.ScaleFactor();
188   if (minorRadius < 0) minorRadius = - minorRadius;
189   pos.Transform(T);
190 }
191
192 inline gp_Elips gp_Elips::Transformed (const gp_Trsf& T) const
193 {
194   gp_Elips E = *this;
195   E.majorRadius *= T.ScaleFactor();
196   if (E.majorRadius < 0) E.majorRadius = - E.majorRadius;
197   E.minorRadius *= T.ScaleFactor();
198   if (E.minorRadius < 0) E.minorRadius = - E.minorRadius;
199   E.pos.Transform(T);
200   return E;
201 }
202
203 inline void gp_Elips::Translate (const gp_Vec& V) 
204 { pos.Translate(V); }
205
206 inline gp_Elips gp_Elips::Translated (const gp_Vec& V) const 
207 {
208   gp_Elips E = *this;
209   E.pos.Translate(V);
210   return E; 
211 }
212
213 inline void gp_Elips::Translate (const gp_Pnt& P1,
214                           const gp_Pnt& P2)
215 {  pos.Translate(P1, P2); }
216
217 inline gp_Elips gp_Elips::Translated (const gp_Pnt& P1,
218                                       const gp_Pnt& P2) const
219 {
220   gp_Elips E = *this;
221   E.pos.Translate(P1, P2);
222   return E; 
223 }
224