envi-code/SourceCode/Code2026/tg_shs/shs_subgeLib/TGMeshNode.cpp

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

TGMeshNode::TGMeshNode(const TGPoint&pt):TGPoint(pt)
{

}

TGMeshNode::~TGMeshNode()
{
	Clear();
}

void TGMeshNode::AppendEdge(TGMeshEdge* pEdge)
{
	m_lstEdge.AddTail(pEdge);
}

void TGMeshNode::Clear()
{
	TDualPtrList<TGMeshEdge*> temp;
	temp.Conbine(m_lstEdge);
}

TGMeshEdge* TGMeshNode::GetOnlyEdge()
{
	return m_lstEdge.IsEmpty() ? NULL : m_lstEdge[0];
}

void TGMeshNode::RemoveEdge(TGMeshEdge*pEdge)
{
	if (m_lstEdge.FindTo(pEdge))
	{
		m_lstEdge.FetchCur();
	}
}

bool TGMeshNode::IsEndNode() const
{
	return m_lstEdge.GetLength() == 1;
}

void TGMeshNode::Arrange()
{
	TDualPtrList<TGMeshEdge*> buf;
	buf.Conbine(m_lstEdge);

	if (buf.GetLength() == 1)
	{
		if (buf[0]->IsNot(DUP_EDGE))
		{
			m_lstEdge.AddTail(buf[0]);
		}
		return;
	}

	double radius = -1;
	for (buf.MoveToFirst();!buf.IsOut();buf.MoveToNext())
	{
		TGMeshEdge* pEdge = buf.GetCurData();
		if (pEdge->GetNode(1) == this)
		{
			double dist = Distance2D(*this,pEdge->GetCurve()->GetSamplePoint());
			if (radius < 0 || dist < radius)
			{
				radius = dist;
			}
		}
		else
		{
			TPGeCurve2D *pRevCurve = (TPGeCurve2D*)(pEdge->GetCurve()->Clone());
			pRevCurve->Reverse();
			double dist = Distance2D(*this,pRevCurve->GetSamplePoint());
			delete pRevCurve;
			if (radius < 0 || dist < radius)
			{
				radius = dist;
			}
		}
	}
	TPGeCircle2D circle(*this,radius);
	
	for (buf.MoveToFirst();!buf.IsOut();buf.MoveToNext())
	{
		TGMeshEdge* pEdge = buf.GetCurData(); 
		if (pEdge->Is(DUP_EDGE))
		{
			continue;
		}

		pEdge->AddFlag(DUP_EDGE);
		TGObjectList interList;
		if (circle.Intersect(*(pEdge->GetCurve()),interList))
		{
			double paMin = 1;
			for (interList.MoveToFirst();!interList.IsOut();interList.MoveToNext())
			{
				double pa = 1;
				pEdge->GetCurve()->Pt2Pa(interList.GetCurData()->GetSamplePoint(),pa);
				if (pEdge->GetNode(2) == this)
				{
					pa = 1 - pa;
				}
				if (pa < paMin)
				{
					paMin = pa;
				}
			}

			if (pEdge->GetNode(2) == this)
			{
				paMin = 1 - paMin;
			}
			TGPoint pt;
			pEdge->GetCurve()->Pa2Pt(paMin,pt);

			pEdge->m_fAngle = TGVector2D(pt,*this).GetAngle();
			if (m_lstEdge.SortIn(pEdge))
			{
				pEdge->RemoveFlag(DUP_EDGE);
			}
		}
	}
}

TGMeshEdge* TGMeshNode::FindNextEdge(TGMeshEdge* pEdgeFrom)
{
	if (IsEndNode())
	{
		return NULL;
	}
	
	m_lstEdge.FindTo(pEdgeFrom);
	m_lstEdge.MoveToNext();
	if (m_lstEdge.IsOut())
	{
		m_lstEdge.MoveToFirst();
	}

	return m_lstEdge.GetCurData();
}

TGMeshEdge* TGMeshNode::FindPreEdge(TGMeshEdge* pEdgeFrom)
{
	if (IsEndNode())
	{
		return NULL;
	}
	
	m_lstEdge.FindTo(pEdgeFrom);
	m_lstEdge.MoveToPre();
	if (m_lstEdge.IsOut())
	{
		m_lstEdge.MoveToLast();
	}
	return m_lstEdge.GetCurData();
}

TGMeshEdge* TGMeshNode::FindNextSDEdge(TGMeshEdge* pEdgeFrom)
{
	if (IsEndNode())
	{
		return NULL;
	}
	
	m_lstEdge.FindTo(pEdgeFrom);
	
	m_lstEdge.MoveToNext();

	if (m_lstEdge.IsOut())
	{
		m_lstEdge.MoveToFirst();
	}
	
	TGMeshEdge *pEdge = m_lstEdge.GetCurData();
	if (pEdge == pEdgeFrom || pEdge->GetNode(1) != this)
	{
		return NULL;
	}
	
	return pEdge;
}

TGMeshEdge* TGMeshNode::FindPreSDEdge(TGMeshEdge* pEdgeFrom)
{
	if (IsEndNode())
	{
		return NULL;
	}
	
	m_lstEdge.FindTo(pEdgeFrom);
	
	m_lstEdge.MoveToPre();
	if (m_lstEdge.IsOut())
	{
		m_lstEdge.MoveToLast();
	}
	
	TGMeshEdge *pEdge = m_lstEdge.GetCurData();
	if (pEdge == pEdgeFrom || pEdge->GetNode(2) != this)
	{
		return NULL;
	}
	
	return pEdge;
}