// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2012 OPEN CASCADE SAS
//
// The content of this file is subject to the Open CASCADE Technology Public
// License Version 6.5 (the "License"). You may not use the content of this file
// except in compliance with the License. Please obtain a copy of the License
// at http://www.opencascade.org and read it completely before using this file.
//
// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
//
// The Original Code and all software distributed under the License is
// distributed on an "AS IS" basis, without warranty of any kind, and the
// Initial Developer hereby disclaims all such warranties, including without
// limitation, any warranties of merchantability, fitness for a particular
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.

// Modif JCV 07/12/90 introduction classe XYZ dans le package gp
// LPA et JCV 07/92 mise a jour

#include <gp.hxx>
#include <gp_Dir.hxx>
#include <gp_Pnt.hxx>
#include <gp_Trsf.hxx>
#include <gp_VectorWithNullMagnitude.hxx>
#include <Standard_ConstructionError.hxx>

inline gp_Vec::gp_Vec() { }

inline gp_Vec::gp_Vec (const gp_Dir& V) { coord = V.XYZ(); }

inline gp_Vec::gp_Vec (const gp_XYZ& Coord) : coord(Coord) { }

inline gp_Vec::gp_Vec (const Standard_Real Xv,
		       const Standard_Real Yv,
		       const Standard_Real Zv)
               : coord (Xv, Yv, Zv)   { }

inline gp_Vec::gp_Vec (const gp_Pnt& P1,
		       const gp_Pnt& P2)
{ coord = P2.XYZ().Subtracted(P1.XYZ()); }

inline void gp_Vec::SetCoord (const Standard_Integer Index,
			      const Standard_Real Xi)
{ coord.SetCoord (Index, Xi); }

inline void gp_Vec::SetCoord (const Standard_Real Xv,
			      const Standard_Real Yv,
			      const Standard_Real Zv)
{
  coord.SetX(Xv);
  coord.SetY(Yv);
  coord.SetZ(Zv);
}

inline void gp_Vec::SetX (const Standard_Real X)
{ coord.SetX (X); }

inline void gp_Vec::SetY (const Standard_Real Y)
{ coord.SetY (Y); }

inline void gp_Vec::SetZ (const Standard_Real Z)
{ coord.SetZ (Z); }

inline void gp_Vec::SetXYZ (const gp_XYZ& Coord)
{ coord = Coord; }

inline Standard_Real gp_Vec::Coord (const Standard_Integer Index) const
{ return coord.Coord (Index); }

inline void gp_Vec::Coord(Standard_Real& Xv, 
			  Standard_Real& Yv,
			  Standard_Real& Zv) const
{
  Xv = coord.X();
  Yv = coord.Y();
  Zv = coord.Z();
}

inline Standard_Real gp_Vec::X() const
{ return coord.X(); }
     
inline Standard_Real gp_Vec::Y() const
{ return coord.Y(); }

inline Standard_Real gp_Vec::Z() const
{ return coord.Z(); }
     
inline const gp_XYZ& gp_Vec::XYZ () const
{ return coord; }

inline Standard_Boolean gp_Vec::IsNormal
(const gp_Vec& Other,
 const Standard_Real AngularTolerance) const
{
  Standard_Real Ang = M_PI / 2.0 - Angle(Other);
  if (Ang < 0) Ang = - Ang;
  return  Ang <= AngularTolerance;
}    

inline Standard_Boolean gp_Vec::IsOpposite
(const gp_Vec& Other,
 const Standard_Real AngularTolerance) const
{
  Standard_Real Ang = M_PI - Angle(Other);
  return Ang <= AngularTolerance;
}    

inline Standard_Boolean gp_Vec::IsParallel
(const gp_Vec& Other,
 const Standard_Real AngularTolerance) const
{
  Standard_Real Ang = Angle (Other);
  return   Ang <= AngularTolerance || M_PI - Ang <= AngularTolerance;
}    

inline Standard_Real gp_Vec::Angle (const gp_Vec& Other) const
{
  //    Commentaires :
  //    Au dessus de 45 degres l'arccos donne la meilleur precision pour le
  //    calcul de l'angle. Sinon il vaut mieux utiliser l'arcsin.
  //    Les erreurs commises sont loin d'etre negligeables lorsque l'on est
  //    proche de zero ou de 90 degres.
  //    En 3d les valeurs angulaires sont toujours positives et comprises entre
  //    0 et Pi.
  
  gp_VectorWithNullMagnitude_Raise_if
    (coord.Modulus()       <= gp::Resolution() ||
     Other.coord.Modulus() <= gp::Resolution(), " ");
  return (gp_Dir(coord)).Angle(Other);
}

inline Standard_Real gp_Vec::AngleWithRef (const gp_Vec& Other,
					   const gp_Vec& Vref) const
{
  gp_VectorWithNullMagnitude_Raise_if
    (coord.Modulus()       <= gp::Resolution() ||
     Vref.coord.Modulus () <= gp::Resolution() ||
     Other.coord.Modulus() <= gp::Resolution(), " ");
  return (gp_Dir(coord)).AngleWithRef(Other,Vref);
} 

inline Standard_Real gp_Vec::Magnitude() const
{ return coord.Modulus(); }

inline Standard_Real gp_Vec::SquareMagnitude() const
{ return coord.SquareModulus(); }

inline void gp_Vec::Add (const gp_Vec& Other)
{ coord.Add (Other.coord); }

inline gp_Vec gp_Vec::Added (const gp_Vec& Other) const
{
  gp_Vec V = *this;
  V.coord.Add (Other.coord);
  return V;
}

inline void gp_Vec::Subtract (const gp_Vec& Right)
{ coord.Subtract (Right.coord); }

inline gp_Vec gp_Vec::Subtracted (const gp_Vec& Right) const
{
  gp_Vec V = *this;
   V.coord.Subtract(Right.coord);
   return V;
}

inline void gp_Vec::Multiply (const Standard_Real Scalar)
{ coord.Multiply(Scalar); }

inline gp_Vec gp_Vec::Multiplied (const Standard_Real Scalar) const
{
  gp_Vec V = *this;
  V.coord.Multiply (Scalar);
  return V;
}

inline void gp_Vec::Divide (const Standard_Real Scalar)
{ coord.Divide (Scalar); }

inline gp_Vec gp_Vec::Divided (const Standard_Real Scalar) const
{
  gp_Vec V = *this;
  V.coord.Divide (Scalar);
  return V;
}

inline void gp_Vec::Cross (const gp_Vec& Right)
{ coord.Cross (Right.coord); }

inline gp_Vec gp_Vec::Crossed (const gp_Vec& Right) const
{
  gp_Vec V = *this;
  V.coord.Cross (Right.coord);
  return V;
}

inline Standard_Real gp_Vec::CrossMagnitude
(const gp_Vec& Right) const
{ return coord.CrossMagnitude (Right.coord); }

inline Standard_Real gp_Vec::CrossSquareMagnitude
(const gp_Vec& Right) const
{ return coord.CrossSquareMagnitude (Right.coord); }

inline void gp_Vec::CrossCross (const gp_Vec& V1,
				const gp_Vec& V2)
{ coord.CrossCross(V1.coord, V2.coord); }

inline gp_Vec gp_Vec::CrossCrossed (const gp_Vec& V1,
				    const gp_Vec& V2) const
{
  gp_Vec V = *this;
  V.coord.CrossCross(V1.coord, V2.coord);
  return V;
}

inline Standard_Real gp_Vec::Dot (const gp_Vec& Other) const
{ return coord.Dot (Other.coord); }

inline Standard_Real gp_Vec::DotCross (const gp_Vec& V1,
				       const gp_Vec& V2)  const
{ return coord.DotCross (V1.coord, V2.coord); } 

inline void gp_Vec::Normalize()
{ 
  Standard_Real D = coord.Modulus();
  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "");
  coord.Divide (D);
}

inline gp_Vec gp_Vec::Normalized() const
{ 
  Standard_Real D = coord.Modulus();
  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "");
  gp_Vec V = *this;
  V.coord.Divide (D);
  return V; 
}

inline void gp_Vec::Reverse()
{ coord.Reverse(); }

inline gp_Vec gp_Vec::Reversed () const
{
  gp_Vec V = *this;
  V.coord.Reverse();
  return V;
}

inline void gp_Vec::SetLinearForm
(const Standard_Real L,
 const gp_Vec& Left,
 const Standard_Real R,
 const gp_Vec& Right)
{ coord.SetLinearForm (L, Left.coord, R, Right.coord); }

inline void gp_Vec::SetLinearForm
(const Standard_Real L,
 const gp_Vec& Left,
 const gp_Vec& Right)
{ coord.SetLinearForm (L, Left.coord, Right.coord); }

inline void gp_Vec::SetLinearForm
(const gp_Vec& Left,
 const gp_Vec& Right)
{ coord.SetLinearForm (Left.coord,  Right.coord); }

inline void gp_Vec::SetLinearForm
(const Standard_Real A1, const gp_Vec& V1, 
 const Standard_Real A2, const gp_Vec& V2,
 const Standard_Real A3, const gp_Vec& V3)
{ coord.SetLinearForm (A1, V1.coord, A2, V2.coord, A3, V3.coord); }

inline void gp_Vec::SetLinearForm
(const Standard_Real A1, const gp_Vec& V1, 
 const Standard_Real A2, const gp_Vec& V2, 
 const gp_Vec& V3)
{ coord.SetLinearForm (A1, V1.coord, A2, V2.coord, V3.coord); }

inline void gp_Vec::SetLinearForm
(const Standard_Real A1, const gp_Vec& V1,
 const Standard_Real A2, const gp_Vec& V2,
 const Standard_Real A3, const gp_Vec& V3,
 const gp_Vec& V4)
{ coord.SetLinearForm(A1,V1.coord,A2,V2.coord,A3,V3.coord,V4.coord); }

inline void gp_Vec::Rotate (const gp_Ax1& A1,
			    const Standard_Real Ang)
{
  gp_Trsf T;
  T.SetRotation (A1, Ang);
  coord.Multiply (T.VectorialPart());
}

inline gp_Vec gp_Vec::Rotated (const gp_Ax1& A1,
			       const Standard_Real Ang) const
{
  gp_Vec Vres = *this;
  Vres.Rotate (A1, Ang);
  return Vres;                     
}

inline void gp_Vec::Scale (const Standard_Real S)
{ coord.Multiply (S); }

inline gp_Vec gp_Vec::Scaled (const Standard_Real S) const
{
  gp_Vec V = *this;
  V.coord.Multiply(S);
  return V;
}

inline gp_Vec gp_Vec::Transformed (const gp_Trsf& T) const
{
  gp_Vec V = *this;
  V.Transform(T);
  return V;
} 

inline gp_Vec operator* (const Standard_Real Scalar, const gp_Vec& V) {
 return V.Multiplied(Scalar);
}