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

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

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

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

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

XSector::~XSector()
{

}

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

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

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

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

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

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

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

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

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

int XSector::AngleFlag(double dAng) const
{
	if (CT_std_angle(dAng - m_dstartAngle) < _angSnap)
	{
		return 1;
	}
	
	if (CT_std_angle(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* XSector::NearAngle(double dAng) 
{
	double dEAng  = CT_std_angle(m_dendAngle - m_dstartAngle),
		dSrcAng = CT_std_angle(dAng - m_dstartAngle);
	
	if (dSrcAng < _angSnap)
	{
		return &(m_dstartAngle);
	}
	else if (CT_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 XSector::TransUCS(double dIncAngle)
{
	m_dstartAngle = CT_std_angle(m_dstartAngle + dIncAngle);
	m_dendAngle   = CT_std_angle(m_dendAngle + dIncAngle);
}

double XSector::MidAngle() const
{
	return CT_std_angle(m_dstartAngle + Bulge() / 2.0);
}