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

TGGeSector::TGGeSector()
{
	m_dstartAngle = 0.0;
	m_dendAngle = 2.0*PI;
}

TGGeSector::TGGeSector(double dStAng, double dEndAng)
{
	m_dstartAngle = dStAng;
	m_dendAngle = dEndAng;
}

TGGeSector::TGGeSector(const TGGeSector &src)
{
	m_dstartAngle = src.m_dstartAngle;
	m_dendAngle = src.m_dendAngle;
}

TGGeSector::TGGeSector(const TEntitySet & ent)
{
	TEntitySet entTmp = ent;
	if (entTmp.Is(_T("ARC")))
	{
		entTmp.GetData(50, &m_dstartAngle);
		entTmp.GetData(51, &m_dendAngle);
	}
	else 
	{
		m_dstartAngle = 0.0;
		m_dendAngle   = PI * 2.0;
	}
}

TGGeSector::~TGGeSector()
{

}

TGGeSector& TGGeSector::operator = (TGGeSector &src)
{
	m_dstartAngle = src.m_dstartAngle;
	m_dendAngle = src.m_dendAngle;
	return *this;
}

bool TGGeSector::operator == (const TGGeSector &src) const
{
	return (RealEqual(m_dstartAngle, src.m_dstartAngle, _angSnap) &&
			RealEqual(m_dendAngle, src.m_dendAngle, _angSnap));
}

int TGGeSector::operator ! () const
{
	return Bulge() < _angSnap;
}

double TGGeSector::Bulge() const
{
	ads_real dBulge = m_dendAngle - m_dstartAngle;
	if (dBulge < -1E-6)
	{
		dBulge = 2.0 * PI + dBulge;
	}
	
	return dBulge;
}

void TGGeSector::SetAngles(double dStart, double dEnd)
{
	m_dstartAngle = dStart;
	m_dendAngle = dEnd;
}

void TGGeSector::SetStarAngle(double dAngle)
{
	m_dstartAngle = dAngle;
}

void TGGeSector::SetEndAngle(double dAngle)
{
	m_dendAngle = dAngle;
}

double TGGeSector::GetStarAngle() const
{
	return m_dstartAngle;
}

double TGGeSector::GetEndAngle() const
{
	return m_dendAngle;
}

int TGGeSector::AngleFlag(double dAng) const
{
	if (AngleRangeTo2PI(dAng - m_dstartAngle) < _angSnap)
	{
		return 1;
	}
	
	if (AngleRangeTo2PI(dAng - m_dendAngle) < _angSnap)
	{
		return 2;
	}
	
	int nTag = 0;
	if (m_dstartAngle < m_dendAngle)
	{
		if (dAng > m_dstartAngle && dAng < m_dendAngle)
		{
			nTag = 3;
		}
		else
		{
			nTag = 0;
		}
	}
	else  
	{
		if (dAng > m_dstartAngle || dAng < m_dendAngle)
		{
			nTag = 3;
		}
		else
		{
			nTag = 0;
		}
	}
	
	return nTag;
}

double* TGGeSector::NearAngle(double dAng) 
{
	double dEAng  = AngleRangeTo2PI(m_dendAngle - m_dstartAngle),
		dSrcAng = AngleRangeTo2PI(dAng - m_dstartAngle);
	
	if (dSrcAng < _angSnap)
	{
		return &(m_dstartAngle);
	}
	else if (RealEqual(dSrcAng, dEAng, _angSnap))
	{
		return &(m_dendAngle);
	}
	else if (dSrcAng < dEAng)			//弧内
	{ 
		if (dEAng - dSrcAng < dSrcAng)
		{
			return &(m_dendAngle);
		}
		else
		{
			return &(m_dstartAngle);
		}
	}
	else								 //弧外
	{
		if (dSrcAng - dEAng < 2.0 * PI - dSrcAng)
		{
			return &(m_dendAngle);
		}
		else 
		{
			return &(m_dstartAngle);
		}
	}
}

void TGGeSector::TransUCS(double dIncAngle)
{
	m_dstartAngle = AngleRangeTo2PI(m_dstartAngle + dIncAngle);
	m_dendAngle   = AngleRangeTo2PI(m_dendAngle + dIncAngle);
}

double TGGeSector::MidAngle() const
{
	return AngleRangeTo2PI(m_dstartAngle + Bulge() / 2.0);
}