src/gp/gp_Vec2d.lxx

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