#include "StdAfx.h"
#include "GeSector.h"
#include "globalFunc.h"

using namespace GlobalFunc;

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

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

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

GeSector::GeSector(const EntitySet & ent)
{
	EntitySet 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;
	}
}

GeSector::~GeSector()
{

}

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

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

int GeSector::operator ! () const
{
	return Bulge() < g_DimOption::instance()._angSnap;
}

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

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

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

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

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

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

int GeSector::AngleFlag(double dAng) const
{
	if (AngleRangeTo2PI(dAng - m_dstartAngle) < g_DimOption::instance()._angSnap)
	{
		return 1;
	}
	
	if (AngleRangeTo2PI(dAng - m_dendAngle) < g_DimOption::instance()._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* GeSector::NearAngle(double dAng) 
{
	double dEAng  = AngleRangeTo2PI(m_dendAngle - m_dstartAngle),
		dSrcAng = AngleRangeTo2PI(dAng - m_dstartAngle);
	
	if (dSrcAng < g_DimOption::instance()._angSnap)
	{
		return &(m_dstartAngle);
	}
	else if (RealEqual(dSrcAng, dEAng, g_DimOption::instance()._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 GeSector::TransUCS(double dIncAngle)
{
	m_dstartAngle = AngleRangeTo2PI(m_dstartAngle + dIncAngle);
	m_dendAngle   = AngleRangeTo2PI(m_dendAngle + dIncAngle);
}

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