0028550: Foundation Classes - fix empty message passed to thrown exception
[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 (MinorRadius < 0.0 || MajorRadius < MinorRadius,
33                                        "gp_Elips2d() - invalid construction parameters");
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 (MinorRadius < 0.0 || MajorRadius < MinorRadius,
44                                        "gp_Elips2d() - invalid construction parameters");
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                                        "gp_Elips2d::SetMajorRadius() - major radius should be greater or equal to minor radius");
54   majorRadius = MajorRadius;
55 }
56
57 inline void gp_Elips2d::SetMinorRadius (const Standard_Real MinorRadius)
58
59   Standard_ConstructionError_Raise_if (MinorRadius < 0.0 || majorRadius < MinorRadius,
60                                        "gp_Elips2d::SetMinorRadius() - minor radius should be a positive number lesser or equal to major radius");
61   minorRadius = MinorRadius;
62 }
63
64 inline void gp_Elips2d::SetXAxis (const gp_Ax2d& A)
65 { pos.SetXAxis(A); }
66
67 inline void gp_Elips2d::SetAxis (const gp_Ax22d& A)
68 { pos.SetAxis(A); }
69
70 inline void gp_Elips2d::SetYAxis (const gp_Ax2d& A)
71 {  pos.SetYAxis(A); }
72
73 inline  Standard_Real gp_Elips2d::Area() const
74 { return M_PI * majorRadius * minorRadius; }
75
76 inline gp_Ax2d gp_Elips2d::Directrix1() const
77 {
78   Standard_Real E = Eccentricity();
79   Standard_ConstructionError_Raise_if (E <= gp::Resolution(), "gp_Elips2d::Directrix1() - zero eccentricity");
80   gp_XY Orig = pos.XDirection().XY();
81   Orig.Multiply (majorRadius/E);
82   Orig.Add (pos.Location().XY());
83   return gp_Ax2d (gp_Pnt2d(Orig),gp_Dir2d (pos.YDirection()));
84 }
85
86 inline gp_Ax2d gp_Elips2d::Directrix2() const
87 {
88   Standard_Real E = Eccentricity();
89   Standard_ConstructionError_Raise_if (E <= gp::Resolution(), "gp_Elips2d::Directrix2() - zero eccentricity");
90   gp_XY Orig = pos.XDirection().XY();
91   Orig.Multiply (-majorRadius/E);
92   Orig.Add (pos.Location().XY());
93   return gp_Ax2d (gp_Pnt2d(Orig),gp_Dir2d (pos.YDirection()));
94 }
95
96 inline Standard_Real gp_Elips2d::Eccentricity() const
97 {
98   if (majorRadius == 0.0) {  return 0.0; }
99   else {
100     return sqrt(majorRadius * majorRadius - 
101                 minorRadius * minorRadius) / majorRadius;
102   }
103 }
104
105 inline Standard_Real gp_Elips2d::Focal() const
106 {
107   return 2.0 * sqrt(majorRadius * majorRadius -
108                     minorRadius * minorRadius);
109 }
110
111 inline gp_Pnt2d gp_Elips2d::Focus1() const
112 {
113   Standard_Real C = sqrt(majorRadius * majorRadius -
114                          minorRadius * minorRadius);
115   const gp_Pnt2d& PP = pos.Location  ();
116   const gp_Dir2d& DD = pos.XDirection();
117   return gp_Pnt2d (PP.X() + C * DD.X(),
118                    PP.Y() + C * DD.Y());
119 }
120
121 inline gp_Pnt2d gp_Elips2d::Focus2() const
122 {
123   Standard_Real C = sqrt (majorRadius * majorRadius -
124                           minorRadius * minorRadius);
125   const gp_Pnt2d& PP = pos.Location  ();
126   const gp_Dir2d& DD = pos.XDirection();
127   return gp_Pnt2d (PP.X() - C * DD.X(),
128                    PP.Y() - C * DD.Y());
129 }
130
131 inline const gp_Pnt2d& gp_Elips2d::Location () const
132 { return pos.Location(); }
133
134 inline   Standard_Real gp_Elips2d::MajorRadius() const
135 { return majorRadius; }
136
137 inline   Standard_Real gp_Elips2d::MinorRadius() const
138 { return minorRadius; }
139
140 inline Standard_Real gp_Elips2d::Parameter () const
141
142   if (majorRadius == 0.0) return 0.0;
143   else                    return (minorRadius * minorRadius) / majorRadius;
144 }
145
146 inline   const gp_Ax22d& gp_Elips2d::Axis () const
147 { return pos; }
148
149 inline gp_Ax2d gp_Elips2d::YAxis () const
150 {  return pos.YAxis(); }
151
152 inline gp_Ax2d gp_Elips2d::XAxis () const
153 {   return pos.XAxis();  }
154
155 inline void gp_Elips2d::Reverse() 
156 {
157   gp_Dir2d Temp = pos.YDirection ();
158   Temp.Reverse ();
159   pos.SetAxis(gp_Ax22d(pos.Location(),pos.XDirection(),Temp));
160 }
161
162 inline gp_Elips2d gp_Elips2d::Reversed() const
163 {
164   gp_Elips2d E = *this;
165   gp_Dir2d Temp = pos.YDirection ();
166   Temp.Reverse ();
167   E.pos.SetAxis(gp_Ax22d(pos.Location(),pos.XDirection(),Temp));
168   return E;
169 }
170
171 inline Standard_Boolean gp_Elips2d::IsDirect() const
172 { return (pos.XDirection().Crossed(pos.YDirection())) >= 0.0; }
173
174 inline void gp_Elips2d::Rotate (const gp_Pnt2d& P,
175                                 const Standard_Real Ang)
176 { pos.Rotate (P, Ang); }
177
178 inline gp_Elips2d gp_Elips2d::Rotated (const gp_Pnt2d& P,
179                                        const Standard_Real Ang) const  
180 {
181   gp_Elips2d E = *this;
182   E.pos.Rotate (P, Ang);
183   return E; 
184 }
185
186 inline void gp_Elips2d::Scale (const gp_Pnt2d& P,
187                                const Standard_Real S) 
188
189   majorRadius *= S;
190   if (majorRadius < 0) majorRadius = - majorRadius;
191   minorRadius *= S;
192   if (minorRadius < 0) minorRadius = - minorRadius;
193   pos.Scale(P, S);
194 }
195
196 inline gp_Elips2d gp_Elips2d::Scaled (const gp_Pnt2d& P,
197                                       const Standard_Real S) const  
198 {
199   gp_Elips2d E = *this;
200   E.majorRadius *= S;
201   if (E.majorRadius < 0) E.majorRadius = - E.majorRadius;
202   E.minorRadius *= S;
203   if (E.minorRadius < 0) E.minorRadius = - E.minorRadius;
204   E.pos.Scale(P, S);
205   return E; 
206 }
207
208 inline void gp_Elips2d::Transform(const gp_Trsf2d& T)
209 {
210   Standard_Real TSca = T.ScaleFactor();
211   if(TSca<0.0) TSca=-TSca;
212   majorRadius *=  TSca;
213   minorRadius *=  TSca;
214   pos.Transform(T);
215 }
216
217 inline gp_Elips2d gp_Elips2d::Transformed (const gp_Trsf2d& T) const  
218 {
219   gp_Elips2d E = *this;
220   E.majorRadius *= T.ScaleFactor();
221   if (E.majorRadius < 0) E.majorRadius = - E.majorRadius;
222   E.minorRadius *= T.ScaleFactor();
223   if (E.minorRadius < 0) E.minorRadius = - E.minorRadius;
224   E.pos.Transform(T);
225   return E;
226 }
227
228 inline void gp_Elips2d::Translate (const gp_Vec2d& V)
229 { pos.Translate(V); }
230
231 inline gp_Elips2d gp_Elips2d::Translated (const gp_Vec2d& V) const  
232 {
233   gp_Elips2d E = *this;
234   E.pos.Translate(V);
235   return E; 
236 }
237
238 inline void gp_Elips2d::Translate (const gp_Pnt2d& P1,
239                                    const gp_Pnt2d& P2) 
240 { pos.Translate(P1, P2); }
241
242 inline gp_Elips2d gp_Elips2d::Translated (const gp_Pnt2d& P1,
243                                           const gp_Pnt2d& P2) const  
244 {
245   gp_Elips2d E = *this;
246   E.pos.Translate(P1, P2);
247   return E; 
248 }
249