1 // Copyright (c) 1995-1999 Matra Datavision
2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
4 // This file is part of Open CASCADE Technology software library.
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.
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
15 // Modif JCV 07/12/90 introduction classe XYZ dans le package gp
16 // LPA et JCV 07/92 mise a jour
21 #include <gp_Trsf.hxx>
22 #include <gp_VectorWithNullMagnitude.hxx>
23 #include <Standard_ConstructionError.hxx>
25 inline gp_Vec::gp_Vec() { }
27 inline gp_Vec::gp_Vec (const gp_Dir& V) { coord = V.XYZ(); }
29 inline gp_Vec::gp_Vec (const gp_XYZ& Coord) : coord(Coord) { }
31 inline gp_Vec::gp_Vec (const Standard_Real Xv,
32 const Standard_Real Yv,
33 const Standard_Real Zv)
34 : coord (Xv, Yv, Zv) { }
36 inline gp_Vec::gp_Vec (const gp_Pnt& P1,
38 { coord = P2.XYZ().Subtracted(P1.XYZ()); }
40 inline void gp_Vec::SetCoord (const Standard_Integer Index,
41 const Standard_Real Xi)
42 { coord.SetCoord (Index, Xi); }
44 inline void gp_Vec::SetCoord (const Standard_Real Xv,
45 const Standard_Real Yv,
46 const Standard_Real Zv)
53 inline void gp_Vec::SetX (const Standard_Real X)
56 inline void gp_Vec::SetY (const Standard_Real Y)
59 inline void gp_Vec::SetZ (const Standard_Real Z)
62 inline void gp_Vec::SetXYZ (const gp_XYZ& Coord)
65 inline Standard_Real gp_Vec::Coord (const Standard_Integer Index) const
66 { return coord.Coord (Index); }
68 inline void gp_Vec::Coord(Standard_Real& Xv,
70 Standard_Real& Zv) const
77 inline Standard_Real gp_Vec::X() const
80 inline Standard_Real gp_Vec::Y() const
83 inline Standard_Real gp_Vec::Z() const
86 inline const gp_XYZ& gp_Vec::XYZ () const
89 inline Standard_Boolean gp_Vec::IsNormal
91 const Standard_Real AngularTolerance) const
93 Standard_Real Ang = M_PI / 2.0 - Angle(Other);
94 if (Ang < 0) Ang = - Ang;
95 return Ang <= AngularTolerance;
98 inline Standard_Boolean gp_Vec::IsOpposite
100 const Standard_Real AngularTolerance) const
102 Standard_Real Ang = M_PI - Angle(Other);
103 return Ang <= AngularTolerance;
106 inline Standard_Boolean gp_Vec::IsParallel
107 (const gp_Vec& Other,
108 const Standard_Real AngularTolerance) const
110 Standard_Real Ang = Angle (Other);
111 return Ang <= AngularTolerance || M_PI - Ang <= AngularTolerance;
114 inline Standard_Real gp_Vec::Angle (const gp_Vec& Other) const
117 // Au dessus de 45 degres l'arccos donne la meilleur precision pour le
118 // calcul de l'angle. Sinon il vaut mieux utiliser l'arcsin.
119 // Les erreurs commises sont loin d'etre negligeables lorsque l'on est
120 // proche de zero ou de 90 degres.
121 // En 3d les valeurs angulaires sont toujours positives et comprises entre
124 gp_VectorWithNullMagnitude_Raise_if
125 (coord.Modulus() <= gp::Resolution() ||
126 Other.coord.Modulus() <= gp::Resolution(), " ");
127 return (gp_Dir(coord)).Angle(Other);
130 inline Standard_Real gp_Vec::AngleWithRef (const gp_Vec& Other,
131 const gp_Vec& Vref) const
133 gp_VectorWithNullMagnitude_Raise_if
134 (coord.Modulus() <= gp::Resolution() ||
135 Vref.coord.Modulus () <= gp::Resolution() ||
136 Other.coord.Modulus() <= gp::Resolution(), " ");
137 return (gp_Dir(coord)).AngleWithRef(Other,Vref);
140 inline Standard_Real gp_Vec::Magnitude() const
141 { return coord.Modulus(); }
143 inline Standard_Real gp_Vec::SquareMagnitude() const
144 { return coord.SquareModulus(); }
146 inline void gp_Vec::Add (const gp_Vec& Other)
147 { coord.Add (Other.coord); }
149 inline gp_Vec gp_Vec::Added (const gp_Vec& Other) const
152 V.coord.Add (Other.coord);
156 inline void gp_Vec::Subtract (const gp_Vec& Right)
157 { coord.Subtract (Right.coord); }
159 inline gp_Vec gp_Vec::Subtracted (const gp_Vec& Right) const
162 V.coord.Subtract(Right.coord);
166 inline void gp_Vec::Multiply (const Standard_Real Scalar)
167 { coord.Multiply(Scalar); }
169 inline gp_Vec gp_Vec::Multiplied (const Standard_Real Scalar) const
172 V.coord.Multiply (Scalar);
176 inline void gp_Vec::Divide (const Standard_Real Scalar)
177 { coord.Divide (Scalar); }
179 inline gp_Vec gp_Vec::Divided (const Standard_Real Scalar) const
182 V.coord.Divide (Scalar);
186 inline void gp_Vec::Cross (const gp_Vec& Right)
187 { coord.Cross (Right.coord); }
189 inline gp_Vec gp_Vec::Crossed (const gp_Vec& Right) const
192 V.coord.Cross (Right.coord);
196 inline Standard_Real gp_Vec::CrossMagnitude
197 (const gp_Vec& Right) const
198 { return coord.CrossMagnitude (Right.coord); }
200 inline Standard_Real gp_Vec::CrossSquareMagnitude
201 (const gp_Vec& Right) const
202 { return coord.CrossSquareMagnitude (Right.coord); }
204 inline void gp_Vec::CrossCross (const gp_Vec& V1,
206 { coord.CrossCross(V1.coord, V2.coord); }
208 inline gp_Vec gp_Vec::CrossCrossed (const gp_Vec& V1,
209 const gp_Vec& V2) const
212 V.coord.CrossCross(V1.coord, V2.coord);
216 inline Standard_Real gp_Vec::Dot (const gp_Vec& Other) const
217 { return coord.Dot (Other.coord); }
219 inline Standard_Real gp_Vec::DotCross (const gp_Vec& V1,
220 const gp_Vec& V2) const
221 { return coord.DotCross (V1.coord, V2.coord); }
223 inline void gp_Vec::Normalize()
225 Standard_Real D = coord.Modulus();
226 Standard_ConstructionError_Raise_if (D <= gp::Resolution(),
227 "gp_Vec::Normalize() - vector has zero norm");
231 inline gp_Vec gp_Vec::Normalized() const
233 Standard_Real D = coord.Modulus();
234 Standard_ConstructionError_Raise_if (D <= gp::Resolution(),
235 "gp_Vec::Normalized() - vector has zero norm");
241 inline void gp_Vec::Reverse()
244 inline gp_Vec gp_Vec::Reversed () const
251 inline void gp_Vec::SetLinearForm
252 (const Standard_Real L,
254 const Standard_Real R,
256 { coord.SetLinearForm (L, Left.coord, R, Right.coord); }
258 inline void gp_Vec::SetLinearForm
259 (const Standard_Real L,
262 { coord.SetLinearForm (L, Left.coord, Right.coord); }
264 inline void gp_Vec::SetLinearForm
267 { coord.SetLinearForm (Left.coord, Right.coord); }
269 inline void gp_Vec::SetLinearForm
270 (const Standard_Real A1, const gp_Vec& V1,
271 const Standard_Real A2, const gp_Vec& V2,
272 const Standard_Real A3, const gp_Vec& V3)
273 { coord.SetLinearForm (A1, V1.coord, A2, V2.coord, A3, V3.coord); }
275 inline void gp_Vec::SetLinearForm
276 (const Standard_Real A1, const gp_Vec& V1,
277 const Standard_Real A2, const gp_Vec& V2,
279 { coord.SetLinearForm (A1, V1.coord, A2, V2.coord, V3.coord); }
281 inline void gp_Vec::SetLinearForm
282 (const Standard_Real A1, const gp_Vec& V1,
283 const Standard_Real A2, const gp_Vec& V2,
284 const Standard_Real A3, const gp_Vec& V3,
286 { coord.SetLinearForm(A1,V1.coord,A2,V2.coord,A3,V3.coord,V4.coord); }
288 inline void gp_Vec::Rotate (const gp_Ax1& A1,
289 const Standard_Real Ang)
292 T.SetRotation (A1, Ang);
293 coord.Multiply (T.VectorialPart());
296 inline gp_Vec gp_Vec::Rotated (const gp_Ax1& A1,
297 const Standard_Real Ang) const
300 Vres.Rotate (A1, Ang);
304 inline void gp_Vec::Scale (const Standard_Real S)
305 { coord.Multiply (S); }
307 inline gp_Vec gp_Vec::Scaled (const Standard_Real S) const
314 inline gp_Vec gp_Vec::Transformed (const gp_Trsf& T) const
321 inline gp_Vec operator* (const Standard_Real Scalar, const gp_Vec& V) {
322 return V.Multiplied(Scalar);