troidal.cpp

曲面加工程序源码,用C＋＋编写的加工曲线曲面的程序

#if !defined(__troidal_cpp)
#define __troidal_cpp

//Difinition of troidal class

#include <math.h>
#pragma hdrstop

#include "troidal.h"

////Construcor and destructor
troidal::troidal(){
	SurfaceLargeRadius = 1000.0;
        SurfaceSmallRadius = 100.0;
	LargeRadius = SurfaceLargeRadius-SurfaceSmallRadius;
        SmallRadius = SurfaceSmallRadius;
        isConcave = true;

        isHorizontal=true ;
};
troidal::troidal( double lr,double sr){
	LargeRadius = lr;
        SmallRadius = sr;
        isConcave = true;

        isHorizontal=true ;
};

troidal::~troidal(){
};

////accessor
/*void troidal::SetParameters(){

	p = InputParameter("Focal Distance[mm]",500,0.01,1000);
	face::SetFaceParameters();
};
//980519
*/

inline void troidal::SetLargeRadius(double r ){ LargeRadius=r; };

inline double troidal::GetLargeRadius() {return(LargeRadius);};

inline void troidal::SetSmallRadius(double r ){SmallRadius=r; };

inline double troidal::GetSmallRadius() {return(SmallRadius);};

inline double troidal::GetZ( double x, double y){

    if (!isHorizontal) {

       double temp=x;
       x=y;
       y=temp;
    };

    double t;
    double R = LargeRadius;
    double r = SmallRadius;

    double a = sqrt(r*r-y*y);
    double b = sqrt((a+R)*(a+R)-x*x);

    if (isConcave==true){
       t = r+R-b;
    }else{
       t = -(r+R-b);
    };
    return t;
    //z=0 ,when x=y=0.

};

inline vector troidal::GetPosition( double x, double y){
	return ( vector( x, y, GetZ(x,y) ) );
};

inline double troidal::gradX(double x, double y){

    if (!isHorizontal) {

       double temp=x;
       x=y;
       y=temp;
    };

    double t;
    double R = LargeRadius;
    double r = SmallRadius;

    double a = sqrt(r*r-y*y);
    double b = sqrt((a+R)*(a+R)-x*x);

    if (isConcave==true){
       t = x/b;
    }else{
       t = -x/b;
    };
    return t;

};

inline double troidal::gradY(double x, double y){

    if (!isHorizontal) {

       double temp=x;
       x=y;
       y=temp;
    };
    double t;
    double R = LargeRadius;
    double r = SmallRadius;

    double a = sqrt(r*r-y*y);
    double b = sqrt((a+R)*(a+R)-x*x);

    if (isConcave==true){
       t = y*(R+a)/a/b;
    }else{
       t = -y*(R+a)/a/b;
    };
    return t;

};

inline double troidal::gradXX(double x, double y){

    if (!isHorizontal) {

       double temp=x;
       x=y;
       y=temp;
    };
    double t;
    double R = LargeRadius;
    double r = SmallRadius;

    double a = sqrt(r*r-y*y);
    double b = sqrt((a+R)*(a+R)-x*x);

    if (isConcave==true){
       t = (R+a)*(R+a)/b/b/b;
    }else{
       t = -(R+a)*(R+a)/b/b/b;
    };
    return t;
};

inline double troidal::gradYY(double x, double y){

    if (!isHorizontal) {

       double temp=x;
       x=y;
       y=temp;
    };
    double t;
    double R = LargeRadius;
    double r = SmallRadius;

    double a = sqrt(r*r-y*y);
    double b = sqrt((a+R)*(a+R)-x*x);

    if (isConcave==true){
       t = (x*x*y*y*a + r*r*r*r*(3*R+a) -r*r*(-R*R*R -3*R*R*a +a*(x*x+y*y) +R*(x*x+3*y*y)))/a/a/a/b/b/b;
    }else{
       t = -(x*x*y*y*a + r*r*r*r*(3*R+a) -r*r*(-R*R*R -3*R*R*a +a*(x*x+y*y) +R*(x*x+3*y*y)))/a/a/a/b/b/b;
    };
    return t;
};

// This is the normal vector of surface on the point(x,y).
// This is toward the inside of troidal.
// This.length is 1.
vector troidal::NormalVector ( double x, double y){
	return ( vector( -gradX(x,y), -gradY(x,y), 1).normalize() );  //OK 980520
};
vector troidal::NormalVector ( vector position){
	return ( NormalVector( position.getX(), position.getY() ) );
};

////GradientVector////////////////////////////////////////////
// This is one of tangential vactors on the tangential plane.
// This is toward direction which has the largest gradient.
// This length is 1.
vector troidal::GradientVector(double x, double y){
	double gx = gradX( x,y);
	double gy = gradY( x,y);

	return ( vector( gx, gy, gx*gx+gy*gy ).normalize() );
};
vector troidal::GradientVector( vector position){
	return( GradientVector( position.getX(), position.getY() ) );
};

////NoGradientVector///////////////////////////////////////////
// This is one of tangential vactors on the tangential plane.
// This is toward direction which has no gradient.
//// This length will be 1,
//// and this Z-coordinate will be Zero.
vector troidal::NoGradientVector(double x,double y){
	return( NormalVector(x,y)%GradientVector(x,y) );
};
vector troidal::NoGradientVector(vector position){
	return( NormalVector(position)%GradientVector(position) );
};


int troidal::WriteFaceName(ofstream& fout){

	fout << "(Face name is : troidal);" << endl;
	return(1);
};
int troidal::WriteParameters(ofstream& fout){

        if (isConcave==true){
           fout << "(Concave);" << endl;
        }else{
           fout << "(Convex);" << endl;
        };

        if (isHorizontal==true) {
           fout << "(Horizontal);" << endl;
        }else{
           fout << "(not Horizontal);" << endl;
        };

	fout << "(,which Large Radius[mm] is :" << LargeRadius <<");" << endl;
	fout << "(,which Small Radius[mm] is :" << SmallRadius <<");" << endl;
	fout << "(,which Surface Large Radius[mm] is :" << SurfaceLargeRadius <<");" << endl;
	fout << "(,which Surface Small Radius[mm] is :" << SurfaceSmallRadius <<");" << endl;

	return(1);
};

/*
void troidal::SetParameters(){

	p = InputParameter("Focal Distance[mm]",500,0.01,1000);
	face::SetFaceParameters();
};
void SetParameter(TStringList str);
void GetParameter(TStringList &str);

*/

void troidal::SetParameter(TStringList *str)
{
   SurfaceLargeRadius=-1.;
   SurfaceSmallRadius=-1.;

   for (int i=0; i<str->Count; i++){

         AnsiString temp;

         temp = "LargeRadius";
         if (str->Names[i]==temp){
              LargeRadius = str->Values[str->Names[i]].ToDouble();
         };
         temp = "SmallRadius";
         if (str->Names[i]==temp){
              SmallRadius = str->Values[str->Names[i]].ToDouble();
         };

         temp = "SurfaceLargeRadius";
         if (str->Names[i]==temp){
              SurfaceLargeRadius = str->Values[str->Names[i]].ToDouble();
         };
         temp = "SurfaceSmallRadius";
         if (str->Names[i]==temp){
              SurfaceSmallRadius = str->Values[str->Names[i]].ToDouble();
         };

         temp = "isConcave";
         if (str->Names[i]==temp){
              isConcave = str->Values[str->Names[i]].ToInt();
         };

         temp = "isHorizontal";
         if (str->Names[i]==temp){
              isHorizontal = str->Values[str->Names[i]].ToInt();
         };

   };

   if ((SurfaceLargeRadius>0)&&(SurfaceSmallRadius>0)){

      LargeRadius = SurfaceLargeRadius-SurfaceSmallRadius;
      SmallRadius = SurfaceSmallRadius;

   }else{

      SurfaceLargeRadius = LargeRadius+SmallRadius;
      SurfaceSmallRadius = SmallRadius;
   };

   face::SetFaceParameter(str);
};

void troidal::GetParameter(TStringList *str)
{

   str->Add(AnsiString("---troidal parameter(s)---"));
   str->Add(AnsiString("FaceType=troidal"));

   str->Add(AnsiString("SurfaceLargeRadius=")+ SurfaceLargeRadius);
   str->Add(AnsiString("SurfaceSmallRadius=")+ SurfaceSmallRadius);

   str->Add(AnsiString("//LargeRadius=")+ LargeRadius);
   str->Add(AnsiString("//SmallRadius=")+ SmallRadius);

   str->Add(AnsiString("isConcave=")+ AnsiString((int)isConcave) );

   if(isConcave==true){
       str->Add(AnsiString("//Concave"));
   }else{
       str->Add(AnsiString("//Convex"));
   };

   str->Add(AnsiString("isHorizontal=")+ AnsiString((int)isHorizontal) );

   if(isHorizontal==true){
       str->Add(AnsiString("//Horizontal"));
   }else{
       str->Add(AnsiString("//not Horizontal"));
   };

   face::GetFaceParameter(str);
};

#endif