#include "stdafx.h"
#include "../inc/geomcalc/cadbase.h"
#include "math.h"

/***********************************************************************************
/
/   CLASS NAME: CPoint2D
/	CLASS DESCRIPATION: Designed for 2 dimensional point
/   CREATED BY: Olive Wang in Apr.28,2000
/   MODIFIED BY:
*************************************************************************************/

// constructor && destructor
CPoint2D::CPoint2D()
{
	x=0.0;
	y=0.0;
}

CPoint2D::CPoint2D(double ix,double iy)
{
	x = ix;
	y = iy;
}

CPoint2D::CPoint2D(const double*p)
{
	x=p[0];
	y=p[1];
}

CPoint2D::CPoint2D(POINT2D p)
{
	x=p.x;
	y=p.y;
}

CPoint2D::~CPoint2D()
{
}


// offsetting with vector
CPoint2D CPoint2D::operator+(VECTOR2D v) const
{
	return CPoint2D(x+v.dx,y+v.dy);
}

void CPoint2D::operator+=(VECTOR2D v)
{
	x+=v.dx;
	y+=v.dy;
}

CPoint2D CPoint2D::operator-(VECTOR2D v) const
{
	return CPoint2D(x-v.dx,y-v.dy);
}

void CPoint2D::operator-=(VECTOR2D v)
{
	x+=v.dx;
	y+=v.dy;
}


// derive vector = this point - sp
CVector2D CPoint2D::operator-(POINT2D sp) const
{
	return CVector2D(x-sp.x,y-sp.y);
}

// transform the point
CPoint2D CPoint2D::operator*(const MATRIX2D& matrix) const
{
	double xx,yy,sc;
	xx = x*matrix.A[0][0]+y*matrix.A[1][0] + matrix.A[2][0];
	yy = x*matrix.A[0][1]+y*matrix.A[1][1] + matrix.A[2][1];
	sc = x*matrix.A[0][2]+y*matrix.A[1][2] + matrix.A[2][2];
	xx /= sc;
	yy /= sc;
	return CPoint2D(xx,yy);
}

void  CPoint2D::operator*=(const MATRIX2D& matrix)
{
	(*this)=(*this)*matrix;
}
/**********************************************************************************
//
//     CLASS NAME: CVector2D
//     DESCRIPTION: designed for 2 dimensional vector
//     CREATED BY: Olive Wang in April 28,2000
//     MODIFIED BY:
//
***********************************************************************************/
// constructor&&destructor
CVector2D::CVector2D()
{
	dx=0.0;
	dy=0.0;
}

CVector2D::CVector2D(double ix,double iy)
{
	dx=ix;
	dy=iy;
}

CVector2D::CVector2D(const double* pv)
{
	dx=pv[0];
	dy=pv[1];
}

CVector2D::CVector2D(VECTOR2D v)
{	
	dx=v.dx;
	dy=v.dy;
}

CVector2D::~CVector2D()
{
}

CVector2D CVector2D::operator+(VECTOR2D v) const
{
	return CVector2D(dx+v.dx,dy+v.dy);
}

CVector2D CVector2D::operator-(VECTOR2D v) const
{
	return CVector2D(dx-v.dx,dy-v.dy);
}

void CVector2D::operator+=(VECTOR2D v)
{
	dx += v.dx;
	dy += v.dy;
}

void CVector2D::operator-=(VECTOR2D v)
{
	dx-=v.dx;
	dy-=v.dy;
}

CVector2D CVector2D::operator*(double d) const
{
	return CVector2D(dx*d,dy*d);
}

void CVector2D::operator*=(double d)
{
	dx *= d;
	dy *= d;
}

CVector2D CVector2D::operator/(double d) const
{
	return CVector2D(dx/d,dy/d);
}
	
void CVector2D::operator/=(double d)
{
	dx /= d;
	dy /= d;
}

// cross product
CVector3D CVector2D::operator*(VECTOR2D v) const
{
	return CVector3D(0.0,0.0,dx*v.dy-v.dx*dy);
}
	
// dot product
double CVector2D::operator|(VECTOR2D v) const
{
	return dx*v.dx+dy*v.dy;
}


//matrix transform
CVector2D CVector2D::operator*(const MATRIX2D& matrix) const
{
	double x,y,sc;
	x = dx*matrix.A[0][0]+dy*matrix.A[1][0] + matrix.A[2][0];
	y = dx*matrix.A[0][1]+dy*matrix.A[1][1] + matrix.A[2][1];
	sc= dx*matrix.A[0][2]+dy*matrix.A[1][2] + matrix.A[2][2];
	x /= sc;
	y /= sc;
	return CVector2D(x,y);
}

void CVector2D::operator*=(const MATRIX2D& matrix)
{
	(*this)=(*this)*matrix;
}

double CVector2D::GetLength() const
{
	return sqrt(dx*dx+dy*dy);
}

CVector2D CVector2D::GetNormal() const
{
	double len = GetLength();
	return CVector2D(dx/len,dy/len);
}

void CVector2D::Normalize()
{
	double len = GetLength();
	dx = dx/len;
	dy = dy/len;
}

BOOL CVector2D::IsZeroLength() const
{
	return IS_ZERO(GetLength());
}

/***********************************************************************************
/
/   CLASS NAME: CPoint3D
/	CLASS DESCRIPATION: Designed for 2 dimensional point
/   CREATED BY: Olive Wang in Apr.28,2000
/   MODIFIED BY:
*************************************************************************************/

// constructor && destructor
CPoint3D::CPoint3D()
{
	x=0.0;
	y=0.0;
	z=0.0;
}

CPoint3D::CPoint3D(double ix,double iy,double iz)
{
	x = ix;
	y = iy;
	z = iz; 
}

CPoint3D::CPoint3D(const double*p)
{
	x=p[0];
	y=p[1];
	z=p[2];
}

CPoint3D::CPoint3D(POINT3D p)
{
	x=p.x;
	y=p.y;
	z=p.z;
}

CPoint3D::~CPoint3D()
{
}

//operators
CPoint3D CPoint3D::operator*(const MATRIX3D& matrix) const
{
	double rx,ry,rz,sc;
	rx = x * matrix.A[0][0] + y * matrix.A[1][0] + z * matrix.A[2][0] + matrix.A[3][0];
	ry = x * matrix.A[0][1] + y * matrix.A[1][1] + z * matrix.A[2][1] + matrix.A[3][1];
	rz = x * matrix.A[0][2] + y * matrix.A[1][2] + z * matrix.A[2][2] + matrix.A[3][2];
	sc = x * matrix.A[0][3] + y * matrix.A[1][3] + z * matrix.A[2][3] + matrix.A[3][3];
	rx /= sc;
	ry /= sc;
	rz /= sc;
	return CPoint3D(rx,ry,rz);
}

void  CPoint3D::operator*=(const MATRIX3D& matrix)
{
	(*this) = (*this)*matrix;
}

// offsetting with vector
CPoint3D CPoint3D::operator+(VECTOR3D v) const
{
	return CPoint3D(x+v.dx,y+v.dy,z+v.dz);
}

void CPoint3D::operator+=(VECTOR3D v)
{
	x+=v.dx;
	y+=v.dy;
	z+=v.dz;
}

CPoint3D CPoint3D::operator-(VECTOR3D v) const
{
	return CPoint3D(x-v.dx,y-v.dy,z-v.dz);
}

void CPoint3D::operator-=(VECTOR3D v)
{
	x-=v.dx;
	y-=v.dy;
	z-=v.dz;
}


// derive vector = this point - sp
CVector3D CPoint3D::operator-(POINT3D sp) const
{
	return CVector3D(x-sp.x,y-sp.y,z-sp.z);
}

BOOL CPoint3D::operator==(POINT3D pos) const
{
	CVector3D  vect(x-pos.x,y-pos.y,z-pos.z);

	if( IS_ZERO( vect.GetLength( ) ) ) return TRUE;
	else return FALSE;

}
BOOL CPoint3D::operator!=(POINT3D pos) const
{
	CVector3D  vect(x-pos.x,y-pos.y,z-pos.z);

	if( IS_ZERO( vect.GetLength( ) ) ) return FALSE;
	else return TRUE;
}


/************************************************************************************
/	
/	CLASS NAME:  CVector3D
/   DESCRIPTION: designed for 3 dimensional vector
/   CREATED BY: Olive Wang in Apr.28,2000
/   MODIFIED By:
/
************************************************************************************/
// constructor&&destructor
CVector3D::CVector3D()
{
	dx=0.0;
	dy=0.0;
	dz=0.0;
}

CVector3D::CVector3D(double ix,double iy,double iz)
{
	dx=ix;
	dy=iy;
	dz=iz;
}

CVector3D::CVector3D(const double* pv)
{
	dx=pv[0];
	dy=pv[1];
	dz=pv[2];
}

CVector3D::CVector3D(VECTOR3D v)
{	
	dx=v.dx;
	dy=v.dy;
	dz=v.dz;
}

CVector3D::~CVector3D()
{
}

CVector3D CVector3D::operator+(VECTOR3D v) const
{
	return CVector3D(dx+v.dx,dy+v.dy,dz+v.dz);
}

CVector3D CVector3D::operator-(VECTOR3D v) const
{
	return CVector3D(dx-v.dx,dy-v.dy,dz-v.dz);
}

void CVector3D::operator+=(VECTOR3D v)
{
	dx += v.dx;
	dy += v.dy;
	dz += v.dz;
}

void CVector3D::operator-=(VECTOR3D v)
{
	dx -= v.dx;
	dy -= v.dy;
	dz -= v.dz;
}

CVector3D CVector3D::operator*(double d) const
{
	return CVector3D(dx*d,dy*d,dz*d);
}

void CVector3D::operator*=(double d)
{
	dx *= d;
	dy *= d;
	dz *= d;
}

CVector3D CVector3D::operator/(double d) const
{
	return CVector3D(dx/d,dy/d,dz/d);
}
	
void CVector3D::operator/=(double d)
{
	dx /= d;
	dy /= d;
	dz /= d;
}

// cross product
CVector3D CVector3D::operator*(VECTOR3D v) const
{
	return CVector3D(dy*v.dz-v.dy*dz,v.dx*dz-dx*v.dz,dx*v.dy-v.dx*dy);
}
	
// dot product
double CVector3D::operator|(VECTOR3D v) const
{
	return dx*v.dx+dy*v.dy+dz*v.dz;
}

//methods implementation
double CVector3D::GetLength() const
{
	return sqrt(dx*dx+dy*dy+dz*dz);
}

double CVector3D::GetLengthXY() const
{
	return sqrt(dx*dx+dy*dy);
}

double CVector3D::GetLengthYZ() const
{
	return sqrt(dy*dy+dz*dz);
}

double CVector3D::GetLengthZX() const
{
	return sqrt(dx*dx+dz*dz);
}

CVector3D CVector3D::GetNormal() const
{
	double len = GetLength();
	return CVector3D(dx/len,dy/len,dz/len);
}

void CVector3D::Normalize()
{
	double len = GetLength();
	dx /= len;
	dy /= len;
	dz /= len;
}

BOOL CVector3D::IsZeroLength() const
{
	return IS_ZERO(GetLength());
}

CVector3D CVector3D::operator*(const MATRIX3D& matrix) const
{
	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);
}

void  CVector3D::operator*=(const MATRIX3D& matrix)
{
	(*this) = (*this)*matrix;
}

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

//construction&&destruction
CMatrix2D::CMatrix2D()
{
	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;
		}
}

CMatrix2D::CMatrix2D(const MATRIX2D& matrix)
{
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
			A[i][j]=matrix.A[i][j];
}

CMatrix2D::CMatrix2D(const double* matrix)
{
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
			A[i][j]=matrix[i*3+j];
}


CMatrix2D::~CMatrix2D()
{
}

//operators
CMatrix2D CMatrix2D::operator*(const MATRIX2D& matrix2) const
{
	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;
}

void CMatrix2D::operator*=(const MATRIX2D& matrix2)
{
	(*this)=(*this)*matrix2;
}

//methods
void CMatrix2D::IdenticalMatrix()
{
	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;
		}
}

double CMatrix2D::GetValue() const
{
	return A[0][0]*A[1][1]-A[0][1]*A[1][0];
}

// static member functions
double CMatrix2D::GetValue(double a00, double a01,
			   double a10, double a11)
{
	return a00*a11-a01*a10;
}

CMatrix2D CMatrix2D::CreateMirrorMatrix(VECTOR2D v)
{
	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;
}

CMatrix2D CMatrix2D::CreateRotateMatrix(double angle)
{
	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;
}

CMatrix2D CMatrix2D::CreateScaleMatrix(double d)
{
	CMatrix2D m;
	m.A[0][0]=m.A[1][1]=d;
	return m;
}

CMatrix2D CMatrix2D::CreateTransfMatrix(VECTOR2D vec)
{