OpenCasCade数学库 - 方向（gp_Dir）

左手的ㄟ右手 2021-12-12 16:51 533阅读 0赞

gp\_Dir描述了三维空间中的一个**单位向量**。

gp\_Dir的定义。

class gp_Dir
    {
    public:
        ...
    private:
        gp_XYZ coord;
    };

默认情况下，位置为原点，方向为x轴方向。

inline gp_Dir::gp_Dir () : coord(1.,0.,0.)
    { 
    }

gp\_Dir 是一个单位向量，因此构造函数接收参数时，需要归一化。同时，零向量不能形成方向向量。

inline gp_Dir::gp_Dir (const gp_XYZ& XYZ)
    {
      Standard_Real X = XYZ.X();
      Standard_Real Y = XYZ.Y();
      Standard_Real Z = XYZ.Z();
      Standard_Real D = sqrt(X * X + Y * Y + Z * Z);
      Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir() - input vector has zero norm");
      coord.SetX(X / D);
      coord.SetY(Y / D);
      coord.SetZ(Z / D);
    }

x,y,z任一分量改变时，都需要重新归一化。如改变x分量时：

inline void gp_Dir::SetX (const Standard_Real X)
    {
      Standard_Real Y = coord.Y();
      Standard_Real Z = coord.Z();
      Standard_Real D = sqrt (X * X + Y * Y + Z * Z);
      Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir::SetX() - result vector has zero norm");
      coord.SetX(X / D);
      coord.SetY(Y / D);
      coord.SetZ(Z / D);
    }

**方向的相等判断**：夹角为0度。

inline Standard_Boolean  gp_Dir::IsEqual(const gp_Dir& Other, const Standard_Real AngularTolerance) const
    {
         return  Angle (Other) <= AngularTolerance; 
    }

**垂直判断**：方向的夹角为90度。

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

**平行判断**：方向的夹角为0度或180度。

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

**相反判断**：方向的夹角为180度。

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

**方向的夹角，**范围是\[0, 180\]**。**注意在一定的范围内，arccos提供最佳的计算精度，否则arcsin提供最佳的计算精度。

Standard_Real gp_Dir::Angle (const gp_Dir& Other) const
    {
      Standard_Real Cosinus = coord.Dot (Other.coord);
      if (Cosinus > -0.70710678118655 && Cosinus < 0.70710678118655)
        return acos (Cosinus);
      else {
        Standard_Real Sinus = (coord.Crossed (Other.coord)).Modulus ();
        if(Cosinus < 0.0)  
            return M_PI - asin (Sinus);
        else               
            return asin (Sinus);
      }
    }

**方向的夹角，**范围是\[-180, 180\]。注意Vref定义了正方向，当两个方向的叉积与Vref的方向相同时，角度为正，否则角度为负。

Standard_Real gp_Dir::AngleWithRef (const gp_Dir& Other,const gp_Dir& Vref) const
    {
      Standard_Real Ang;
      gp_XYZ XYZ = coord.Crossed (Other.coord);
      Standard_Real Cosinus = coord.Dot(Other.coord);
      Standard_Real Sinus   = XYZ.Modulus ();
      if (Cosinus > -0.70710678118655 && Cosinus < 0.70710678118655)
        Ang =  acos (Cosinus);
      else {
        if(Cosinus < 0.0)  
            Ang = M_PI - asin (Sinus);
        else               
            Ang = asin (Sinus);
      }
      if (XYZ.Dot (Vref.coord) >= 0.0) 
        return  Ang;
      else                              
        return -Ang;
    }

**方向的叉积**。返回值是单位向量，注意当两个方向平行时，无法计算叉积。

inline void gp_Dir::Cross (const gp_Dir& Right)
    { 
      coord.Cross (Right.coord); 
      Standard_Real D = coord.Modulus ();
      Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir::Cross() - result vector has zero norm");
      coord.Divide (D);
    }

**方向的镜像**。对方向做对称变换，V是对称变换的中心。

void gp_Dir::Mirror (const gp_Dir& V)
    {
      const gp_XYZ& XYZ = V.coord;
      Standard_Real A = XYZ.X();
      Standard_Real B = XYZ.Y();
      Standard_Real C = XYZ.Z();
      Standard_Real X = coord.X();
      Standard_Real Y = coord.Y();
      Standard_Real Z = coord.Z();
      Standard_Real M1 = 2.0 * A * B;
      Standard_Real M2 = 2.0 * A * C;
      Standard_Real M3 = 2.0 * B * C;
      Standard_Real XX = ((2.0 * A * A) - 1.0) * X + M1 * Y + M2 * Z;
      Standard_Real YY = M1 * X + ((2.0 * B * B) - 1.0) * Y + M3 * Z;
      Standard_Real ZZ = M2 * X + M3 * Y + ((2.0 * C * C) - 1.0) * Z;
      coord.SetCoord(XX,YY,ZZ);
    }

参数是gp\_Ax2坐标系统时，镜像后需要取反。

void gp_Dir::Mirror (const gp_Ax2& A2)
    {
      const gp_Dir& Vz = A2.Direction();
      Mirror(Vz);
      Reverse();
    }

**方向的旋转**，A1是旋转轴，Ang是旋转角度。

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

**  方向的变换。**

void gp_Dir::Transform (const gp_Trsf& T)
    {
      if (T.Form() == gp_Identity ||  T.Form() == gp_Translation) 
      {     
      }
      else if (T.Form() == gp_PntMirror)   //中心对称
      { 
          coord.Reverse(); 
      }
      else if (T.Form() == gp_Scale)    //缩放
      { 
        if (T.ScaleFactor() < 0.0)
        { 
            coord.Reverse(); 
        }
      }
      else
      {
        coord.Multiply (T.HVectorialPart());
        Standard_Real D = coord.Modulus();
        coord.Divide(D);
        if (T.ScaleFactor() < 0.0) 
        { 
            coord.Reverse(); 
        }
      } 
    }