//-------------------------------------------------------------------------------------------------------+
// Copyright (C), 1998-2007, Beijing Tangent Software Co. Ltd.
// = FileName	:   TGVector3D 类
// = Version	:   ver2.0
// = Author		:   wlw
// = CreateDate	:   2002-09-09
// = Description:   TGVector3D 定义
// = Maintainers: 
//                  
//-------------------------------------------------------------------------------------------------------+
#include "StdAfx.h"
#include "TGVector3D.h"

TGVector3D::TGVector3D(double x /*= 0*/,double y /*= 0*/,double z /*= 0*/):TGPoint(x,y,z)
{

}

TGVector3D::TGVector3D(double *p):TGPoint(p)
{
}

TGVector3D::TGVector3D(float*p):TGPoint(p)
{
}

TGVector3D::TGVector3D(const TGPoint& pt):TGPoint(pt)
{
}

TGVector3D::TGVector3D(const TGPoint& fromPt,const TGPoint& toPt):TGPoint(toPt.x-fromPt.x,toPt.y-fromPt.y,toPt.z-fromPt.z)
{
}

TGVector3D::~TGVector3D()
{

}

double TGVector3D::Length() const
{
	return Length3D();
}

bool TGVector3D::IsValid() const
{
	return UP_ZEROD(Length());
}

bool TGVector3D::IsNullVector() const
{
	double l = Length();
	return EQUAL_ZEROD(l);
}

bool TGVector3D::IsNormalized() const
{
	double temp = 1 - Length();
	return EQUAL_ZEROD(temp);
}

void TGVector3D::SetVector(double x,double y,double z)
{
	TGPoint::SetPoint(x,y,z);
}

void TGVector3D::SetLength(double len)
{
	(*this) *= (len/Length());
}

void TGVector3D::Reverse()
{
	x = -x;
	y = -y;
	z = -z;
}

TGVector3D TGVector3D::operator -() const
{
	return TGVector3D(-x,-y,-z);
}

TGVector3D TGVector3D::operator +(const TGPoint& vt) const
{
	return TGVector3D(x+vt.x, y+vt.y, z+vt.z);
}

TGVector3D TGVector3D::operator -(const TGPoint& vt) const
{
	return TGVector3D(x-vt.x, y-vt.y, z-vt.z);
}

TGVector3D TGVector3D::operator *(double rate) const
{
	return TGVector3D(x*rate, y*rate, z*rate);
}

TGVector3D TGVector3D::operator /(double rate) const
{
	return TGVector3D(x/rate, y/rate, z/rate);
}

TGVector3D TGVector3D::operator *(const TGPoint& vt) const
{
	return TGVector3D(y * vt.z - z * vt.y, z * vt.x - x * vt.z, x * vt.y - y * vt.x);
}

double TGVector3D::operator & (const TGPoint& vt) const
{
	return x * vt.x + y * vt.y + z * vt.z;
}

bool TGVector3D::Normalize()
{
	double len = Length();
	if (UP_ZERO(len))
	{
		x /= len;
		y /= len;
		z /= len;
		return true;
	}
	return false;
}

bool TGVector3D::IsParallel(const TGPoint& vt,bool bNormalized) const
{
	if (bNormalized)
	{
		return ((*this)*vt).IsNullVector();
	}
	TGVector3D vt0(*this),vt1(vt);
	vt0.Normalize();
	vt1.Normalize();
	return (vt0*vt1).IsNullVector();
}

bool TGVector3D::IsVert(const TGPoint& vt,bool bNormalized) const
{
	double temp;
	if (bNormalized)
	{
		temp = (*this)& vt;
	}
	else
	{
		TGVector3D vt0(*this),vt1(vt);
		vt0.Normalize();
		vt1.Normalize();
		temp = vt0& vt1;
	}
	return EQUAL_ZERO(temp);
}

bool TGVector3D::IsSameDirection(const TGPoint& vt,bool bNormalized) const
{
	double temp;
	if (bNormalized)
	{
		temp = (*this)& vt;
	}
	else
	{
		TGVector3D vt0(*this),vt1(vt);
		vt0.Normalize();
		vt1.Normalize();
		temp = vt0 & vt1;
	}
	return UP_ZERO(temp);
}

bool TGVector3D::IsReverseDirection(const TGPoint& vt,bool bNormalized) const
{
	double temp;
	if (bNormalized)
	{
		temp = (*this)& vt;
	}
	else
	{
		TGVector3D vt0(*this),vt1(vt);
		vt0.Normalize();
		vt1.Normalize();
		temp = vt0 & vt1;
	}
	return DOWN_ZERO(temp);
}

double TGVector3D::GetAngleWith(const TGPoint& vt,bool bNormalized) const
{
	if (bNormalized)
	{
		return acos((*this)& vt);
	}
	else
	{
		TGVector3D vt0(*this),vt1(vt);
		vt0.Normalize();
		vt1.Normalize();
		return acos(vt0 & vt1);
	}
}

bool TGVector3D::GetVertVector(TGPoint& vt) const
{
	if(EQUAL_ZERO(x) && EQUAL_ZERO(y))
	{
		if(EQUAL_ZERO(z))
		{
			return false;
		}
		vt.x = 1;
		vt.y = 0;
		vt.z = 0;
	}
	else 
	{
		vt.x = -y;
		vt.y = x;
		vt.z = 0;
	}
	return true;
}