tin.cpp

这是我自己写的从数据库中读出数据

// Tin.cpp: implementation of the CTin class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Mine.h"
#include "Tin.h"

#include "MineDoc.h"

#include "math.h"
#include <gl\gl.h>
#include <gl\glaux.h>


#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif


extern CNode *g_pNodeHead;
extern CEdge *g_pEdgeHead;
extern CPolygon *g_pPolygonHead;

//extern CNode *g_pOutsideNodeHead;
extern float g_fXMin;
extern float g_fXMax;
extern float g_fYMin;
extern float g_fYMax;

extern float g_fXTranslation;
extern float g_fYTranslation;
extern float g_fZTranslation;
extern float g_fXZoom;
extern float g_fYZoom;
extern float g_fZZoom;
extern float g_fSize;

extern int g_nMaxLayer;
//extern int g_nCurrentLayer;
extern float bright;
extern bool g_bInit;
//extern	int		m_solidminebody1;
//extern	int		m_solidtunnel1;
//extern	int		m_dispalytunnel1;
//extern	int		m_displayminebody1;
 extern   CPoint m_ptOrigin;
extern	CPoint m_ptEnd;



//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CTin::CTin()
{
	m_nCurrentLayer = 1;

}

CTin::~CTin()
{

}

void CTin::InitTin()
{
	float lenth,width;//扩展值
	CNode *node;
	//寻找TIN网边界值
	node = g_pNodeHead->next;
	while (node != g_pNodeHead)
	{
		if (node->m_bTinNode)
		{
			
				if (node->m_nSurfaceLayer == 1)//第一层
				{
				  xMin = xMax = node->x;
				  yMin = yMax = node->y;
				  break;
				}
			
		}
		node = node->next;
	}

	while (node != g_pNodeHead)
	{
		if (node->m_bTinNode)
		{
			
				if (node->m_nSurfaceLayer == 1)//第一层
				{
				   if (node->x < xMin) xMin = node->x;
				   if (node->x > xMax) xMax = node->x;
				   if (node->y < yMin) yMin = node->y;
				   if (node->y > yMax) yMax = node->y;
				}
		}
		
		node = node->next;
	}

	g_fXMin = xMin;
	g_fXMax = xMax;
	g_fYMin = yMin;
	g_fYMax = yMax;
	
	g_fXTranslation = (xMin+xMax)/2;
	g_fYTranslation = (yMin+yMax)/2;
	g_fXZoom = fabs((xMax-xMin)/1000);
	g_fYZoom = fabs((yMax-yMin)/800);
//////////////////////////////////////////
//平移，缩放对话框
	//CDialogPanZoom dlg;
	//dlg.ChangeData();
	//dlg.DoModal();
/////////////////////////////////////////
//	if (!g_bInit)
//	{
//		node = g_pNodeHead->next;
//		while (node != g_pNodeHead)
//		{
//			if (node->m_bTinNode)
//			{
//				node->x = (node->x - g_fXTranslation)/7+700;
//				node->y = (node->y - g_fYTranslation)/7+400;
//				node->z = (node->z - g_fZTranslation)/g_fZZoom; 
//			}
//			
//			node = node->next;
//		}
//		g_bInit = true;
//	}
//	xMin = (xMin - g_fXTranslation)/g_fXZoom;
//	xMax = (xMax - g_fXTranslation)/g_fXZoom;
//	yMin = (yMin - g_fYTranslation)/g_fYZoom;
//	yMax = (yMax - g_fYTranslation)/g_fYZoom;

	//外轮廓增加10％
	lenth=float((xMax-xMin)/10.0);
	width=float((yMax-yMin)/10.0);
	xMin-=lenth;
	xMax+=lenth;
	yMin-=width;
	yMax+=width;
	//计算实际容差值
	size = g_fSize*sqrt(g_fXZoom*g_fYZoom);

}

void CTin::InitTin2()
{
	//所新添加的四个顶点，五条三角形边和两个三角形
	CNode *node1,*node2,*node3,*node4;
	CEdge *edge0,*edge1,*edge2,*edge3,*edge4;
	CPolygon *triangle1,*triangle2;
	CEntity entity;
	//所有三角形顶点存储都是按逆时针方向存储的
	//添加控制点
	node1 = entity.InitNode();
	node1->m_nNodeID = -1;
	node1->x = xMin;
	node1->y = yMin;
	node1->m_nSurfaceLayer = m_nCurrentLayer;

	node2 = entity.InitNode();
	node2->m_nNodeID = -2;
	node2->x = xMax;
	node2->y = yMin;
	node2->m_nSurfaceLayer = m_nCurrentLayer;

	node3 = entity.InitNode();
	node3->m_nNodeID = -3;
	node3->x = xMax;
	node3->y = yMax;
	node3->m_nSurfaceLayer = m_nCurrentLayer;

	node4 = entity.InitNode();
	node4->m_nNodeID = -4;
	node4->x = xMin;
	node4->y = yMax;
	node4->m_nSurfaceLayer = m_nCurrentLayer;
	//添加控制线
	edge0 = entity.InitEdge();
	edge0->m_nEdgeID = -1;
	edge0->m_pNode[0] = node1;
	edge0->m_pNode[1] = node2;
	edge0->m_nSurfaceLayer = m_nCurrentLayer;
	edge0->m_nEdgeType = 1;

	edge1 = entity.InitEdge();
	edge1->m_nEdgeID = -2;
	edge1->m_pNode[0] = node2;
	edge1->m_pNode[1] = node3;
	edge1->m_nSurfaceLayer = m_nCurrentLayer;
	edge1->m_nEdgeType = 1;

	edge2 = entity.InitEdge();
	edge2->m_nEdgeID = -3;
	edge2->m_pNode[0] = node3;
	edge2->m_pNode[1] = node4;
	edge2->m_nSurfaceLayer = m_nCurrentLayer;
	edge2->m_nEdgeType = 1;

	edge3 = entity.InitEdge();
	edge3->m_nEdgeID = -4;
	edge3->m_pNode[0] = node4;
	edge3->m_pNode[1] = node1;
	edge3->m_nSurfaceLayer = m_nCurrentLayer;
	edge3->m_nEdgeType = 1;

	edge4 = entity.InitEdge();
	edge4->m_pNode[0] = node2;
	edge4->m_pNode[1] = node4;
	edge4->m_nSurfaceLayer = m_nCurrentLayer;
	edge4->m_nEdgeType = 1;
	//添加控制面
	triangle1 = entity.InitPolygon();
	triangle1->m_nPolygonID = -1;
	triangle1->m_nConsistNodeNum = 3;
	triangle1->m_pConsistNodes[0] = node1;//点边相对
	triangle1->m_pConsistNodes[1] = node2;
	triangle1->m_pConsistNodes[2] = node4;
	triangle1->m_pConsistEdges[0] = edge4;
	triangle1->m_pConsistEdges[1] = edge3;
	triangle1->m_pConsistEdges[2] = edge0;
	triangle1->m_nSurfaceLayer = m_nCurrentLayer;
//	triangle1->m_nPolygonType = 6;
     

	triangle2 = entity.InitPolygon();
	triangle2->m_nPolygonID = -2;
	triangle2->m_nConsistNodeNum = 3;
	triangle2->m_pConsistNodes[0] = node2;
	triangle2->m_pConsistNodes[1] = node3;
	triangle2->m_pConsistNodes[2] = node4;
	triangle2->m_pConsistEdges[0] = edge2;
	triangle2->m_pConsistEdges[1] = edge4;
	triangle2->m_pConsistEdges[2] = edge1;
	triangle2->m_nSurfaceLayer = m_nCurrentLayer;
//	triangle2->m_nPolygonType  = 6;
	 
	//左右三角形
	edge0->m_pNeighbourTinTri[0] = triangle1;
	edge1->m_pNeighbourTinTri[0] = triangle2;
	edge2->m_pNeighbourTinTri[0] = triangle2;
	edge3->m_pNeighbourTinTri[0] = triangle1;
	edge4->m_pNeighbourTinTri[0] = triangle1;
	edge4->m_pNeighbourTinTri[1] = triangle2;

}

void CTin::CreateTin()
{
	InitTin();
	CNode *node;
	CPolygon *loc;

	//多层TIN构模
	//多层TIN构模
	while (m_nCurrentLayer < g_nMaxLayer+1)
	{
		InitTin2();
		node = g_pNodeHead->next;
		while (node != g_pNodeHead)
		{
			if (node->m_bTinNode)
			{
			
					if (node->m_nSurfaceLayer == m_nCurrentLayer)
				{
					if (node->m_nNodeID>=0)
					{
						
						loc = NULL;
						if (!(loc = LocationNode(node)))
							return;
						if (Lenth2(node,loc->m_pConsistNodes[0])>size*size
							&& Lenth2(node,loc->m_pConsistNodes[1])>size*size
							&& Lenth2(node,loc->m_pConsistNodes[2])>size*size)
							InsertNode(node,loc);
					}
				}
				
			 }
			node = node->next;
		}
		
		Discard();
		m_nCurrentLayer++;
	}
}

CPolygon* CTin::LocationNode(CNode *pNode)
{
		CPolygon* triangle;
	triangle = g_pPolygonHead->next;

	while (triangle != g_pPolygonHead)
	{
		if (triangle->m_bTinPolygon)
		{
			
				if (InTinTriangle(pNode,triangle)) 
				{
					return triangle;
				}
		}
		triangle = triangle->next;		
	}
	return NULL;

}

double CTin::Lenth2(CNode *pNode1, CNode *pNode2)
{
	return
		(pNode1->x-pNode2->x)*(pNode1->x-pNode2->x)+
		(pNode1->y-pNode2->y)*(pNode1->y-pNode2->y);

}

void CTin::InsertNode(CNode *pNode, CPolygon *pTinTriangle)//插入新节点
{
	CEdge *edge[4],*edge2[4];
	CPolygon *polygon,*polygon2,*polygon3;
	int i,ie,ie2,polygon1Id,polygon2Id;
	CEntity entity;

	ie = InTinTriangle(pNode,pTinTriangle);
	if (ie == 4)
	{
		for (i=0;i<3;i++)
		{
			edge[i] = entity.InitEdge();
			//edge代表新生成的内边，edge2代表原三角形的边
			edge[i]->m_pNode[0] = pNode;
			edge[i]->m_pNode[1] = pTinTriangle->m_pConsistNodes[i];
			edge[i]->m_nSurfaceLayer = m_nCurrentLayer;
			edge[i]->m_nEdgeType = 1;
			edge2[i] = pTinTriangle->m_pConsistEdges[i];			
		}
		polygon1Id = pTinTriangle->m_nPolygonID;
		//不用删除原有三角形，把它赋值成一个新的三角形
		pTinTriangle->m_pConsistNodes[0] = pNode;
		pTinTriangle->m_pConsistNodes[1] = edge[1]->m_pNode[1];
		pTinTriangle->m_pConsistNodes[2] = edge[2]->m_pNode[1];
		pTinTriangle->m_pConsistEdges[0] = edge2[0];
		pTinTriangle->m_pConsistEdges[1] = edge[2];
		pTinTriangle->m_pConsistEdges[2] = edge[1];

		polygon2 = entity.InitPolygon();
		polygon2->m_pConsistNodes[0] = pNode;
		polygon2->m_pConsistNodes[1] = edge[2]->m_pNode[1];
		polygon2->m_pConsistNodes[2] = edge[0]->m_pNode[1];
		polygon2->m_pConsistEdges[0] = edge2[1];
		polygon2->m_pConsistEdges[1] = edge[0];
		polygon2->m_pConsistEdges[2] = edge[2];
		polygon2->m_nSurfaceLayer = m_nCurrentLayer;
		polygon2->m_nConsistNodeNum = 3;
	//	polygon2->m_nPolygonType = 6;
       polygon2->m_bVisible=true;
		
		polygon3 = entity.InitPolygon();
		polygon3->m_pConsistNodes[0] = pNode;
		polygon3->m_pConsistNodes[1] = edge[0]->m_pNode[1];
		polygon3->m_pConsistNodes[2] = edge[1]->m_pNode[1];
		polygon3->m_pConsistEdges[0] = edge2[2];
		polygon3->m_pConsistEdges[1] = edge[1];
		polygon3->m_pConsistEdges[2] = edge[0];
		polygon3->m_nSurfaceLayer = m_nCurrentLayer;
		polygon3->m_nConsistNodeNum = 3;
		//polygon3->m_nPolygonType = 6;
        polygon3->m_bVisible=true;
		edge[0]->m_pNeighbourTinTri[0] = polygon2;
		edge[0]->m_pNeighbourTinTri[1] = polygon3;
		edge[1]->m_pNeighbourTinTri[0] = polygon3;
		edge[1]->m_pNeighbourTinTri[1] = pTinTriangle;
		edge[2]->m_pNeighbourTinTri[0] = pTinTriangle;
		edge[2]->m_pNeighbourTinTri[1] = polygon2;

		if(edge2[1]->m_nEdgeID<0)
		{
			edge2[1]->m_pNeighbourTinTri[0] = polygon2;
		}
		else 
		{
			if (edge2[1]->m_pNeighbourTinTri[0]->m_nPolygonID == polygon1Id)
			{
				edge2[1]->m_pNeighbourTinTri[0] = polygon2;
			}
			else
			{
				edge2[1]->m_pNeighbourTinTri[1] = polygon2;
			}
		}

		if (edge2[2]->m_nEdgeID<0)
		{
			edge2[2]->m_pNeighbourTinTri[0] = polygon3;
		}
		else
		{
			if (edge2[2]->m_pNeighbourTinTri[0]->m_nPolygonID == polygon1Id)
			{
				edge2[2]->m_pNeighbourTinTri[0] = polygon3;
			}
			else
			{
				edge2[2]->m_pNeighbourTinTri[1] = polygon3;
			}
		}
			Leagalize(pNode,pTinTriangle);
			Leagalize(pNode,polygon2);
			Leagalize(pNode,polygon3);
	}
	else
	{
		ie--;
		edge[0] = pTinTriangle->m_pConsistEdges[ie];
		//寻找此边的另一个相邻三角形
		if (edge[0]->m_pNeighbourTinTri[0]->m_nPolygonID == pTinTriangle->m_nPolygonID)
		{
			polygon = edge[0]->m_pNeighbourTinTri[1];
		}
		else
		{
			polygon = edge[0]->m_pNeighbourTinTri[0];
		}

		if (edge[0]->m_nEdgeID == polygon->m_pConsistEdges[0]->m_nEdgeID)
		{
			ie2 = 0;
		}