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

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

TPGeCurveMesh3D::TPGeCurveMesh3D()
{

}

TPGeCurveMesh3D::~TPGeCurveMesh3D()
{
	
}


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

bool TPGeCurveMesh3D::operator < (const TPGeCurveMesh3D&) const
{
	return false;
}

TGMeshNode3D* TPGeCurveMesh3D::FindOrAddNode(const TGPoint&pt)
{
	TGMeshNode3D*pNode = new TGMeshNode3D(pt);
	if(!m_allNode.SortIn(pNode))
	{
		delete pNode;
	}
	return m_allNode.GetCurData();
}

TPGeCurveMesh3D::TPGeCurveMesh3D(const TGObjectList&buf,bool bOnlyClose)
{
	for(TGObject*const*p = buf.GetFirst(); p != NULL; p = buf.GetNext(p))
	{
		AppendCurve((const TPGeCurve3D*)(*p));
	}

	for(m_allNode.MoveToFirst(); !m_allNode.IsOut(); m_allNode.MoveToNext())
	{
		m_allNode.GetCurData()->Arrange();
	}

	for(m_allEdge.MoveToFirst(); !m_allEdge.IsOut(); m_allEdge.MoveToNext())
	{
		if(m_allEdge.GetCurData()->Is(DUP_EDGE))
		{
			TGMeshEdge3D *pEdge = m_allEdge.GetCurData();
			TGMeshNode3D* pNode1 = (TGMeshNode3D*)pEdge->GetNode(1);
			TGMeshNode3D* pNode2 = (TGMeshNode3D*)pEdge->GetNode(2);
			if(pNode1 != NULL)
			{
				pNode1->RemoveEdge(pEdge);
			}
			if(pNode2 != NULL)
			{
				pNode2->RemoveEdge(pEdge);
			}
			m_allEdge.DelCur();
		}
	}

	if(bOnlyClose)
	{
		RemoveOpenEdge();
	}
}

void TPGeCurveMesh3D::AppendCurve(const TPGeCurve3D*pCurve)
{
	if((!pCurve->IsFinite(true) && !pCurve->IsFinite(false)) || pCurve->IsClosed())
	{
		return;
	}

	TGPoint pt1,pt2;
	pCurve->GetStartPoint(pt1);
	pCurve->GetEndPoint(pt2);
	m_allEdge.AddTail(new TGMeshEdge3D(pCurve,pCurve->IsFinite(true) ? FindOrAddNode(pt1) : NULL,
									  pCurve->IsFinite(false) ? FindOrAddNode(pt2):NULL));
}

void TPGeCurveMesh3D::RemoveOpenEdge()
{
	TListQuene<TGMeshNode3D*> quene;
	for(m_allNode.MoveToFirst(); !m_allNode.IsOut(); m_allNode.MoveToNext())
	{
		if(m_allNode.GetCurData()->IsEndNode())
		{
			quene.EnQuene(m_allNode.GetCurData());
		}
	}

	while(!quene.IsEmpty())
	{
		TGMeshNode3D*pNode;
		quene.DeQuene(pNode);
		TGMeshEdge3D*pEdge = pNode->GetOnlyEdge();
		if(pEdge == NULL)
		{
			continue;
		}

		pNode->Clear();
		pNode = pEdge->GetNextNode(pNode);
		if(pNode != NULL)
		{
			pNode->RemoveEdge(pEdge);
			if(pNode->IsEndNode())
			{
				quene.EnQuene(pNode);
			}
		}

		pEdge->AddFlag(INVALID_EDGE);
	}
	
	for(m_allEdge.MoveToFirst();!m_allEdge.IsOut();m_allEdge.MoveToNext())
	{
		if(m_allEdge.GetCurData()->Is(INVALID_EDGE))
		{
			m_allEdge.DelCur();
		}
	}
}

void TPGeCurveMesh3D::FindAllMesh()
{
	for(m_allEdge.MoveToFirst();!m_allEdge.IsOut();m_allEdge.MoveToNext())
	{
		TGMeshEdge3D* pEdge = m_allEdge.GetCurData();
		if(pEdge->IsNot(VISITED12))
		{
			TGMesh3D* pMesh = pEdge->FindMesh(1);
			if(pMesh != NULL)
			{
				pMesh->ExplodeSelfCross(m_allMesh);
				m_allMesh << pMesh;
			}
		}
		if(pEdge->IsNot(VISITED21))
		{
			TGMesh3D* pMesh = pEdge->FindMesh(2);
			if(pMesh != NULL)
			{
				pMesh->ExplodeSelfCross(m_allMesh);
				m_allMesh << pMesh;
			}
		}
	}
}

void TPGeCurveMesh3D::FindAllSDMesh()
{
	for(m_allEdge.MoveToFirst();!m_allEdge.IsOut();m_allEdge.MoveToNext())
	{
		TGMeshEdge3D* pEdge = m_allEdge.GetCurData();
		if(pEdge->IsNot(VISITED12))
		{
			TGMesh3D* pMesh = pEdge->FindSDMesh();
			if(pMesh != NULL)
			{
				pMesh->ExplodeSelfCross(m_allMesh);
				m_allMesh << pMesh;
			}
		}	
	}
}

void TPGeCurveMesh3D::Explode(TPDList<TPGeCurveMesh3D> &lstChildMesh)
{
	for(m_allEdge.MoveToFirst();!m_allEdge.IsOut();m_allEdge.MoveToNext())
	{
		TGMeshEdge3D *pEdge = m_allEdge.GetCurData();
		if(pEdge->IsNot(VISITED))
		{
			TPGeCurveMesh3D *pChild = new TPGeCurveMesh3D;
			TListQuene<TGMeshEdge3D*> quene;
			pEdge->AddFlag(VISITED);
			quene.EnQuene(pEdge);

			while(!quene.IsEmpty())
			{
				quene.DeQuene(pEdge);
				pChild->m_allEdge << pEdge;
				if(pEdge->m_pNode1 != NULL)
				{
					pChild->m_allNode.SortIn(pEdge->m_pNode1);
				}
				if(pEdge->m_pNode2 != NULL)
				{
					pChild->m_allNode.SortIn(pEdge->m_pNode2);
				}
				if(pEdge->m_pMesh1 != NULL)
				{
					pChild->m_allMesh.FindOrAddTail(pEdge->m_pMesh1);
				}
				if(pEdge->m_pMesh2 != NULL)
				{
					pChild->m_allMesh.FindOrAddTail(pEdge->m_pMesh2);
				}

				TGMeshNode3D *pNode = pEdge->m_pNode1;
				if(pNode != NULL)
				{
					for(pNode->m_lstEdge.MoveToFirst();!pNode->m_lstEdge.IsOut();pNode->m_lstEdge.MoveToNext())
					{
						TGMeshEdge3D *pEdge1 = pNode->m_lstEdge.GetCurData();
						if(pEdge1->IsNot(VISITED))
						{
							pEdge1->AddFlag(VISITED);
							quene.EnQuene(pEdge1);
						}
					}
				}

				pNode = pEdge->m_pNode2;
				if(pNode != NULL)
				{
					for(pNode->m_lstEdge.MoveToFirst();!pNode->m_lstEdge.IsOut();pNode->m_lstEdge.MoveToNext())
					{
						TGMeshEdge3D *pEdge1 = pNode->m_lstEdge.GetCurData();
						if(pEdge1->IsNot(VISITED))
						{
							pEdge1->AddFlag(VISITED);
							quene.EnQuene(pEdge1);
						}
					}
				}
			}

			lstChildMesh << pChild;
		}
	}

	for(m_allEdge.MoveToFirst();!m_allEdge.IsOut();m_allEdge.MoveToNext())
	{
		TGMeshEdge3D *pEdge = m_allEdge.GetCurData();
		pEdge->RemoveFlag(VISITED);
		m_allEdge.SetCurData(NULL);
	}
	m_allEdge.Clear();

	for(m_allNode.MoveToFirst();!m_allNode.IsOut();m_allNode.MoveToNext())
	{
		if(m_allNode.GetCurData()->m_lstEdge.GetLength() > 0)
		{
			m_allNode.FetchCur();
		}
	}

	for(m_allMesh.MoveToFirst();!m_allMesh.IsOut();m_allMesh.MoveToNext())
	{
		m_allMesh.SetCurData(NULL);
	}
	m_allMesh.Clear();
}