tin.cpp

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

//            
//			
//
//		}
//	}
//
//
//	

}

void CTin::CreateTin2()
{
	InitTin3();
	CNode *node;
	CPolygon *loc;

	//多层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++;
	}

}

void CTin::InitTin3()
{
	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)/g_fXZoom;
				node->y = (node->y - g_fYTranslation)/g_fYZoom;
				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::CrossPolygon(CNode *node, CEdge *edge, CPolygon *pol1, CPolygon *pol2,CPolygon *pol,int n)
{//看看能循环利用不？
	CPolygon *poc1,*poc2;
	CEntity entity;
	poc1=poc2=NULL;
	int polygong1ID,polygong2ID;
	CEdge *edgee1,*edgee2,*edgee3,*edgee4,*edgee;
	CEdge *edge2[4];
	edgee1=edgee2=edgee3=edgee4=edgee=NULL;
	edgee=edge->next;
	edge2[2]=pol1->m_pConsistEdges[(n+2)%3];
	edge2[3]=pol1->m_pConsistEdges[(n+1)%3];
	
	CNode *nod;
		nod=node->next;
	CPolygon *polyg;
	polyg=NULL;
	polyg=pol2->next;
	if (pol2!=pol)
	{
		for (int i=0;i<3;i++)
		{
		if (pol2->m_pConsistEdges[i]==edge)
		{
			edge2[0]=pol2->m_pConsistEdges[(i+1)%3];
			edge2[1]=pol2->m_pConsistEdges[(i+2)%3];

			edgee1=entity.InitEdge();
		edgee1->m_pNode[0]=pol1->m_pConsistNodes[n];
		edgee1->m_pNode[1]=node;
		edgee2=entity.InitEdge();
		edgee2->m_pNode[1]=pol2->m_pConsistNodes[i];
		edgee2->m_pNode[0]=node;
		edgee3=entity.InitEdge();
		edgee3->m_pNode[0]=node;
		edgee3->m_pNode[1]=pol2->m_pConsistNodes[(i+1)%3];
		edgee4=entity.InitEdge();
	    edgee4->m_pNode[0]=node;
		edgee4->m_pNode[1]=pol2->m_pConsistNodes[(i+2)%3];
		polygong1ID=pol1->m_nPolygonID;
		pol1->m_pConsistNodes[0]=edgee1->m_pNode[0];
		pol1->m_pConsistNodes[1]=node;
		pol1->m_pConsistNodes[2]=edgee3->m_pNode[1];
		pol1->m_pConsistEdges[0]=edgee3;
		pol1->m_pConsistEdges[1]=edge2[3];
		pol1->m_pConsistEdges[2]=edgee1;

		polygong2ID=pol2->m_nPolygonID;
		pol2->m_pConsistNodes[0]=node;
		pol2->m_pConsistNodes[1]=edgee2->m_pNode[1];
		pol2->m_pConsistNodes[2]=edgee3->m_pNode[1];
		pol2->m_pConsistEdges[0]=edge2[1];
		pol2->m_pConsistEdges[1]=edgee3;
		pol2->m_pConsistEdges[2]=edgee2;

		poc1=entity.InitPolygon();
		poc1->m_pConsistNodes[0]=edgee1->m_pNode[0];
		poc1->m_pConsistNodes[1]=edgee4->m_pNode[1];
		poc1->m_pConsistNodes[2]=node;
		poc1->m_pConsistEdges[0]=edgee4;
		poc1->m_pConsistEdges[1]=edgee1;
		poc1->m_pConsistEdges[2]=edge2[2];
		poc1->m_nConsistNodeNum=3;
		poc1->m_nSurfaceLayer = m_nCurrentLayer;

		poc2=entity.InitPolygon();
		poc2->m_pConsistNodes[0]=node;
		poc2->m_pConsistNodes[1]=edgee4->m_pNode[1];
		poc2->m_pConsistNodes[2]=edgee2->m_pNode[1];
		poc2->m_pConsistEdges[0]=edge2[0];
		poc2->m_pConsistEdges[1]=edgee2;
		poc2->m_pConsistEdges[2]=edgee4;
		poc2->m_nSurfaceLayer=m_nCurrentLayer;
		poc2->m_nConsistNodeNum=3;

		edgee1->m_pNeighbourTinTri[0]=pol1;
		edgee1->m_pNeighbourTinTri[1]=poc1;
		edgee4->m_pNeighbourTinTri[0]=poc1;
		edgee4->m_pNeighbourTinTri[1]=poc2;
		edgee2->m_pNeighbourTinTri[0]=poc2;
		edgee2->m_pNeighbourTinTri[1]=pol2;
		edgee3->m_pNeighbourTinTri[0]=pol2;
		edgee3->m_pNeighbourTinTri[1]=pol1;
		if (edgee==edge2[0])
		{
			for (int i=0;i<3;i++)
			{
				if (edgee==poc2->m_pConsistEdges[i])
				{
					CrossPolygon(nod,edgee,poc2,polyg,pol,i);
				}
			}
		  
		}
	    else if (edgee==edge2[1])
		{
		   for (int i=0;i<3;i++)
		   {
			   if (edgee==pol2->m_pConsistEdges[i])
			   {
				   CrossPolygon(nod,edgee,pol2,polyg,pol,i);
			   }
		   }
		   
		}
		}

	}
	
	}
	for (int i=0;i<3;i++)
	{
		if (edge==pol1->m_pConsistEdges[i])
		{
			CrossLastPoly(node,edge,pol1,pol,i);
		}
	}
}

void CTin::CrossLastPoly(CNode *node, CEdge *edge, CPolygon *pl1, CPolygon *pl2,int n)
{

    CEdge *edge1,*edge2,*edge3,*edge4,*edge5,*edge6,*edge7,*edge8;
	edge1=edge2=edge3=edge4=edge5=edge6=edge7=edge8=NULL;
	edge1=pl1->m_pConsistEdges[(n+1)%3];
	edge2=pl1->m_pConsistEdges[(n+2)%3];
	CEntity entity;
	CPolygon *pol1,*pol2;
	pol1=pol2=NULL;
	int polygon1ID,polygon2ID;
	for (int i=0;i<3;i++)
	{
		if (edge==pl2->m_pConsistEdges[i])
		{
			edge3=pl2->m_pConsistEdges[(i+1)%3];
			edge4=pl2->m_pConsistEdges[(i+2)%3];

			edge5=entity.InitEdge();
			edge5->m_pNode[0]=pl1->m_pConsistNodes[n];
			edge5->m_pNode[1]=node;

			edge6=entity.InitEdge();
			edge6->m_pNode[0]=node;
			edge6->m_pNode[1]=pl2->m_pConsistNodes[i];
			edge7=entity.InitEdge();
			edge7->m_pNode[0]=node;
			edge7->m_pNode[1]=pl2->m_pConsistNodes[(i+1)%3];
			edge8=entity.InitEdge();
			edge8->m_pNode[0]=node;
			edge8->m_pNode[1]=pl2->m_pConsistNodes[(i+2)%3];

			polygon1ID=pl1->m_nPolygonID;
			pl1->m_pConsistNodes[0]=edge5->m_pNode[0];
			pl1->m_pConsistNodes[1]=node;
			pl1->m_pConsistNodes[2]=edge7->m_pNode[1];

			pl1->m_pConsistEdges[0]=edge7;
			pl1->m_pConsistEdges[1]=edge1;
			pl1->m_pConsistEdges[2]=edge5;


			polygon2ID=pl2->m_nPolygonID;
			pl2->m_pConsistNodes[0]=node;
			pl2->m_pConsistNodes[1]=edge6->m_pNode[1];
			pl2->m_pConsistNodes[2]=edge7->m_pNode[1];

			pl2->m_pConsistEdges[0]=edge4;
			pl2->m_pConsistEdges[1]=edge7;
			pl2->m_pConsistEdges[2]=edge6;
			
			pol1=entity.InitPolygon();
			pol1->m_pConsistNodes[0]=edge5->m_pNode[0];
			pol1->m_pConsistNodes[1]=edge8->m_pNode[1];
			pol1->m_pConsistNodes[2]=node;
			pol1->m_pConsistEdges[0]=edge8;
			pol1->m_pConsistEdges[1]=edge5;
			pol1->m_pConsistEdges[2]=edge2;
			pol1->m_nSurfaceLayer=m_nCurrentLayer;
			pol1->m_nConsistNodeNum=3;


			pol2=entity.InitPolygon();
			pol2->m_pConsistNodes[0]=node;
			pol2->m_pConsistNodes[1]=edge8->m_pNode[1];
			pol2->m_pConsistNodes[2]=edge6->m_pNode[1];
			pol2->m_pConsistEdges[0]=edge3;
			pol2->m_pConsistEdges[1]=edge6;
			pol2->m_pConsistEdges[2]=edge8;
			pol2->m_nSurfaceLayer=m_nCurrentLayer;
			pol2->m_nConsistNodeNum=3;


		}
	}
}


CPolygon * CTin::InsertNode2(CNode *node, CPolygon *poly,int n)
{
	CEdge *edge1,*edge2,*edge3,*edgee1,*edgee2,*edgee3;
	CPolygon *polygon2,*polygon3;
	int polygon1Id;
	CEntity entity;
	CEdge *edg1,*edg2,*edg3;
	edg1=edg2=edg3=NULL;
	   edge1=entity.InitEdge();

	   edg1=edge1->next;
	   edge1->next=edg1->next;
	   edg1->next->prev=edg1->prev;

	   edg1->next = g_pEdgeHead->next;
	   edg1->prev = g_pEdgeHead;
       g_pEdgeHead->next = edg1;
	   edg1->next->prev  = edg1;

	   
	   edge1->m_pNode[0]=node;
	   edge1->m_pNode[1]=poly->m_pConsistNodes[n];
	   edge1->m_nSurfaceLayer=m_nCurrentLayer;
	   edge1->m_nEdgeType=1;
	   edgee1=poly->m_pConsistEdges[n];
	  
	   edge2=entity.InitEdge();

	   edg2=edge2->next;
	   edge2->next=edg2->next;
	   edg2->next->prev=edg2->prev;

	   edg2->next = g_pEdgeHead->next;
	   edg2->prev = g_pEdgeHead;
       g_pEdgeHead->next = edg2;
	   edg2->next->prev  = edg2;


	   edge2->m_pNode[0]=node;
	   edge2->m_pNode[1]=poly->m_pConsistNodes[(n+1)%3];
	   edge2->m_nSurfaceLayer=m_nCurrentLayer;
	   edge2->m_nEdgeType=1;
	   edgee2=poly->m_pConsistEdges[(n+1)%3];

	   edge3=entity.InitEdge();

	   edg3=edge3->next;
	   edge3->next=edg3->next;
	   edg3->next->prev=edg3->prev;

	   edg3->next = g_pEdgeHead->next;
	   edg3->prev = g_pEdgeHead;
       g_pEdgeHead->next = edg3;
	   edg3->next->prev  = edg3;


	   edge3->m_pNode[0]=node;
	   edge3->m_pNode[1]=poly->m_pConsistNodes[(n+2)%3];
	   edge3->m_nSurfaceLayer=m_nCurrentLayer;
	   edge3->m_nEdgeType=1;
	   edgee3=poly->m_pConsistEdges[(n+2)%3];

		polygon1Id = poly->m_nPolygonID;
		//不用删除原有三角形，把它赋值成一个新的三角形
		poly->m_pConsistNodes[0] = node;
		poly->m_pConsistNodes[1] = edge2->m_pNode[1];
		poly->m_pConsistNodes[2] = edge3->m_pNode[1];
		poly->m_pConsistEdges[0] = edgee1;
		poly->m_pConsistEdges[1] = edge3;
		poly->m_pConsistEdges[2] = edge2;

		polygon2 = entity.InitPolygon();
		polygon2->m_pConsistNodes[0] = node;
		polygon2->m_pConsistNodes[1] = edge3->m_pNode[1];
		polygon2->m_pConsistNodes[2] = edge1->m_pNode[1];
		polygon2->m_pConsistEdges[0] = edgee2;
		polygon2->m_pConsistEdges[1] = edge1;
		polygon2->m_pConsistEdges[2] = edge3;
		polygon2->m_nSurfaceLayer = m_nCurrentLayer;
		polygon2->m_nConsistNodeNum = 3;
	// 	polygon2->m_nPolygonType = 6;
        polygon2->m_bVisible=true;
		
		polygon3 = entity.InitPolygon();
		polygon3->m_pConsistNodes[0] = node;
		polygon3->m_pConsistNodes[1] = edge1->m_pNode[1];
		polygon3->m_pConsistNodes[2] = edge2->m_pNode[1];
		polygon3->m_pConsistEdges[0] = edgee3;
		polygon3->m_pConsistEdges[1] = edge2;
		polygon3->m_pConsistEdges[2] = edge1;
		polygon3->m_nSurfaceLayer = m_nCurrentLayer;
		polygon3->m_nConsistNodeNum = 3;
		// polygon3->m_nPolygonType = 6;
        polygon3->m_bVisible=true;
		edge1->m_pNeighbourTinTri[0] = polygon2;
		edge1->m_pNeighbourTinTri[1] = polygon3;
		edge2->m_pNeighbourTinTri[0] = polygon3;
		edge2->m_pNeighbourTinTri[1] = poly;
		edge3->m_pNeighbourTinTri[0] = poly;
		edge3->m_pNeighbourTinTri[1] = polygon2;

//		Leagalize(node,polygon2);
//			Leagalize(node,polygon3);
		return poly;

}