0032137: Coding Rules - merge redundant .lxx files into header files within Package gp
[occt.git] / src / gp / gp_Vec2d.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 // Modif JCV 08/01/91 modifs suite a la deuxieme revue de projet
16 // et introduction des classes XY, Mat2d + nouveau operateurs
17
18 #include <gp_Dir2d.hxx>
19 #include <gp_Trsf2d.hxx>
20 #include <gp_Pnt2d.hxx>
21
22 inline gp_Vec2d::gp_Vec2d()
23 {}
24
25 inline gp_Vec2d::gp_Vec2d (const gp_Dir2d& V)
26 { coord = V.XY(); }
27
28 inline gp_Vec2d::gp_Vec2d (const gp_XY& Coord) : coord(Coord)
29 {}
30
31 inline gp_Vec2d::gp_Vec2d (const Standard_Real Xv,
32                            const Standard_Real Yv) : coord (Xv, Yv)
33 { }
34
35 inline gp_Vec2d::gp_Vec2d (const gp_Pnt2d& P1,
36                            const gp_Pnt2d& P2)
37 { coord = P2.XY().Subtracted (P1.XY()); }
38
39 inline void gp_Vec2d::SetCoord (const Standard_Integer Index,
40                                 const Standard_Real Xi)
41 { coord.SetCoord (Index, Xi); }
42
43 inline void gp_Vec2d::SetCoord (const Standard_Real Xv,
44                                 const Standard_Real Yv)
45 { coord.SetCoord (Xv, Yv); }
46
47 inline void gp_Vec2d::SetX (const Standard_Real X)
48 { coord.SetX (X); }
49
50 inline void gp_Vec2d::SetY (const Standard_Real Y)
51 { coord.SetY (Y); }
52
53 inline void gp_Vec2d::SetXY (const gp_XY& Coord)
54 { coord = Coord; }
55
56 inline Standard_Real gp_Vec2d::Coord (const Standard_Integer Index) const
57 { return coord.Coord(Index); }
58
59 inline void gp_Vec2d::Coord(Standard_Real& Xv,
60                             Standard_Real& Yv) const
61 { coord.Coord(Xv, Yv); }
62
63 inline Standard_Real gp_Vec2d::X() const
64 { return coord.X(); }
65      
66 inline Standard_Real gp_Vec2d::Y() const
67 { return coord.Y(); }
68
69 inline  const gp_XY& gp_Vec2d::XY () const
70 { return coord; }
71
72 inline Standard_Boolean gp_Vec2d::IsNormal
73 (const gp_Vec2d& theOther, 
74  const Standard_Real theAngularTolerance) const
75 {
76   const Standard_Real anAng = Abs(M_PI_2 - Abs(Angle(theOther)));
77   return !(anAng > theAngularTolerance);
78 }    
79
80 inline Standard_Boolean gp_Vec2d::IsOpposite
81 (const gp_Vec2d& Other,
82  const Standard_Real AngularTolerance) const
83 {
84   Standard_Real Ang = Angle(Other);
85   if (Ang < 0) Ang = - Ang;
86   return M_PI - Ang <= AngularTolerance;
87 }    
88
89 inline Standard_Boolean gp_Vec2d::IsParallel
90 (const gp_Vec2d& Other,
91  const Standard_Real AngularTolerance) const
92 {
93   Standard_Real Ang = Angle(Other);
94   if (Ang < 0) Ang = - Ang;
95   return   Ang <= AngularTolerance || M_PI - Ang <= AngularTolerance;
96 }    
97
98 inline Standard_Real gp_Vec2d::Magnitude() const
99 { return coord.Modulus(); }
100
101 inline Standard_Real gp_Vec2d::SquareMagnitude() const
102 { return coord.SquareModulus(); }
103
104 inline void gp_Vec2d::Add (const gp_Vec2d& Other)
105 { coord.Add (Other.coord); }
106
107 inline gp_Vec2d gp_Vec2d::Added (const gp_Vec2d& Other) const
108 {
109   gp_Vec2d V = *this;
110   V.coord.Add (Other.coord);
111   return V;
112 }
113
114 inline Standard_Real gp_Vec2d::Crossed (const gp_Vec2d& Right) const
115 { return coord.Crossed (Right.coord); }
116
117 inline Standard_Real gp_Vec2d::CrossMagnitude (const gp_Vec2d& Right) const
118 { return coord.CrossMagnitude (Right.coord); }
119
120 inline Standard_Real gp_Vec2d::CrossSquareMagnitude
121 (const gp_Vec2d& Right) const
122 { return coord.CrossSquareMagnitude (Right.coord); }
123
124 inline void gp_Vec2d::Divide (const Standard_Real Scalar)
125 { coord.Divide (Scalar); }
126
127 inline gp_Vec2d gp_Vec2d::Divided (const Standard_Real Scalar) const
128 {
129   gp_Vec2d V = *this;
130   V.coord.Divide(Scalar);
131   return V;
132 }
133
134 inline Standard_Real gp_Vec2d::Dot (const gp_Vec2d& Other) const
135 { return coord.Dot (Other.coord); }
136
137 inline void gp_Vec2d::Multiply (const Standard_Real Scalar)
138 { coord.Multiply (Scalar); }
139
140 inline gp_Vec2d gp_Vec2d::Multiplied (const Standard_Real Scalar) const
141 {
142   gp_Vec2d V = *this;
143   V.coord.Multiply(Scalar);
144   return V;
145 }
146
147 inline void gp_Vec2d::Normalize()
148
149   Standard_Real D = coord.Modulus();
150   Standard_ConstructionError_Raise_if (D <= gp::Resolution(),
151                                        "gp_Vec2d::Normalize() - vector has zero norm");
152   coord.Divide (D);
153 }
154
155 inline gp_Vec2d gp_Vec2d::Normalized() const
156
157   Standard_Real D = coord.Modulus();
158   Standard_ConstructionError_Raise_if (D <= gp::Resolution(),
159                                        "gp_Vec2d::Normalized() - vector has zero norm");
160   gp_Vec2d V = *this;
161   V.coord.Divide (D);
162   return V; 
163 }
164
165 inline void gp_Vec2d::Reverse()
166 { coord.Reverse(); }
167
168 inline gp_Vec2d gp_Vec2d::Reversed() const
169 {
170   gp_Vec2d V = *this;
171   V.coord.Reverse();
172   return V;
173 }
174
175 inline void gp_Vec2d::Subtract (const gp_Vec2d& Right)
176 { coord.Subtract (Right.coord); }
177
178 inline gp_Vec2d gp_Vec2d::Subtracted (const gp_Vec2d& Right) const
179 {
180   gp_Vec2d V = *this;
181   V.coord.Subtract (Right.coord);
182   return V;
183 }
184
185 inline void gp_Vec2d::SetLinearForm (const Standard_Real L, 
186                                      const gp_Vec2d& Left,
187                                      const Standard_Real R,
188                                      const gp_Vec2d& Right)
189 { coord.SetLinearForm (L, Left.coord, R, Right.coord); }
190
191 inline void gp_Vec2d::SetLinearForm (const Standard_Real L, 
192                                      const gp_Vec2d& Left,
193                                      const gp_Vec2d& Right)
194 { coord.SetLinearForm (L, Left.coord, Right.coord); }
195
196 inline void gp_Vec2d::SetLinearForm (const gp_Vec2d& Left,
197                                      const gp_Vec2d& Right)
198 { coord.SetLinearForm (Left.coord,  Right.coord); }
199
200 inline void gp_Vec2d::SetLinearForm (const Standard_Real A1, 
201                                      const gp_Vec2d& V1,
202                                      const Standard_Real A2, 
203                                      const gp_Vec2d& V2, 
204                                      const gp_Vec2d& V3)
205 { coord.SetLinearForm (A1, V1.coord, A2, V2.coord, V3.coord); }
206
207 inline void gp_Vec2d::Rotate (const Standard_Real Ang)
208 {
209   gp_Trsf2d T;
210   T.SetRotation  (gp_Pnt2d (0.0, 0.0), Ang);
211   coord.Multiply (T.VectorialPart ());
212 }
213
214 inline gp_Vec2d gp_Vec2d::Rotated (const Standard_Real Ang) const
215 {
216   gp_Vec2d V = *this;
217   V.Rotate (Ang);
218   return V;
219 }
220
221 inline void gp_Vec2d::Scale (const Standard_Real S)
222 { coord.Multiply (S); }
223
224 inline gp_Vec2d gp_Vec2d::Scaled (const Standard_Real S) const
225 {
226   gp_Vec2d V = *this;
227   V.coord.Multiply (S);
228   return V;
229 }
230
231 inline gp_Vec2d gp_Vec2d::Transformed (const gp_Trsf2d& T) const
232 {
233   gp_Vec2d V = *this;
234   V.Transform(T);
235   return V;
236
237
238 inline gp_Vec2d operator* (const Standard_Real Scalar,
239                            const gp_Vec2d& V)
240 { return V.Multiplied(Scalar); }
241
242 inline gp_Vec2d gp_Vec2d::GetNormal() const
243 {
244   return gp_Vec2d(this->Y(), (-1)*this->X());
245 }
246