2fc6f8d739387d0d6e31d372b2ff2a10fffc51da
[occt.git] / src / gp / gp_Elips2d.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_Trsf2d.hxx>
16 #include <gp.hxx>
17 #include <Standard_ConstructionError.hxx>
18
19 inline gp_Elips2d::gp_Elips2d() :
20 majorRadius(RealLast()),
21 minorRadius(RealSmall())
22 { }
23
24 inline gp_Elips2d::gp_Elips2d (const gp_Ax2d& MajorAxis, 
25                                const Standard_Real MajorRadius, 
26                                const Standard_Real MinorRadius,
27                                const Standard_Boolean Sense) :  
28                                majorRadius(MajorRadius), 
29                                minorRadius(MinorRadius) 
30
31   pos = gp_Ax22d(MajorAxis,Sense); 
32   Standard_ConstructionError_Raise_if
33     (MinorRadius < 0.0 || MajorRadius < MinorRadius,"");
34 }
35
36 inline gp_Elips2d::gp_Elips2d (const gp_Ax22d& A, 
37                                const Standard_Real MajorRadius, 
38                                const Standard_Real MinorRadius) :  
39                                pos(A), 
40                                majorRadius(MajorRadius), 
41                                minorRadius(MinorRadius) 
42
43   Standard_ConstructionError_Raise_if
44     (MinorRadius < 0.0 || MajorRadius < MinorRadius,"");
45 }
46
47 inline void gp_Elips2d::SetLocation (const gp_Pnt2d& P)
48 {  pos.SetLocation(P);}
49
50 inline void gp_Elips2d::SetMajorRadius (const Standard_Real MajorRadius)
51
52   Standard_ConstructionError_Raise_if(MajorRadius < minorRadius,"");
53   majorRadius = MajorRadius;
54 }
55
56 inline void gp_Elips2d::SetMinorRadius (const Standard_Real MinorRadius)
57
58   Standard_ConstructionError_Raise_if
59     (MinorRadius < 0.0 || majorRadius < MinorRadius,"");
60   minorRadius = MinorRadius;
61 }
62
63 inline void gp_Elips2d::SetXAxis (const gp_Ax2d& A)
64 { pos.SetXAxis(A); }
65
66 inline void gp_Elips2d::SetAxis (const gp_Ax22d& A)
67 { pos.SetAxis(A); }
68
69 inline void gp_Elips2d::SetYAxis (const gp_Ax2d& A)
70 {  pos.SetYAxis(A); }
71
72 inline  Standard_Real gp_Elips2d::Area() const
73 { return M_PI * majorRadius * minorRadius; }
74
75 inline gp_Ax2d gp_Elips2d::Directrix1() const
76 {
77   Standard_Real E = Eccentricity();
78   Standard_ConstructionError_Raise_if (E <= gp::Resolution(), "");
79   gp_XY Orig = pos.XDirection().XY();
80   Orig.Multiply (majorRadius/E);
81   Orig.Add (pos.Location().XY());
82   return gp_Ax2d (gp_Pnt2d(Orig),gp_Dir2d (pos.YDirection()));
83 }
84
85 inline gp_Ax2d gp_Elips2d::Directrix2() const
86 {
87   Standard_Real E = Eccentricity();
88   Standard_ConstructionError_Raise_if (E <= gp::Resolution(), "");
89   gp_XY Orig = pos.XDirection().XY();
90   Orig.Multiply (-majorRadius/E);
91   Orig.Add (pos.Location().XY());
92   return gp_Ax2d (gp_Pnt2d(Orig),gp_Dir2d (pos.YDirection()));
93 }
94
95 inline Standard_Real gp_Elips2d::Eccentricity() const
96 {
97   if (majorRadius == 0.0) {  return 0.0; }
98   else {
99     return sqrt(majorRadius * majorRadius - 
100                 minorRadius * minorRadius) / majorRadius;
101   }
102 }
103
104 inline Standard_Real gp_Elips2d::Focal() const
105 {
106   return 2.0 * sqrt(majorRadius * majorRadius -
107                     minorRadius * minorRadius);
108 }
109
110 inline gp_Pnt2d gp_Elips2d::Focus1() const
111 {
112   Standard_Real C = sqrt(majorRadius * majorRadius -
113                          minorRadius * minorRadius);
114   const gp_Pnt2d& PP = pos.Location  ();
115   const gp_Dir2d& DD = pos.XDirection();
116   return gp_Pnt2d (PP.X() + C * DD.X(),
117                    PP.Y() + C * DD.Y());
118 }
119
120 inline gp_Pnt2d gp_Elips2d::Focus2() const
121 {
122   Standard_Real C = sqrt (majorRadius * majorRadius -
123                           minorRadius * minorRadius);
124   const gp_Pnt2d& PP = pos.Location  ();
125   const gp_Dir2d& DD = pos.XDirection();
126   return gp_Pnt2d (PP.X() - C * DD.X(),
127                    PP.Y() - C * DD.Y());
128 }
129
130 inline const gp_Pnt2d& gp_Elips2d::Location () const
131 { return pos.Location(); }
132
133 inline   Standard_Real gp_Elips2d::MajorRadius() const
134 { return majorRadius; }
135
136 inline   Standard_Real gp_Elips2d::MinorRadius() const
137 { return minorRadius; }
138
139 inline Standard_Real gp_Elips2d::Parameter () const
140
141   if (majorRadius == 0.0) return 0.0;
142   else                    return (minorRadius * minorRadius) / majorRadius;
143 }
144
145 inline   const gp_Ax22d& gp_Elips2d::Axis () const
146 { return pos; }
147
148 inline gp_Ax2d gp_Elips2d::YAxis () const
149 {  return pos.YAxis(); }
150
151 inline gp_Ax2d gp_Elips2d::XAxis () const
152 {   return pos.XAxis();  }
153
154 inline void gp_Elips2d::Reverse() 
155 {
156   gp_Dir2d Temp = pos.YDirection ();
157   Temp.Reverse ();
158   pos.SetAxis(gp_Ax22d(pos.Location(),pos.XDirection(),Temp));
159 }
160
161 inline gp_Elips2d gp_Elips2d::Reversed() const
162 {
163   gp_Elips2d E = *this;
164   gp_Dir2d Temp = pos.YDirection ();
165   Temp.Reverse ();
166   E.pos.SetAxis(gp_Ax22d(pos.Location(),pos.XDirection(),Temp));
167   return E;
168 }
169
170 inline Standard_Boolean gp_Elips2d::IsDirect() const
171 { return (pos.XDirection().Crossed(pos.YDirection())) >= 0.0; }
172
173 inline void gp_Elips2d::Rotate (const gp_Pnt2d& P,
174                                 const Standard_Real Ang)
175 { pos.Rotate (P, Ang); }
176
177 inline gp_Elips2d gp_Elips2d::Rotated (const gp_Pnt2d& P,
178                                        const Standard_Real Ang) const  
179 {
180   gp_Elips2d E = *this;
181   E.pos.Rotate (P, Ang);
182   return E; 
183 }
184
185 inline void gp_Elips2d::Scale (const gp_Pnt2d& P,
186                                const Standard_Real S) 
187
188   majorRadius *= S;
189   if (majorRadius < 0) majorRadius = - majorRadius;
190   minorRadius *= S;
191   if (minorRadius < 0) minorRadius = - minorRadius;
192   pos.Scale(P, S);
193 }
194
195 inline gp_Elips2d gp_Elips2d::Scaled (const gp_Pnt2d& P,
196                                       const Standard_Real S) const  
197 {
198   gp_Elips2d E = *this;
199   E.majorRadius *= S;
200   if (E.majorRadius < 0) E.majorRadius = - E.majorRadius;
201   E.minorRadius *= S;
202   if (E.minorRadius < 0) E.minorRadius = - E.minorRadius;
203   E.pos.Scale(P, S);
204   return E; 
205 }
206
207 inline void gp_Elips2d::Transform(const gp_Trsf2d& T)
208 {
209   Standard_Real TSca = T.ScaleFactor();
210   if(TSca<0.0) TSca=-TSca;
211   majorRadius *=  TSca;
212   minorRadius *=  TSca;
213   pos.Transform(T);
214 }
215
216 inline gp_Elips2d gp_Elips2d::Transformed (const gp_Trsf2d& T) const  
217 {
218   gp_Elips2d E = *this;
219   E.majorRadius *= T.ScaleFactor();
220   if (E.majorRadius < 0) E.majorRadius = - E.majorRadius;
221   E.minorRadius *= T.ScaleFactor();
222   if (E.minorRadius < 0) E.minorRadius = - E.minorRadius;
223   E.pos.Transform(T);
224   return E;
225 }
226
227 inline void gp_Elips2d::Translate (const gp_Vec2d& V)
228 { pos.Translate(V); }
229
230 inline gp_Elips2d gp_Elips2d::Translated (const gp_Vec2d& V) const  
231 {
232   gp_Elips2d E = *this;
233   E.pos.Translate(V);
234   return E; 
235 }
236
237 inline void gp_Elips2d::Translate (const gp_Pnt2d& P1,
238                                    const gp_Pnt2d& P2) 
239 { pos.Translate(P1, P2); }
240
241 inline gp_Elips2d gp_Elips2d::Translated (const gp_Pnt2d& P1,
242                                           const gp_Pnt2d& P2) const  
243 {
244   gp_Elips2d E = *this;
245   E.pos.Translate(P1, P2);
246   return E; 
247 }
248