#include "StdAfx.h"
#include "Pad.h"


BOOL	CPadPoint::FindCrossX(CPadPoint &point, int cy, int &tx)// ÀÓÀÇÀÇ cy¿¡ ÇØ´çÇÏ´Â x, °ª ã±â
{
	if(point.y == y)
	{
		tx= point.x;
		return y == cy;
	}
	tx= x+ (cy- y)*(point.x- x)/(point.y- y);
	return TRUE;
}

BOOL CPadPoint::FindCrossY(CPadPoint &point, int cx, int &ty)// ÀÓÀÇÀÇ cX¿¡ ÇØ´çÇÏ´Â y °ª ã±â
{
	if(point.x == x)
	{
		ty= point.y;
		return x == cx;
	}
	ty= y+ (cx- x)*(point.y- y)/(point.x- x);
	return TRUE;
}

BOOL	CPadPoint::ChangeCrossHori(CPadPoint &point, int cy)// ÀÓÀÇÀÇ cy¿¡ ÇØ´çÇÏ´Â x, y ·Î °ª ¹Ù²Ù±â
{
	if(point.y == y)
	{
		x= point.x;
		y= point.y;
		return	y == cy;
	}
	x= x+ (cy- y)*(point.x- x)/(point.y- y);
	y= cy;
	return TRUE;
}
BOOL	CPadPoint::ChangeCrossVert(CPadPoint &point, int cx)// ÀÓÀÇÀÇ cx¿¡ ÇØ´çÇÏ´Â x, y ·Î °ª ¹Ù²Ù±â
{
	if(point.x == x)
	{
		x= point.x;
		y= point.y;
		return x == cx;
	}
	y= y+ (cx- x)*(point.y- y)/(point.x- x);
	x= cx;
	return TRUE;
}

void CPadPoligon::CalOutRect()
{
	CPadPoint *point;

	m_OutRect.SetRect(10000000, 10000000, -10000000, -10000000);

	for(int i= 0; i< m_nPadPoint; i++)
	{
		point= m_PadPoints+ i;
		if(point->x < m_OutRect.left)
			m_OutRect.left= point->x;
		if(point->y < m_OutRect.top)
			m_OutRect.top= point->y;
		if(m_OutRect.right < point->x)
			m_OutRect.right= point->x;
		if(m_OutRect.bottom < point->y)
			m_OutRect.bottom= point->y;
	}
}

void CPadPoligon::Find_Corner()
{
	int ip;
	int yMax= 1000000000;
	int iMax, xMax;
	int yMin= -1000000000;
	int iMin, xMin;

	if(m_nPadPoint < 3)
		return;

	if(! IsClockwise())
	{
		ReverseIndex(0);
	}

	for(ip= 0; ip < m_nPadPoint; ip++)
	{
		if(yMax > m_PadPoints[ip].y)// 
		{
			iMax= ip;
			yMax= m_PadPoints[ip].y;
			xMax= m_PadPoints[ip].x;
		}else if(yMax == m_PadPoints[ip].y)
		{
			if(m_PadPoints[ip].x < xMax)
			{
				iMax= ip;
				yMax= m_PadPoints[ip].y;
				xMax= m_PadPoints[ip].x;
			}
		}
		if(m_PadPoints[ip].y > yMin)
		{
			iMin= ip;
			yMin= m_PadPoints[ip].y;
			xMin= m_PadPoints[ip].x;
		}else if(yMin == m_PadPoints[ip].y)
		{
			if(m_PadPoints[ip].x > xMin)
			{
				iMin= ip;
				yMin= m_PadPoints[ip].y;
				xMin= m_PadPoints[ip].x;
			}
		}
	}

	m_iTopLeft= iMax;
	m_iBottomRight= iMin;

	CPadPoint *point;

	m_iTopRight= m_iTopLeft;
	for(ip= 0; ip < m_nPadPoint; ip++)
	{
		point= GetPadPoint_Round(m_iTopLeft+ ip);
		if(m_PadPoints[m_iTopLeft].y == point->y)
		{
			m_iTopRight= GetRoundIndex(m_iTopLeft+ ip);
		}else
		{
			break;
		}
	}

	m_iBottomLeft= m_iBottomRight;
	for(ip= 0; ip < m_nPadPoint; ip++)
	{
		point= GetPadPoint_Round(m_iBottomRight+ ip);
		if(m_PadPoints[m_iBottomRight].y == point->y)
		{
			m_iBottomLeft= GetRoundIndex(m_iBottomRight+ ip);
		}else
		{
			break;
		}
	}

	CalOutRect();
}

BOOL CPadPoligon::IsClockwise()
{
	if(m_nPadPoint < 3)	return FALSE;// °Ë»ç ¿µ¿ª ¾øÀ½, »ï°¢Çü ¸øÇØ...Àß¶ó¼­ ¿Í.

	CPadPoint pt1, pt2;
	int nCheck= m_nPadPoint- 2;
	int vr;
	for(int i= 0; i< nCheck; i++)
	{
		pt1= *GetPadPoint(i);
		pt2= *GetPadPoint(i+1);
		pt1.VectorTo(pt2);
		pt2.VectorTo(*GetPadPoint(i+2));
		vr= pt1.x*pt2.y- pt2.x*pt1.y;
		if(vr < 0)
			return FALSE;
	}

	return TRUE;


	pt1= *GetPadPoint(0);
	pt2= *GetPadPoint(1);
	pt1.VectorTo(pt2);
	pt2.VectorTo(*GetPadPoint(2));


	vr= pt1.x*pt2.y- pt2.x*pt1.y;

	if( vr >= 0)
	{
		return TRUE;
	}
	return FALSE;
}
BOOL CPadPoligon::Cut_TrapeziumVert(CTrapeziumStorage	*pTrapeziums)
{
	pTrapeziums->ResetTrapeziumCount();
	if(m_nPadPoint < 3)	return FALSE;// °Ë»ç ¿µ¿ª ¾øÀ½, »ï°¢Çü ¸øÇØ...Àß¶ó¼­ ¿Í.
	return TRUE;
}

BOOL CPadPoligon::Cut_TrapeziumHori(CTrapeziumStorage	*pTrapeziums)
{
	pTrapeziums->ResetTrapeziumCount();
	if(m_nPadPoint < 3)	return FALSE;// °Ë»ç ¿µ¿ª ¾øÀ½, »ï°¢Çü ¸øÇØ...Àß¶ó¼­ ¿Í.

	if(m_nPadPoint == 3)
	{
		int			i,j,nCount;
		CPadPoint	point;
		for(i=0;i<m_nPadPoint;i++)
		{
			nCount = 0;
			point = m_PadPoints[i];
			for(j=0;j<m_nPadPoint;j++)
			{
				if(point.x == m_PadPoints[j].x && point.y == m_PadPoints[j].y)
					nCount++;
			}

			if(nCount >= 2)
				return FALSE;
		}
	}

	// if(nPoint == 4)	// »ç´Ù¸®²Ã ȤÀº rect ³×~~

	int		iLeft, iRight;
	CPadPoint TopLeft, TopRight;

	TopLeft= m_PadPoints[m_iTopLeft];
	TopRight= m_PadPoints[m_iTopRight];


	iLeft= GetPreIndex(m_iTopLeft);//(m_iTopLeft+ m_nPadPoint- 1)%m_nPadPoint;
	iRight= GetNextIndex(m_iTopRight);//(m_iTopRight+ 1)%m_nPadPoint;

	int endLeft, endRight;
	endLeft= GetPreIndex(m_iBottomLeft);
	endRight= GetNextIndex(m_iBottomRight);

	while(!(iLeft == endLeft && iRight == endRight))
	{
		pTrapeziums->OpenTrap(TopLeft, TopRight);
		if(m_PadPoints[iLeft].y < m_PadPoints[iRight].y)
		{
			TopLeft= m_PadPoints[iLeft];
			TopRight.ChangeCrossHori(m_PadPoints[iRight], TopLeft.y);
			pTrapeziums->CloseTrap(TopRight, TopLeft);
			//iLeft--;
			iLeft= GetPreIndex(iLeft);
		}else if(m_PadPoints[iLeft].y > m_PadPoints[iRight].y)
		{
			TopRight= m_PadPoints[iRight];
			TopLeft.ChangeCrossHori(m_PadPoints[iLeft], TopRight.y);
			pTrapeziums->CloseTrap(TopRight, TopLeft);
			//iRight++;
			iRight= GetNextIndex(iRight);
		}else // if( == )
		{
			TopLeft= m_PadPoints[iLeft];
			TopRight= m_PadPoints[iRight];
			pTrapeziums->CloseTrap(TopRight, TopLeft);
			//iLeft--;
			//iRight++;
			iLeft= GetPreIndex(iLeft);
			iRight= GetNextIndex(iRight);
		}
	}
	return TRUE;
}

void CPadPoligon::Cut_Margin(int left, int right, CPadPoligon &PadPoligon)
{
	int i;
	CPadPoint *pt1, *pt2;
	CPadPoint	point;
	int iPoint= 0;
	PadPoligon.ResetPoligon();

//	if(left > m_OutRect.left && left < m_OutRect.right)
	{
		for(i= 0; i< m_nPadPoint; i++)
		{
			pt1= GetPadPoint_Round(i);//m_PadPoints+ i;
			pt2= GetPadPoint_Round(i+ 1);//m_PadPoints+ (i+1)%m_nPadPoint;

			if(pt1->x < left)
			{
				if(left < pt2->x)
				{
					point= *pt1;
					point.ChangeCrossVert(*pt2, left);
					PadPoligon.AddPoint(point);
				}
				if(right < pt2->x)
				{
					point= *pt1;
					point.ChangeCrossVert(*pt2, right);
					PadPoligon.AddPoint(point);
				}
			}else if(right < pt1->x)
			{
				if(pt2->x < right)
				{
					point= *pt1;
					point.ChangeCrossVert(*pt2, right);
					PadPoligon.AddPoint(point);
				}
				if(pt2->x < left)
				{
					point= *pt1;
					point.ChangeCrossVert(*pt2, left);
					PadPoligon.AddPoint(point);
				}
			}else// if(left <= pt1->x && pt1->x < right)
			{
				PadPoligon.AddPoint(*pt1);
				if(pt2->x < left)
				{
					point= *pt1;
					point.ChangeCrossVert(*pt2, left);
					PadPoligon.AddPoint(point);
				}else if(right < pt2->x)
				{
					point= *pt1;
					point.ChangeCrossVert(*pt2, right);
					PadPoligon.AddPoint(point);
				}
			}
		}
	}
}

void CPadPoligon::Test()
{
	AddPoint(100, 150);
	AddPoint(400, 30);
	AddPoint(600, 100);
//	AddPoint(780, 200);
	AddPoint(800, 200);
	AddPoint(500, 400);	// bottom right
	AddPoint(400, 400);	// bottom left
	AddPoint(300, 400);	// bottom left
	AddPoint(200, 350);
	AddPoint(100, 200);

}

void CPadPoligon::OffsetPlus(int dx, int dy)
{
	int i;
	for(i=0; i< m_nPadPoint; i++)
	{
		m_PadPoints[i].x= m_PadPoints[i].x+ dx;
		m_PadPoints[i].y= m_PadPoints[i].y+ dy;
	}
}

void CPadPoligon::OffsetPlusIndex(int start)
{
	int i;
	CPadPoligon poligon= *this;
	for(i=0; i< m_nPadPoint; i++)
	{
		m_PadPoints[i]= *poligon.GetPadPoint_Round(start+ i);//poligon.m_PadPoints[GetPreIndex(m_nPadPoint+ test-i)];
	}
}
void CPadPoligon::ReverseIndex(int start)
{
	int i;
	CPadPoligon poligon= *this;
	for(i=0; i< m_nPadPoint; i++)
	{
		m_PadPoints[i]= *poligon.GetPadPoint_Round(m_nPadPoint+ start- i);//poligon.m_PadPoints[GetPreIndex(m_nPadPoint+ test-i)];
	}
}