vector.cpp

蒙特卡罗方法可以有效地解决复杂的工程问题

// Vector.cpp: implementation of the CVector class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "RayTrace.h"

#include <math.h>

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CVector::CVector( double x, double y, double z )
{
	m_dX = x ;
	m_dY = y ;
	m_dZ = z ;
}

CVector::CVector( const CVector &vec)
{
	m_dX = vec.m_dX;
	m_dY = vec.m_dY;
	m_dZ = vec.m_dZ;
}

CVector::~CVector()
{}

CVector CVector::operator + (const CVector &vec) const
{
	CVector temp;
	temp.m_dX = m_dX + vec.m_dX;
	temp.m_dY = m_dY + vec.m_dY;
	temp.m_dZ = m_dZ + vec.m_dZ;
	return temp;
}

CVector CVector::operator - (const CVector &vec) const
{
	CVector temp;
	temp.m_dX = m_dX - vec.m_dX;
	temp.m_dY = m_dY - vec.m_dY;
	temp.m_dZ = m_dZ - vec.m_dZ;
	return temp;
}

double  CVector::operator * (const CVector &vec) const  //重载*，点乘
{
	return m_dX*vec.m_dX + m_dY*vec.m_dY + m_dZ*vec.m_dZ ;
}

CVector CVector::operator / (const CVector &vec) const  //重载/，叉乘
{
	CVector temp;
	temp.m_dX = m_dY*vec.m_dZ - m_dZ*vec.m_dY;
	temp.m_dY = m_dZ*vec.m_dX - m_dX*vec.m_dZ;
	temp.m_dZ = m_dX*vec.m_dY - m_dY*vec.m_dX;
	return temp;
}

CVector CVector::operator * (double dnum) const  //重载*，数乘
{
	CVector temp;
	temp.m_dX = m_dX*dnum;
	temp.m_dY = m_dY*dnum;
	temp.m_dZ = m_dZ*dnum;
	return temp;
}

CVector CVector::operator * (const CMatrix &mat) const   //重载*，乘矩阵
{
	CVector temp;
	temp.m_dX =  m_dX * mat.GetOffset(0,0)
				+m_dY * mat.GetOffset(1,0)
				+m_dZ * mat.GetOffset(2,0)
				+1    * mat.GetOffset(3,0) ;
	temp.m_dY =  m_dX * mat.GetOffset(0,1)
				+m_dY * mat.GetOffset(1,1)
				+m_dZ * mat.GetOffset(2,1)
				+1    * mat.GetOffset(3,1) ;
	temp.m_dX =  m_dX * mat.GetOffset(0,2)
				+m_dY * mat.GetOffset(1,2)
				+m_dZ * mat.GetOffset(2,2)
				+1    * mat.GetOffset(3,2) ;

	return temp;
}

void CVector::operator += (const CVector &vec)
{
	m_dX += vec.m_dX;
	m_dY += vec.m_dY;
	m_dZ += vec.m_dZ;
}

void CVector::operator -= (const CVector &vec)
{
	m_dX -= vec.m_dX;
	m_dY -= vec.m_dY;
	m_dZ -= vec.m_dZ;
}

void CVector::operator *= (double dnum)//重载*，数乘
{
	m_dX *= dnum;
	m_dY *= dnum;
	m_dZ *= dnum;
}

void CVector::operator *= (const CMatrix &mat)  //重载*=，乘矩阵
{
	double X,Y,Z;
	X=m_dX;
	Y=m_dY;
	Z=m_dZ;
	m_dX =   X * mat.GetOffset(0,0)
			+Y * mat.GetOffset(1,0)
			+Z * mat.GetOffset(2,0)
			+1 * mat.GetOffset(3,0) ;
	m_dY =   X * mat.GetOffset(0,1)
			+Y * mat.GetOffset(1,1)
			+Z * mat.GetOffset(2,1)
			+1 * mat.GetOffset(3,1) ;
	m_dX =   X * mat.GetOffset(0,2)
			+Y * mat.GetOffset(1,2)
			+Z * mat.GetOffset(2,2)
			+1 * mat.GetOffset(3,2) ;
	
}
void CVector::operator /= (const CVector &vec)  //重载/，叉乘
{
	double x=m_dX,y=m_dY,z=m_dZ;
	m_dX = y*vec.m_dZ - z*vec.m_dY;
	m_dY = z*vec.m_dX - x*vec.m_dZ;
	m_dZ = x*vec.m_dY - y*vec.m_dX;
}

void CVector::operator = (const CVector &vec) //赋值
{
	m_dX = vec.m_dX;
	m_dY = vec.m_dY;
	m_dZ = vec.m_dZ;
}

void CVector::Empty()  //置空
{
	m_dX = 0.0;
	m_dY = 0.0;
	m_dZ = 0.0;
}

void CVector::Reverse() //反转
{
	m_dX =- m_dX;
	m_dY =- m_dY;
	m_dZ =- m_dZ;
}

void CVector::GetOffset(double &x,double &y,double &z)//获取分量值
{
	x = m_dX;
	y = m_dY;
	z = m_dZ;
}
void CVector::SetOffset(double x,double y,double z)//设置分量值
{
	m_dX = x ;
	m_dY = y ;
	m_dZ = z ;
}

double CVector::GetLength()	 //计算长度（模）
{
	return sqrt( m_dX*m_dX+m_dY*m_dY+m_dZ*m_dZ );
}

void CVector::Normalize()	 //归一化
{
	double temp = GetLength();
	if( temp ) //模非零
	{
		m_dX /= temp;
		m_dY /= temp;
		m_dZ /= temp;
	}
	else
	{
//		AfxMessageBox("向量长度不能是0!");
		this->Empty();
	}
}

void CVector::print()		 //输出
{
}

double CVector::GetX()
{	
	return m_dX;
}

double CVector::GetY()
{
	return m_dY;
}

double CVector::GetZ()
{
	return m_dZ;
}

void CVector::ElemMult(const CVector &vec)
{
	m_dX *= vec.m_dX ;
	m_dY *= vec.m_dY ;
	m_dZ *= vec.m_dZ ;
}

void CVector::Rotate_X(double alpha)
{
	double y,z;
	alpha = Radian( alpha );
	y = m_dY;
	z = m_dZ;
	m_dY = y * cos(alpha) - z * sin(alpha);
	m_dZ = y * sin(alpha) + z * cos(alpha);

}

void CVector::Rotate_Y(double alpha)
{
	double x,z;
	alpha = Radian( alpha );
	x = m_dX;
	z = m_dZ;
	m_dX = x * cos(alpha) + z * sin(alpha);
	m_dZ = -x * sin(alpha) + z * cos(alpha);

}

void CVector::Rotate_Z(double alpha)
{
	double x,y;
	alpha = Radian( alpha );
	x = m_dX;
	y = m_dY;
	m_dX = x * cos(alpha) - y * sin(alpha);
	m_dY = x * sin(alpha) + y * cos(alpha);

}

void CVector::Rotate(CVector rotate)
{
	Rotate_X( rotate.m_dX );
	Rotate_Y( rotate.m_dY );
	Rotate_Z( rotate.m_dZ );

}

void CVector::Translate(CVector offset)
{
	m_dX += offset.m_dX;
	m_dY += offset.m_dY;
	m_dZ += offset.m_dZ;

}

double CVector::GetDistance(const CVector &vec)
{
	return sqrt(   ( m_dX - vec.m_dX ) * ( m_dX - vec.m_dX )	
				 + ( m_dY - vec.m_dY ) * ( m_dY - vec.m_dY )
				 + ( m_dZ - vec.m_dZ ) * ( m_dZ - vec.m_dZ )		);

}