0032137: Coding Rules - merge redundant .lxx files into header files within Package gp
[occt.git] / src / gp / gp_Circ2d.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 <Standard_ConstructionError.hxx>
16
17 inline gp_Circ2d::gp_Circ2d () : radius(RealLast())
18 { }
19
20 inline gp_Circ2d::gp_Circ2d (const gp_Ax2d& XAxis, 
21                              const Standard_Real Radius,
22                              const Standard_Boolean Sense) : radius(Radius)
23 {
24   Standard_ConstructionError_Raise_if (Radius < 0.0, "gp_Circ2d() - radius should be positive number");
25   pos = gp_Ax22d(XAxis,Sense);
26 }
27
28 inline gp_Circ2d::gp_Circ2d (const gp_Ax22d&     Axis, 
29                              const Standard_Real Radius) :
30                              pos(Axis),
31                              radius(Radius)
32 {
33   Standard_ConstructionError_Raise_if (Radius < 0.0, "gp_Circ2d() - radius should be positive number");
34 }
35
36 inline void gp_Circ2d::SetLocation (const gp_Pnt2d& P)
37 { pos.SetLocation (P); }
38
39 inline void gp_Circ2d::SetXAxis (const gp_Ax2d& A)
40 {  pos.SetXAxis(A); }
41
42 inline void gp_Circ2d::SetAxis (const gp_Ax22d& A)
43 {  pos.SetAxis(A);}
44
45 inline void gp_Circ2d::SetYAxis (const gp_Ax2d& A)
46 {   pos.SetYAxis(A); }
47
48 inline void gp_Circ2d::SetRadius (const Standard_Real Radius)
49
50   Standard_ConstructionError_Raise_if (Radius < 0.0, "gp_Circ2d::SetRadius() - radius should be positive number");
51   radius = Radius;
52 }
53
54 inline   Standard_Real gp_Circ2d::Area() const
55 { return M_PI * radius * radius; }
56
57 inline void gp_Circ2d::Coefficients (Standard_Real& A,
58                                      Standard_Real& B,
59                                      Standard_Real& C,
60                                      Standard_Real& D,
61                                      Standard_Real& E,
62                                      Standard_Real& F) const
63 {
64   Standard_Real Xc = pos.Location().X();
65   Standard_Real Yc = pos.Location().Y();
66   A = 1.0;
67   B = 1.0;
68   C = 0.0;
69   D = - Xc;
70   E = - Yc;
71   F = Xc * Xc + Yc * Yc - radius * radius;
72 }
73
74 inline Standard_Boolean gp_Circ2d::Contains
75 (const gp_Pnt2d& P,
76  const Standard_Real LinearTolerance) const
77 { return Distance(P) <= LinearTolerance; }
78
79 inline Standard_Real gp_Circ2d::Distance (const gp_Pnt2d& P) const
80 {
81   gp_XY Coord = P.XY();
82   Coord.Subtract (pos.Location().XY());
83   Standard_Real D = radius - Coord.Modulus();
84   if (D < 0) D = - D;
85   return D;
86 }
87
88 inline Standard_Real gp_Circ2d::SquareDistance (const gp_Pnt2d& P) const
89 {
90   gp_XY Coord = P.XY();
91   Coord.Subtract (pos.Location().XY());        
92   Standard_Real D = radius - Coord.Modulus();
93   return D * D;
94 }
95
96 inline   Standard_Real gp_Circ2d::Length() const
97 { return 2. * M_PI * radius; }
98
99 inline const gp_Pnt2d& gp_Circ2d::Location () const
100 {return pos.Location(); }
101
102 inline   Standard_Real gp_Circ2d::Radius() const
103 { return radius; }
104
105 inline   const gp_Ax22d& gp_Circ2d::Axis () const
106 { return pos; }
107
108 inline   const gp_Ax22d& gp_Circ2d::Position () const
109 { return pos; }
110
111 inline gp_Ax2d gp_Circ2d::XAxis () const
112 { return gp_Ax2d (pos.XAxis()); }
113
114 inline gp_Ax2d gp_Circ2d::YAxis () const
115 { return gp_Ax2d (pos.YAxis()); }
116
117 inline void gp_Circ2d::Reverse() 
118 {
119   gp_Dir2d Temp = pos.YDirection ();
120   Temp.Reverse ();
121   pos.SetAxis(gp_Ax22d(pos.Location(),pos.XDirection(),Temp));
122 }
123
124 inline gp_Circ2d gp_Circ2d::Reversed() const
125 {
126   gp_Circ2d C = *this;
127   gp_Dir2d Temp = pos.YDirection ();
128   Temp.Reverse ();
129   C.pos.SetAxis(gp_Ax22d(pos.Location(),pos.XDirection(),Temp));
130   return C;
131 }
132
133 inline Standard_Boolean gp_Circ2d::IsDirect() const
134 { return (pos.XDirection().Crossed(pos.YDirection())) >= 0.0; }
135
136 inline void gp_Circ2d::Rotate (const gp_Pnt2d& P,
137                                const Standard_Real Ang)
138 {pos.Rotate (P, Ang);}
139
140 inline gp_Circ2d gp_Circ2d::Rotated (const gp_Pnt2d& P,
141                                      const Standard_Real Ang) const
142 {
143   gp_Circ2d C = *this;
144   C.pos.Rotate (P, Ang);
145   return C; 
146 }
147
148 inline void gp_Circ2d::Scale (const gp_Pnt2d& P,
149                               const Standard_Real S)
150
151   radius *= S;
152   if (radius < 0) radius = - radius;
153   pos.Scale(P, S);
154 }
155
156 inline gp_Circ2d gp_Circ2d::Scaled (const gp_Pnt2d& P,
157                                     const Standard_Real S) const
158 {
159   gp_Circ2d C = *this;
160   C.radius *= S;
161   if (C.radius < 0) C.radius = - C.radius;
162   C.pos.Scale(P, S);
163   return C; 
164 }
165
166 inline void gp_Circ2d::Transform (const gp_Trsf2d& T)
167 {
168   radius *= T.ScaleFactor();
169   if (radius < 0) radius = - radius;
170   pos.Transform(T);
171 }
172
173 inline gp_Circ2d gp_Circ2d::Transformed (const gp_Trsf2d& T) const
174 {
175   gp_Circ2d C = *this;
176   C.radius *= T.ScaleFactor();
177   if (C.radius < 0) C.radius = - C.radius;
178   C.pos.Transform(T);
179   return C;
180 }
181
182 inline void gp_Circ2d::Translate (const gp_Vec2d& V)
183 { pos.Translate(V); }
184
185 inline gp_Circ2d gp_Circ2d::Translated (const gp_Vec2d& V) const
186 {
187   gp_Circ2d C = *this;
188   C.pos.Translate(V);
189   return C; 
190 }
191
192 inline void gp_Circ2d::Translate (const gp_Pnt2d& P1,
193                                   const gp_Pnt2d& P2)
194 { pos.Translate(P1, P2); }
195
196 inline gp_Circ2d gp_Circ2d::Translated (const gp_Pnt2d& P1,
197                                         const gp_Pnt2d& P2) const
198 {
199   gp_Circ2d C = *this;
200   C.pos.Translate(P1, P2);
201   return C; 
202 }
203