cadbase.cpp

这是一个程序的一般架构方法

{
//## begin CVector3D::CVector3D%58222562FEED.body preserve=yes
	dx=0.0;
	dy=0.0;
	dz=0.0;
//## end CVector3D::CVector3D%58222562FEED.body
}
//-- {AddDecl: 584} region.unprotectedFunction [6724..6811]

CVector3D::CVector3D(double ix,double iy,double iz)
{
//## begin CVector3D::CVector3D%F8C0C3E1FEED.body preserve=yes
	dx=ix;
	dy=iy;
	dz=iz;
//## end CVector3D::CVector3D%F8C0C3E1FEED.body
}
//-- {AddDecl: 585} region.unprotectedFunction [6812..6895]

CVector3D::CVector3D(const double* pv)
{
//## begin CVector3D::CVector3D%F9C489A8FEED.body preserve=yes
	dx=pv[0];
	dy=pv[1];
	dz=pv[2];
//## end CVector3D::CVector3D%F9C489A8FEED.body
}
//-- {AddDecl: 586} region.unprotectedFunction [6896..6971]

CVector3D::CVector3D(VECTOR3D v)
{
//## begin CVector3D::CVector3D%6BC77254FEED.body preserve=yes
	
	dx=v.dx;
	dy=v.dy;
	dz=v.dz;
//## end CVector3D::CVector3D%6BC77254FEED.body
}
//-- {AddDecl: 587} region.unprotectedFunction [6972..7004]

CVector3D::~CVector3D()
{
//## begin CVector3D::~CVector3D%A865531CFEED.body preserve=yes
//## end CVector3D::~CVector3D%A865531CFEED.body
}
//-- {AddDecl: 588} region.unprotectedFunction [7005..7107]

CVector3D CVector3D::operator+(VECTOR3D v) const
{
//## begin CVector3D::operator +%83D4E4C1FEED.body preserve=yes
	return CVector3D(dx+v.dx,dy+v.dy,dz+v.dz);
//## end CVector3D::operator +%83D4E4C1FEED.body
}
//-- {AddDecl: 589} region.unprotectedFunction [7108..7210]

CVector3D CVector3D::operator-(VECTOR3D v) const
{
//## begin CVector3D::operator -%D8B7BDF6FEED.body preserve=yes
	return CVector3D(dx-v.dx,dy-v.dy,dz-v.dz);
//## end CVector3D::operator -%D8B7BDF6FEED.body
}
//-- {AddDecl: 590} region.unprotectedFunction [7211..7300]

void CVector3D::operator+=(VECTOR3D v)
{
//## begin CVector3D::operator +=%A82A920AFEED.body preserve=yes
	dx += v.dx;
	dy += v.dy;
	dz += v.dz;
//## end CVector3D::operator +=%A82A920AFEED.body
}
//-- {AddDecl: 591} region.unprotectedFunction [7301..7390]

void CVector3D::operator-=(VECTOR3D v)
{
//## begin CVector3D::operator -=%EA6123BEFEED.body preserve=yes
	dx -= v.dx;
	dy -= v.dy;
	dz -= v.dz;
//## end CVector3D::operator -=%EA6123BEFEED.body
}
//-- {AddDecl: 592} region.unprotectedFunction [7391..7482]

CVector3D CVector3D::operator*(double d) const
{
//## begin CVector3D::operator *%C8D055D2FEED.body preserve=yes
	return CVector3D(dx*d,dy*d,dz*d);
//## end CVector3D::operator *%C8D055D2FEED.body
}
//-- {AddDecl: 593} region.unprotectedFunction [7483..7561]

void CVector3D::operator*=(double d)
{
//## begin CVector3D::operator *=%09BF75ACFEED.body preserve=yes
	dx *= d;
	dy *= d;
	dz *= d;
//## end CVector3D::operator *=%09BF75ACFEED.body
}
//-- {AddDecl: 594} region.unprotectedFunction [7562..7653]

CVector3D CVector3D::operator/(double d) const
{
//## begin CVector3D::operator /%337B5EBBFEED.body preserve=yes
	return CVector3D(dx/d,dy/d,dz/d);
//## end CVector3D::operator /%337B5EBBFEED.body
}
//-- {AddDecl: 595} region.unprotectedFunction [7654..7733]
	
void CVector3D::operator/=(double d)
{
//## begin CVector3D::operator /=%A81B2F0AFEED.body preserve=yes
	dx /= d;
	dy /= d;
	dz /= d;
//## end CVector3D::operator /=%A81B2F0AFEED.body
}
//-- {AddDecl: 596} region.unprotectedFunction [7734..7878]

// cross product
CVector3D CVector3D::operator*(VECTOR3D v) const
{
//## begin CVector3D::operator *%CFB4BF99FEED.body preserve=yes
	return CVector3D(dy*v.dz-v.dy*dz,v.dx*dz-dx*v.dz,dx*v.dy-v.dx*dy);
//## end CVector3D::operator *%CFB4BF99FEED.body
}
//-- {AddDecl: 597} region.unprotectedFunction [7879..7984]
	
// dot product
double CVector3D::operator|(VECTOR3D v) const
{
//## begin CVector3D::operator |%52C157CDFEED.body preserve=yes
	return dx*v.dx+dy*v.dy+dz*v.dz;
//## end CVector3D::operator |%52C157CDFEED.body
}
//-- {AddDecl: 598} region.unprotectedFunction [7985..8089]

//methods implementation
double CVector3D::GetLength() const
{
//## begin CVector3D::GetLength%E60591BEFEED.body preserve=yes
	return sqrt(dx*dx+dy*dy+dz*dz);
//## end CVector3D::GetLength%E60591BEFEED.body
}
//-- {AddDecl: 599} region.unprotectedFunction [8090..8164]

double CVector3D::GetLengthXY() const
{
//## begin CVector3D::GetLengthXY%5B14E73DFEED.body preserve=yes
	return sqrt(dx*dx+dy*dy);
//## end CVector3D::GetLengthXY%5B14E73DFEED.body
}
//-- {AddDecl: 600} region.unprotectedFunction [8165..8239]

double CVector3D::GetLengthYZ() const
{
//## begin CVector3D::GetLengthYZ%81BF502DFEED.body preserve=yes
	return sqrt(dy*dy+dz*dz);
//## end CVector3D::GetLengthYZ%81BF502DFEED.body
}
//-- {AddDecl: 601} region.unprotectedFunction [8240..8314]

double CVector3D::GetLengthZX() const
{
//## begin CVector3D::GetLengthZX%36BF7A77FEED.body preserve=yes
	return sqrt(dx*dx+dz*dz);
//## end CVector3D::GetLengthZX%36BF7A77FEED.body
}
//-- {AddDecl: 602} region.unprotectedFunction [8315..8432]

CVector3D CVector3D::GetNormal() const
{
//## begin CVector3D::GetNormal%89114D58FEED.body preserve=yes
	double len = GetLength();
	return CVector3D(dx/len,dy/len,dz/len);
//## end CVector3D::GetNormal%89114D58FEED.body
}
//-- {AddDecl: 603} region.unprotectedFunction [8433..8536]

void CVector3D::Normalize()
{
//## begin CVector3D::Normalize%673AC1ECFEED.body preserve=yes
	double len = GetLength();
	dx /= len;
	dy /= len;
	dz /= len;
//## end CVector3D::Normalize%673AC1ECFEED.body
}
//-- {AddDecl: 604} region.unprotectedFunction [8537..8613]

BOOL CVector3D::IsZeroLength() const
{
//## begin CVector3D::IsZeroLength%C215D9C0FEED.body preserve=yes
	return IS_ZERO(GetLength());
//## end CVector3D::IsZeroLength%C215D9C0FEED.body
}
//-- {AddDecl: 605} region.unprotectedFunction [8614..9127]

CVector3D CVector3D::operator*(const MATRIX3D& matrix) const
{
//## begin CVector3D::operator *%D14BA88DFEED.body preserve=yes
	double rx,ry,rz,sc;
	rx = dx * matrix.A[0][0] + dy * matrix.A[1][0] + dz * matrix.A[2][0] + matrix.A[3][0];
	ry = dx * matrix.A[0][1] + dy * matrix.A[1][1] + dz * matrix.A[2][1] + matrix.A[3][1];
	rz = dx * matrix.A[0][2] + dy * matrix.A[1][2] + dz * matrix.A[2][2] + matrix.A[3][2];
	sc = dx * matrix.A[0][3] + dy * matrix.A[1][3] + dz * matrix.A[2][3] + matrix.A[3][3];
	rx /= sc;
	ry /= sc;
	rz /= sc;
	return CVector3D(rx,ry,rz);
//## end CVector3D::operator *%D14BA88DFEED.body
}
//-- {AddDecl: 606} region.unprotectedFunction [9128..9216]

void  CVector3D::operator*=(const MATRIX3D& matrix)
{
//## begin CVector3D::operator *=%E14657BDFEED.body preserve=yes
	(*this) = (*this)*matrix;
//## end CVector3D::operator *=%E14657BDFEED.body
}
//-- {InsertRegion: 695} module.vulnerableDeclarations [9217..9573]
//## begin module.additionalDeclarations preserve=yes

/************************************************************************************
/	
/	CLASS NAME:  CMatrix2D
/   DESCRIPTION: designed for 2*2 dimensional matrix
/   CREATED BY: Olive Wang in Apr.28,2000
/   MODIFIED By:
/
************************************************************************************/

//construction&&destruction
//## end module.additionalDeclarations
//-- {AddDecl: 607} region.unprotectedFunction [9574..9716]
CMatrix2D::CMatrix2D()
{
//## begin CMatrix2D::CMatrix2D%3A53E5E6FEED.body preserve=yes
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++){
			if(i==j)
				A[i][j] = 1.0;
			else
				A[i][j] = 0.0;
		}
//## end CMatrix2D::CMatrix2D%3A53E5E6FEED.body
}
//-- {AddDecl: 608} region.unprotectedFunction [9717..9845]

CMatrix2D::CMatrix2D(const MATRIX2D& matrix)
{
//## begin CMatrix2D::CMatrix2D%5B783DE9FEED.body preserve=yes
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
			A[i][j]=matrix.A[i][j];
//## end CMatrix2D::CMatrix2D%5B783DE9FEED.body
}
//-- {AddDecl: 609} region.unprotectedFunction [9846..9971]

CMatrix2D::CMatrix2D(const double* matrix)
{
//## begin CMatrix2D::CMatrix2D%F25AF8BBFEED.body preserve=yes
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
			A[i][j]=matrix[i*3+j];
//## end CMatrix2D::CMatrix2D%F25AF8BBFEED.body
}
//-- {AddDecl: 610} region.unprotectedFunction [9972..10006]


CMatrix2D::~CMatrix2D()
{
//## begin CMatrix2D::~CMatrix2D%9BBA566AFEED.body preserve=yes
//## end CMatrix2D::~CMatrix2D%9BBA566AFEED.body
}
//-- {AddDecl: 611} region.unprotectedFunction [10007..10293]

//operators
CMatrix2D CMatrix2D::operator*(const MATRIX2D& matrix2) const
{
//## begin CMatrix2D::operator *%6A47CC31FEED.body preserve=yes
	CMatrix2D matrix;
	for(int i=0;i<3;i++)
	for(int j=0;j<3;j++){
		matrix.A[i][j] = A[i][0]*matrix2.A[0][j]
					   + A[i][1]*matrix2.A[1][j]
					   + A[i][2]*matrix2.A[2][j];
	}
	return matrix;
//## end CMatrix2D::operator *%6A47CC31FEED.body
}
//-- {AddDecl: 612} region.unprotectedFunction [10294..10381]

void CMatrix2D::operator*=(const MATRIX2D& matrix2)
{
//## begin CMatrix2D::operator *=%63C4D3E2FEED.body preserve=yes
	(*this)=(*this)*matrix2;
//## end CMatrix2D::operator *=%63C4D3E2FEED.body
}
//-- {AddDecl: 613} region.unprotectedFunction [10382..10550]

//methods
void CMatrix2D::IdenticalMatrix()
{
//## begin CMatrix2D::IdenticalMatrix%ED7F94ECFEED.body preserve=yes
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++){
			if(i==j)
				A[i][j] = 1.0;
			else
				A[i][j] = 0.0;
		}
//## end CMatrix2D::IdenticalMatrix%ED7F94ECFEED.body
}
//-- {AddDecl: 614} region.unprotectedFunction [10551..10636]

double CMatrix2D::GetValue() const
{
//## begin CMatrix2D::GetValue%5D9CC103FEED.body preserve=yes
	return A[0][0]*A[1][1]-A[0][1]*A[1][0];
//## end CMatrix2D::GetValue%5D9CC103FEED.body
}
//-- {AddDecl: 615} region.unprotectedFunction [10637..10781]

// static member functions
double CMatrix2D::GetValue(double a00, double a01,
			   double a10, double a11)
{
//## begin CMatrix2D::GetValue%8D2D30AEFEED.body preserve=yes
	return a00*a11-a01*a10;
//## end CMatrix2D::GetValue%8D2D30AEFEED.body
}
//-- {AddDecl: 616} region.unprotectedFunction [10782..11077]

CMatrix2D CMatrix2D::CreateMirrorMatrix(VECTOR2D v)
{
//## begin CMatrix2D::CreateMirrorMatrix%0C7EFFA0FEED.body preserve=yes
	double len=((CVector2D)v).GetLength();
	CMatrix2D matrix;
	matrix.A[0][0]=(v.dx*v.dx - v.dy*v.dy)/len;
	matrix.A[0][1]=2.0*(v.dx*v.dy)/len;
	matrix.A[1][0]=2.0*(v.dx*v.dy)/len;
	matrix.A[1][1]= -matrix.A[0][0];
	return matrix;
//## end CMatrix2D::CreateMirrorMatrix%0C7EFFA0FEED.body
}
//-- {AddDecl: 617} region.unprotectedFunction [11078..11248]

CMatrix2D CMatrix2D::CreateRotateMatrix(double angle)
{
//## begin CMatrix2D::CreateRotateMatrix%90AC43F9FEED.body preserve=yes
	CMatrix2D m;
	m.A[0][0]=m.A[1][1]=cos(angle);
	m.A[0][1]=sin(angle);m.A[1][0]= -sin(angle);
	return m;
//## end CMatrix2D::CreateRotateMatrix%90AC43F9FEED.body
}
//-- {AddDecl: 618} region.unprotectedFunction [11249..11358]

CMatrix2D CMatrix2D::CreateScaleMatrix(double d)
{
//## begin CMatrix2D::CreateScaleMatrix%EB40D6B5FEED.body preserve=yes
	CMatrix2D m;
	m.A[0][0]=m.A[1][1]=d;
	return m;
//## end CMatrix2D::CreateScaleMatrix%EB40D6B5FEED.body
}
//-- {AddDecl: 619} region.unprotectedFunction [11359..11488]

CMatrix2D CMatrix2D::CreateTransfMatrix(VECTOR2D vec)
{
//## begin CMatrix2D::CreateTransfMatrix%04C20E2AFEED.body preserve=yes
	CMatrix2D m;
	m.A[2][0]=vec.dx;
	m.A[2][1]=vec.dy;
	return m;
//## end CMatrix2D::CreateTransfMatrix%04C20E2AFEED.body
}
//-- {AddDecl: 620} region.unprotectedFunction [11489..12057]

//求伴随矩阵
CMatrix2D CMatrix2D::GetAccompany()const
{
//## begin CMatrix2D::GetAccompany%1DC89693FEED.body preserve=yes
	CMatrix2D m;

	for(int i=0;i<3;i++)
	{
		for(int j=0;j<3;j++)
		{
			double  tp[2][2];
			int num=0;
			for(int g=0;g<3;g++)
			{
				if(g==i) continue;
				for(int h=0;h<3;h++)
				{
					if(h==j) continue;
					else
					{
						ASSERT(num<4);
						*tp[num]=A[g][h];
						num++;
					}
				}
			}
			int tip;
			double fuhao;
			tip=i+j+2;
			fuhao=1.0;
			if(tip%2==1) fuhao=-1.0;
			m.A[i][j]=fuhao*GetValue(*tp[0],*tp[1],*tp[2],*tp[3]);
		}
	}
	m=m.T();
	return m;
//## end CMatrix2D::GetAccompany%1DC89693FEED.body
}
//-- {AddDecl: 621} module.vulnerableDeclarations [12058..14314]
//## begin module.additionalDeclarations preserve=yes
#define R 3
void let(int t,double  a[R][R*2] )
{
    int sw=1;
	int c,k;
	if(a[t][t]==0)
	{
		for(c=t+1;c<=(R-1);c++)
		{
			if(a[c][t]!=0)
			{
				for(k=0;k<=(2*R-1);k++)
				{
					a[t][k]+=a[c][k];
				}
				if(a[t][k]*a[t][k]<0.00001)
				{
					a[t][k]=0;
				}
				break;
			}
		}
	}
	ASSERT(a[t][t]!=0);
	
}
void swap(double a ,double b)
{
	double c = a;
	a = b;
	b = c;
}

//求逆阵
double Inverse(CMatrix2D& mOut, const CMatrix2D& rhs)
{
	CMatrix2D m(rhs);
	DWORD is[R];
	DWORD js[R];
	double fDet = 1.0;
	int f = 1;
	
	for (DWORD k = 0; k < R; k ++)
	{
		// 第一步，全选主元
		double fMax = 0.0f;
		for (DWORD i = k; i < R; i ++)
		{
			for (DWORD j = k; j < R; j ++)
			{
				const double f = fabs(m.A [i][j] );
				if (f > fMax)
				{
					fMax = f;
					is[k] = i;
					js[k] = j;
				}
			}
		}
		if (fabs(fMax) < 0.0001f)
			return 0;
		
		if (is[k] != k)
		{
			f = -f;
			swap(m.A[k][0], m.A[is[k]][0]);
			swap(m.A[k][1], m.A[is[k]][1]);
			swap(m.A[k][2], m.A[is[k]][2]);
		}
		if (js[k] != k)
		{
			f = -f;
			swap(m.A[0][k], m.A[0][js[k]]);
			swap(m.A[1][k], m.A[1][js[k]]);
			swap(m.A[2][k], m.A[2][js[k]]);
		}
		
		// 计算行列值
		fDet *= m.A[k][k];
		
		// 计算逆矩阵
		
		// 第二步
		m.A[k][k] = 1.0f / m.A[k][k];
		// 第三步
		for (DWORD j = 0; j < R; j ++)
		{
			if (j != k)
				m.A[k][j] *= m.A[k][k];
		}
		// 第四步
		for ( i = 0; i < R; i ++)
		{
			if (i != k)
			{
				for (j = 0; j < R; j ++)
				{
					if (j != k)
						m.A[i][j] = m.A[i][j] - m.A[i][k] * m.A[k][j];
				}
			}
		}
		// 第五步