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

TPGeDscPoint::TPGeDscPoint(double X,double Y,double Z) 
	: TGPoint(X,Y,Z),m_ptCount(1)
{

}

TPGeDscPoint::TPGeDscPoint(const TPGeDscPoint &pt) : TGPoint(pt),m_ptCount(1)
{

}

TPGeDscPoint::~TPGeDscPoint()
{
	
}


double TPGeDscPoint::GetValue() const
{
	return z;
}

void TPGeDscPoint::SetValue(double value)
{
	z = value;
}

long TPGeDscPoint::GetEdgeNum() const
{
	return allEdge.GetLength();
}

void TPGeDscPoint::AppendEdge(TPGeDscEdge*p)
{
	allEdge.AddTail(p);
}

void TPGeDscPoint::RemoveEdge(TPGeDscEdge*p)
{
	allEdge.FindAndDel(p);
}

TGPoint2D* TPGeDscPoint::CreatePoint()
{
	return new TGPoint2D(*this);
}

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

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

bool TPGeDscPoint::operator > (const TPGeDscPoint&pt) const
{
	double d = x - pt.x;
	if(UP_ZEROD(d))
	{
		return true;
	}
	else if(DOWN_ZEROD(d))
	{
		return false;
	}
	else
	{
		d = y - pt.y;
		if(UP_ZEROD(d))
		{
			return true;
		}
		else 
		{
			return false;
		}
	}		
}

bool TPGeDscPoint::operator < (const TPGeDscPoint&pt) const
{
	return pt > (*this);
}

void TPGeDscPoint::AppendValue(double value)
{
	double total = m_ptCount * GetValue() + value;
	m_ptCount++;
	SetValue(total / m_ptCount);
}

TPGeDscEdge* TPGeDscPoint::FindEdge(TPGeDscPoint*pPtTo)
{
	for(allEdge.MoveToFirst();!allEdge.IsOut();allEdge.MoveToNext())
	{
		TPGeDscEdge*pEdge = allEdge.GetCurData();

		if(pEdge->GetNextPoint(this) == pPtTo)
		{
			return pEdge;
		}
	}
	return NULL;
}

void TPGeDscPoint::Arrange()
{
	TPDList<TPGeDscEdge> buf;
	buf.Conbine(allEdge);
	buf.Arrange(CompareEdge);
	allEdge.Conbine(buf);
}

void TPGeDscPoint::MakeTriangle(TPDList<TPGeFitTriangle>&allTrg)
{
	if(allEdge.GetLength() < 2)
	{
		return;
	}

	if(allEdge.GetLength() == 2)
	{
		TPGeDscEdge*pEdge0=allEdge[0];
		TPGeDscEdge*pEdge1=allEdge[1];
		TPGeDscPoint *pPt0=pEdge0->GetNextPoint(this);
		TPGeDscPoint *pPt1=pEdge1->GetNextPoint(this);
		TPGeDscEdge*pEdge2=pPt0->FindEdge(pPt1);
		if(pEdge2 != NULL)
		{
			allTrg.AddTail(new TPGeFitTriangle(pEdge0,pEdge1,pEdge2));
		}
		return;
	}

	Arrange();

	allEdge.MoveToFirst();
	TPGeDscEdge*pEdge0 = allEdge.GetCurData();
	TPGeDscPoint *pPt0 = pEdge0->GetNextPoint(this);
	for(allEdge.MoveToNext();!allEdge.IsOut();allEdge.MoveToNext())
	{
		TPGeDscEdge*pEdge1 = allEdge.GetCurData();
		TPGeDscPoint *pPt1 = pEdge1->GetNextPoint(this);
		TPGeDscEdge*pEdge2 = pPt0->FindEdge(pPt1);
		if(pEdge2 != NULL)
		{
			allTrg.AddTail(new TPGeFitTriangle(pEdge0,pEdge1,pEdge2));
		}

		pPt0 = pPt1;
		pEdge0 = pEdge1;
	}
	TPGeDscEdge*pEdge1 = allEdge[0];
	TPGeDscPoint *pPt1 = pEdge1->GetNextPoint(this);
	TPGeDscEdge*pEdge2 = pPt0->FindEdge(pPt1);
	if(pEdge2 != NULL)
	{
		allTrg.AddTail(new TPGeFitTriangle(pEdge0,pEdge1,pEdge2));
	}
}

void TPGeDscPoint::RemoveAllEdge()
{
	for(allEdge.MoveToLast();!allEdge.IsOut();)
	{
		TPGeDscEdge*pEdge = allEdge.GetCurData();
		allEdge.DelCur();
		pEdge->GetNextPoint(this)->RemoveEdge(pEdge);
	}
}

void TPGeDscPoint::GetConnectPoint(TTable<TPGeDscPoint*> &connectPoint)
{
	for(allEdge.MoveToFirst();!allEdge.IsOut();allEdge.MoveToNext())
	{
		TPGeDscEdge*pEdge = allEdge.GetCurData();
		connectPoint << pEdge->GetNextPoint(this);
	}
}

TPGeDscPoint* TPGeDscPoint::FindNext(TPGeDscEdge*&pEdge)
{
	allEdge.FindTo(pEdge);
	long oldCur = allEdge.GetCur();
	allEdge.MoveToNext();
	if(allEdge.IsOut())
	{
		allEdge.MoveToFirst();
	}
	pEdge = allEdge.GetCurData();
	if(pEdge->Is(VISITED))
	{
		if(allEdge.GetLength() > 2)
		{
			allEdge.MoveTo(oldCur);
			allEdge.MoveToPre();
			if(allEdge.IsOut())
			{
				allEdge.MoveToLast();
			}
			pEdge = allEdge.GetCurData();
			if(pEdge->IsNot(VISITED))
			{
				pEdge->AddFlag(VISITED);
				return pEdge->GetNextPoint(this);
			}
		}
		return NULL;
	}
	else
	{
		pEdge->AddFlag(VISITED);
		return pEdge->GetNextPoint(this);
	}
}

TPGeDscPoint* TPGeDscPoint::GetFitPoint(double Z,double zSnap)
{
	if(allEdge.IsEmpty())
	{
		return NULL;
	}

	TPGeDscPoint *pPtFit = new TPGeDscPoint(x,y,Z);
	bool bUsed = false;

	if(EQUAL_ZERO(z - Z))
	{
		for(allEdge.MoveToFirst();!allEdge.IsOut();allEdge.MoveToNext())
		{
			TPGeDscEdge *pEdge = allEdge.GetCurData();
			TPGeDscPoint *pOtherPt = pEdge->GetNextPoint(this);
			if(!EQUAL_ZERO(pOtherPt->z - Z))
			{
				if(!EQUAL_ZERO(pOtherPt->z - zSnap))
				{
					pEdge->pPtFit = pPtFit;
					bUsed = true;
				}
			}
		}
		if(bUsed)
		{
			return pPtFit;
		}
		else
		{
			delete pPtFit;
			return NULL;
		}
	}

	if(EQUAL_ZERO(z-zSnap))
	{
		for(allEdge.MoveToFirst();!allEdge.IsOut();allEdge.MoveToNext())
		{
			TPGeDscEdge *pEdge = allEdge.GetCurData();
			TPGeDscPoint *pOtherPt = pEdge->GetNextPoint(this);
			if(!EQUAL_ZERO(pOtherPt->z - zSnap))
			{
				double dTotal = fabs(pOtherPt->z - z);
				double d1 = fabs(pOtherPt->z - Z), d2 = fabs(z - Z);
				if(EQUAL_ZERO(dTotal - d1 - d2))
				{
					pEdge->pPtFit = pPtFit;
					bUsed = true;
				}
			}
		}
		if(bUsed)
		{
			return pPtFit;
		}
		else
		{
			delete pPtFit;
			return NULL;
		}
	}

	return NULL;
}