//-------------------------------------------------------------------------------------------------------+
// Copyright (C), 1998-2007, Beijing Tangent Software Co. Ltd.
// = FileName	:   TGMeshEdge3D Àà
// = Version	:   ver2.0
// = Author		:   wlw
// = CreateDate	:   2002-09-09
// = Description:   TGMeshEdge3D ¶¨Òå
// = Maintainers: 
//                  
//-------------------------------------------------------------------------------------------------------+
#include "StdAfx.h"
#include "TGMeshEdge3D.h"
#include "TGMeshNode3D.h"
#include "TPGeCurve3D.h"
#include "TPGeGLine3D.h"
#include "TGMesh3D.h"

TGMeshEdge3D::TGMeshEdge3D(const TPGeCurve3D* pCurve,TGMeshNode3D* pNode1,TGMeshNode3D*pNode2)
	: m_pCurve(pCurve),m_pNode1(pNode1),m_pNode2(pNode2),m_pMesh1(NULL),m_pMesh2(NULL)
{
	if (m_pNode1 != NULL)
	{
		m_pNode1->AppendEdge(this);
	}

	if (m_pNode2 != NULL)
	{
		m_pNode2->AppendEdge(this);
	}
}
TGMeshEdge3D::~TGMeshEdge3D()
{
	
}


const TPGeCurve3D* TGMeshEdge3D::GetCurve() const
{
	return m_pCurve;
}

const TGMeshNode3D* TGMeshEdge3D::GetNode(int i/*=1*/) const
{
	return i == 1 ? m_pNode1 : m_pNode2;
}

bool TGMeshEdge3D::IsLine() const
{
	return IS_CLASS(m_pCurve,TPGeGLine3D);
}

TGMeshNode3D* TGMeshEdge3D::GetNextNode(TGMeshNode3D*pNode) const
{
	return pNode == m_pNode1 ? m_pNode2 : m_pNode1;
}

bool TGMeshEdge3D::operator > (const TGMeshEdge3D&edge) const
{
	return false;
}

bool TGMeshEdge3D::operator < (const TGMeshEdge3D&edge) const
{
	return edge > *this;
}

TGMeshEdge3D* TGMeshEdge3D::FindNextEdge(TGMeshNode3D* &pNodeStart,TGMesh3D*pMesh)
{
	if (pNodeStart == m_pNode1)
	{
		AddFlag(VISITED12);
		m_pMesh1 = pMesh;
		pNodeStart = m_pNode2;
	}
	else
	{
		AddFlag(VISITED21);
		m_pMesh2 = pMesh;
		pNodeStart = m_pNode1;
	}
	if (pNodeStart == NULL)
	{
		return NULL;
	}
	return pNodeStart->FindNextEdge(this);
}

TGMeshEdge3D* TGMeshEdge3D::FindPreEdge(TGMeshNode3D* &pNodeStart,TGMesh3D*pMesh)
{
	if (pNodeStart == m_pNode1)
	{
		AddFlag(VISITED21);
		m_pMesh2 = pMesh;
		pNodeStart = m_pNode2;
	}
	else
	{
		m_pMesh1 = pMesh;
		AddFlag(VISITED12);
		pNodeStart = m_pNode1;
	}
	if (pNodeStart == NULL)
	{
		return NULL;
	}
	return pNodeStart->FindPreEdge(this);
}

TGMeshEdge3D* TGMeshEdge3D::FindNextSDEdge(TGMesh3D*pMesh)
{
	AddFlag(VISITED12);
	m_pMesh1 = pMesh;


	if (m_pNode2 == NULL)
	{
		return NULL;
	}
	return m_pNode2->FindNextSDEdge(this);
}

TGMeshEdge3D* TGMeshEdge3D::FindPreSDEdge(TGMesh3D*pMesh)
{
	AddFlag(VISITED12);
	m_pMesh1 = pMesh;

	if (m_pNode1 == NULL)
	{
		return NULL;
	}
	return m_pNode1->FindPreSDEdge(this);
}

TGMesh3D* TGMeshEdge3D::FindMesh(int i)
{
	TGMesh3D *pMesh = new TGMesh3D;
	TGMeshNode3D* pNodeStart;
	if (i == 1)
	{
		pNodeStart = m_pNode1;
		m_pMesh1 = pMesh;
	}
	else
	{
		pNodeStart = m_pNode2;
		m_pMesh2 = pMesh;
	}

	TGMeshEdge3D*pEdge = this;
	do
	{
		pMesh->AddTail(pEdge);
		pEdge = pEdge->FindNextEdge(pNodeStart,pMesh);
	}
	while(pEdge != this&&pEdge != NULL);
	if (pEdge == NULL)
	{
		pNodeStart = i == 1 ? m_pNode2 : m_pNode1;
		TGMeshEdge3D*pEdge = this;
		while(true)
		{
			pEdge = pEdge->FindPreEdge(pNodeStart,pMesh);
			if (pEdge == NULL)
			{
				break;
			}
			pMesh->InsertHead(pEdge);
		}
	}

	return pMesh;
}
TGMesh3D* TGMeshEdge3D::FindSDMesh()
{
	TGMesh3D *pMesh = new TGMesh3D;
	m_pMesh1 = pMesh;

	TGMeshEdge3D*pEdge = this;
	do
	{
		pMesh->AddTail(pEdge);
		pEdge = pEdge->FindNextSDEdge(pMesh);
	}
	while(pEdge != this && pEdge != NULL);

	if (pEdge == NULL)
	{
		TGMeshEdge3D*pEdge = this;
		while(true)
		{
			pEdge = pEdge->FindPreSDEdge(pMesh);
			if (pEdge == NULL)
			{
				break;
			}
			pMesh->InsertHead(pEdge);
		}
	}

	return pMesh;
}