1 // Copyright (c) 1995-1999 Matra Datavision
2 // Copyright (c) 1999-2012 OPEN CASCADE SAS
4 // The content of this file is subject to the Open CASCADE Technology Public
5 // License Version 6.5 (the "License"). You may not use the content of this file
6 // except in compliance with the License. Please obtain a copy of the License
7 // at http://www.opencascade.org and read it completely before using this file.
9 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
10 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
12 // The Original Code and all software distributed under the License is
13 // distributed on an "AS IS" basis, without warranty of any kind, and the
14 // Initial Developer hereby disclaims all such warranties, including without
15 // limitation, any warranties of merchantability, fitness for a particular
16 // purpose or non-infringement. Please see the License for the specific terms
17 // and conditions governing the rights and limitations under the License.
19 // Modif JCV 07/12/90 introduction classe XYZ dans le package gp
20 // LPA et JCV 07/92 mise a jour
25 #include <gp_Trsf.hxx>
26 #include <gp_VectorWithNullMagnitude.hxx>
27 #include <Standard_ConstructionError.hxx>
29 inline gp_Vec::gp_Vec() { }
31 inline gp_Vec::gp_Vec (const gp_Dir& V) { coord = V.XYZ(); }
33 inline gp_Vec::gp_Vec (const gp_XYZ& Coord) : coord(Coord) { }
35 inline gp_Vec::gp_Vec (const Standard_Real Xv,
36 const Standard_Real Yv,
37 const Standard_Real Zv)
38 : coord (Xv, Yv, Zv) { }
40 inline gp_Vec::gp_Vec (const gp_Pnt& P1,
42 { coord = P2.XYZ().Subtracted(P1.XYZ()); }
44 inline void gp_Vec::SetCoord (const Standard_Integer Index,
45 const Standard_Real Xi)
46 { coord.SetCoord (Index, Xi); }
48 inline void gp_Vec::SetCoord (const Standard_Real Xv,
49 const Standard_Real Yv,
50 const Standard_Real Zv)
57 inline void gp_Vec::SetX (const Standard_Real X)
60 inline void gp_Vec::SetY (const Standard_Real Y)
63 inline void gp_Vec::SetZ (const Standard_Real Z)
66 inline void gp_Vec::SetXYZ (const gp_XYZ& Coord)
69 inline Standard_Real gp_Vec::Coord (const Standard_Integer Index) const
70 { return coord.Coord (Index); }
72 inline void gp_Vec::Coord(Standard_Real& Xv,
74 Standard_Real& Zv) const
81 inline Standard_Real gp_Vec::X() const
84 inline Standard_Real gp_Vec::Y() const
87 inline Standard_Real gp_Vec::Z() const
90 inline const gp_XYZ& gp_Vec::XYZ () const
93 inline Standard_Boolean gp_Vec::IsNormal
95 const Standard_Real AngularTolerance) const
97 Standard_Real Ang = M_PI / 2.0 - Angle(Other);
98 if (Ang < 0) Ang = - Ang;
99 return Ang <= AngularTolerance;
102 inline Standard_Boolean gp_Vec::IsOpposite
103 (const gp_Vec& Other,
104 const Standard_Real AngularTolerance) const
106 Standard_Real Ang = M_PI - Angle(Other);
107 return Ang <= AngularTolerance;
110 inline Standard_Boolean gp_Vec::IsParallel
111 (const gp_Vec& Other,
112 const Standard_Real AngularTolerance) const
114 Standard_Real Ang = Angle (Other);
115 return Ang <= AngularTolerance || M_PI - Ang <= AngularTolerance;
118 inline Standard_Real gp_Vec::Angle (const gp_Vec& Other) const
121 // Au dessus de 45 degres l'arccos donne la meilleur precision pour le
122 // calcul de l'angle. Sinon il vaut mieux utiliser l'arcsin.
123 // Les erreurs commises sont loin d'etre negligeables lorsque l'on est
124 // proche de zero ou de 90 degres.
125 // En 3d les valeurs angulaires sont toujours positives et comprises entre
128 gp_VectorWithNullMagnitude_Raise_if
129 (coord.Modulus() <= gp::Resolution() ||
130 Other.coord.Modulus() <= gp::Resolution(), " ");
131 return (gp_Dir(coord)).Angle(Other);
134 inline Standard_Real gp_Vec::AngleWithRef (const gp_Vec& Other,
135 const gp_Vec& Vref) const
137 gp_VectorWithNullMagnitude_Raise_if
138 (coord.Modulus() <= gp::Resolution() ||
139 Vref.coord.Modulus () <= gp::Resolution() ||
140 Other.coord.Modulus() <= gp::Resolution(), " ");
141 return (gp_Dir(coord)).AngleWithRef(Other,Vref);
144 inline Standard_Real gp_Vec::Magnitude() const
145 { return coord.Modulus(); }
147 inline Standard_Real gp_Vec::SquareMagnitude() const
148 { return coord.SquareModulus(); }
150 inline void gp_Vec::Add (const gp_Vec& Other)
151 { coord.Add (Other.coord); }
153 inline gp_Vec gp_Vec::Added (const gp_Vec& Other) const
156 V.coord.Add (Other.coord);
160 inline void gp_Vec::Subtract (const gp_Vec& Right)
161 { coord.Subtract (Right.coord); }
163 inline gp_Vec gp_Vec::Subtracted (const gp_Vec& Right) const
166 V.coord.Subtract(Right.coord);
170 inline void gp_Vec::Multiply (const Standard_Real Scalar)
171 { coord.Multiply(Scalar); }
173 inline gp_Vec gp_Vec::Multiplied (const Standard_Real Scalar) const
176 V.coord.Multiply (Scalar);
180 inline void gp_Vec::Divide (const Standard_Real Scalar)
181 { coord.Divide (Scalar); }
183 inline gp_Vec gp_Vec::Divided (const Standard_Real Scalar) const
186 V.coord.Divide (Scalar);
190 inline void gp_Vec::Cross (const gp_Vec& Right)
191 { coord.Cross (Right.coord); }
193 inline gp_Vec gp_Vec::Crossed (const gp_Vec& Right) const
196 V.coord.Cross (Right.coord);
200 inline Standard_Real gp_Vec::CrossMagnitude
201 (const gp_Vec& Right) const
202 { return coord.CrossMagnitude (Right.coord); }
204 inline Standard_Real gp_Vec::CrossSquareMagnitude
205 (const gp_Vec& Right) const
206 { return coord.CrossSquareMagnitude (Right.coord); }
208 inline void gp_Vec::CrossCross (const gp_Vec& V1,
210 { coord.CrossCross(V1.coord, V2.coord); }
212 inline gp_Vec gp_Vec::CrossCrossed (const gp_Vec& V1,
213 const gp_Vec& V2) const
216 V.coord.CrossCross(V1.coord, V2.coord);
220 inline Standard_Real gp_Vec::Dot (const gp_Vec& Other) const
221 { return coord.Dot (Other.coord); }
223 inline Standard_Real gp_Vec::DotCross (const gp_Vec& V1,
224 const gp_Vec& V2) const
225 { return coord.DotCross (V1.coord, V2.coord); }
227 inline void gp_Vec::Normalize()
229 Standard_Real D = coord.Modulus();
230 Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "");
234 inline gp_Vec gp_Vec::Normalized() const
236 Standard_Real D = coord.Modulus();
237 Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "");
243 inline void gp_Vec::Reverse()
246 inline gp_Vec gp_Vec::Reversed () const
253 inline void gp_Vec::SetLinearForm
254 (const Standard_Real L,
256 const Standard_Real R,
258 { coord.SetLinearForm (L, Left.coord, R, Right.coord); }
260 inline void gp_Vec::SetLinearForm
261 (const Standard_Real L,
264 { coord.SetLinearForm (L, Left.coord, Right.coord); }
266 inline void gp_Vec::SetLinearForm
269 { coord.SetLinearForm (Left.coord, Right.coord); }
271 inline void gp_Vec::SetLinearForm
272 (const Standard_Real A1, const gp_Vec& V1,
273 const Standard_Real A2, const gp_Vec& V2,
274 const Standard_Real A3, const gp_Vec& V3)
275 { coord.SetLinearForm (A1, V1.coord, A2, V2.coord, A3, V3.coord); }
277 inline void gp_Vec::SetLinearForm
278 (const Standard_Real A1, const gp_Vec& V1,
279 const Standard_Real A2, const gp_Vec& V2,
281 { coord.SetLinearForm (A1, V1.coord, A2, V2.coord, V3.coord); }
283 inline void gp_Vec::SetLinearForm
284 (const Standard_Real A1, const gp_Vec& V1,
285 const Standard_Real A2, const gp_Vec& V2,
286 const Standard_Real A3, const gp_Vec& V3,
288 { coord.SetLinearForm(A1,V1.coord,A2,V2.coord,A3,V3.coord,V4.coord); }
290 inline void gp_Vec::Rotate (const gp_Ax1& A1,
291 const Standard_Real Ang)
294 T.SetRotation (A1, Ang);
295 coord.Multiply (T.VectorialPart());
298 inline gp_Vec gp_Vec::Rotated (const gp_Ax1& A1,
299 const Standard_Real Ang) const
302 Vres.Rotate (A1, Ang);
306 inline void gp_Vec::Scale (const Standard_Real S)
307 { coord.Multiply (S); }
309 inline gp_Vec gp_Vec::Scaled (const Standard_Real S) const
316 inline gp_Vec gp_Vec::Transformed (const gp_Trsf& T) const
323 inline gp_Vec operator* (const Standard_Real Scalar, const gp_Vec& V) {
324 return V.Multiplied(Scalar);