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

TGVector2D::TGVector2D(double x,double y,double z):TGPoint(x,y,z)
{
	
}

TGVector2D::TGVector2D(double*p):TGPoint(p[0],p[1])
{

}

TGVector2D::TGVector2D(float*p):TGPoint(p[0],p[1])
{

}

TGVector2D::TGVector2D(const TGPoint& pt):TGPoint(pt)
{

}

TGVector2D::TGVector2D(const TGPoint& fromPt,const TGPoint& toPt):TGPoint(toPt.x-fromPt.x,toPt.y-fromPt.y)
{

}

TGVector2D::~TGVector2D()
{

}

void TGVector2D::Polar(double angle)
{
	x = cos(angle);
	y = sin(angle);
}

double TGVector2D::Length() const
{
	return Length2D();
}

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

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

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

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

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

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

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

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

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

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

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

void TGVector2D::operator +=  (const TGPoint& vt)
{
	x += vt.x; 
	y += vt.y;
}

void  TGVector2D::operator  -= (const TGPoint& vt)
{
	x -= vt.x; 
	y -= vt.y;
}

void  TGVector2D::operator *=  (double rate)
{
	x *= rate; 
	y *= rate;
}

void  TGVector2D::operator /=  (double rate)
{
	x /= rate; 
	y /= rate; 
}

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

double TGVector2D::operator *(const TGPoint& vt) const
{
	return x*vt.y-y*vt.x;
}

bool TGVector2D::operator == (const TGPoint& pt) const
{
	return Equal2D(pt);
}

bool TGVector2D::operator != (const TGPoint& pt) const
{
	return !Equal2D(pt);
}

void TGVector2D::GetLVertVector(TGPoint& vt) const
{
	vt = TGVector2D(-y,x);
}

void TGVector2D::GetRVertVector(TGPoint& vt) const
{
	vt = TGVector2D(y,-x);
}

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

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

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

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

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

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

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

double TGVector2D::GetAngleWith(const TGPoint& vt,bool bNormalized) const
{
	if (bNormalized)
	{
		double result = acos((*this)& vt);
		return IsVectorLeft(vt,true) ? PI2 - result : result;
	}
	else
	{
		TGVector2D vt0(*this),vt1(vt);
		vt0.Normalize();
		vt1.Normalize();
		double result = acos(vt0& vt1);
		return vt0.IsVectorLeft(vt1,true) ? PI2 - result : result;
	}
}

double TGVector2D::GetAngle() const
{
	double result = acos(x / Length());
	return y < 0 ? PI2 - result : result;
}