tin.cpp

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

		else if (edge[0]->m_nEdgeID == polygon->m_pConsistEdges[1]->m_nEdgeID)
		{
			ie2 = 1;
		}
		else
		{
			ie2 = 2;
		}
		polygon1Id = pTinTriangle->m_nPolygonID;
		polygon2Id = polygon->m_nPolygonID;
		//四条内边
		edge[0]->m_pNode[0] = pNode;
		edge[0]->m_pNode[1] = pTinTriangle->m_pConsistNodes[(ie+2)%3];

		edge[1] = entity.InitEdge();
		edge[1]->m_pNode[0] = pNode;
		edge[1]->m_pNode[1] = pTinTriangle->m_pConsistNodes[ie];
		edge[1]->m_nEdgeType = 1;

		edge[2] = entity.InitEdge();
		edge[2]->m_pNode[0] = pNode;
		edge[2]->m_pNode[1] = pTinTriangle->m_pConsistNodes[(ie+1)%3];
		edge[2]->m_nSurfaceLayer = m_nCurrentLayer;
		edge[2]->m_nEdgeType = 1;

		edge[3] = entity.InitEdge();
		edge[3]->m_pNode[0] = pNode;
		edge[3]->m_pNode[1] = pTinTriangle->m_pConsistNodes[ie2];
		edge[3]->m_nSurfaceLayer = m_nCurrentLayer;
		edge[2]->m_nEdgeType = 1;

		//四条外边
		edge2[0] = pTinTriangle->m_pConsistEdges[(ie+1)%3];
		edge2[1] = pTinTriangle->m_pConsistEdges[(ie+2)%3];
		edge2[2] = polygon->m_pConsistEdges[(ie2+1)%3];
		edge2[3] = polygon->m_pConsistEdges[(ie2+2)%3];

		pTinTriangle->m_pConsistNodes[0] = pNode;
		pTinTriangle->m_pConsistNodes[1] = edge[0]->m_pNode[1];
		pTinTriangle->m_pConsistNodes[2] = edge[1]->m_pNode[1];
		pTinTriangle->m_pConsistEdges[0] = edge2[0];
		pTinTriangle->m_pConsistEdges[1] = edge[1];
		pTinTriangle->m_pConsistEdges[2] = edge[0];

		polygon->m_pConsistNodes[0] = pNode;
		polygon->m_pConsistNodes[1] = edge[3]->m_pNode[1];
		polygon->m_pConsistNodes[2] = edge[0]->m_pNode[1];
		polygon->m_pConsistEdges[0] = edge2[3];
		polygon->m_pConsistEdges[1] = edge[0];
		polygon->m_pConsistEdges[2] = edge[3];

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

		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 == polygon2Id)
			{
				edge2[2]->m_pNeighbourTinTri[0] = polygon3;
			}
			else
			{
				edge2[2]->m_pNeighbourTinTri[1] = polygon3;
			}
		}
		Leagalize(pNode,pTinTriangle);
		Leagalize(pNode,polygon2);
		Leagalize(pNode,polygon3);
		Leagalize(pNode,polygon);
	}
}


////////////////////////////////////////////////////////
//判断点是否在Tin网三角形中
int CTin::InTinTriangle(CNode *pNode, CPolygon *pTinTriangle)
{
	double a,b,c;
	double zero = 0.01;

	a = Area(pTinTriangle->m_pConsistNodes[0],pTinTriangle->m_pConsistNodes[1],pNode);
	if (a < -zero) return 0;

	b = Area(pTinTriangle->m_pConsistNodes[1],pTinTriangle->m_pConsistNodes[2],pNode);
	if (b < -zero) return 0;

	c = Area(pTinTriangle->m_pConsistNodes[2],pTinTriangle->m_pConsistNodes[0],pNode);
	if (c < -zero) return 0;

	if(a > zero && b > zero && c > zero)
		return 4;
	else if(fabs(a) <= zero)
		return 3;
	else if(fabs(b) <= zero)
		return 1;
	else if(fabs(c) <= zero)
		return 2;
	else 
		return 0;

}

void CTin::Discard()//边缘修剪
{
	CEdge *pe,*te;
	pe = g_pEdgeHead->next;
	while(pe!=g_pEdgeHead)
	{
		te=pe;
		pe=pe->next;
		if (te->m_bTinEdge)
		{
			if(te->m_pNode[0]->m_nNodeID<0||te->m_pNode[1]->m_nNodeID<0)
			{
				////////////////////////////////////////////////////////////////
				if (te->m_nSurfaceLayer == 1)//搜寻外部点
				{
					if (te->m_pNode[0]->m_nNodeID>0)
					{
						te->m_pNode[0]->m_bOutsideNode = true;
					}
					if (te->m_pNode[1]->m_nNodeID >0)
					{
						te->m_pNode[1]->m_bOutsideNode = true;
					}
				}
				////////////////////////////////////////////////////////////////			
				te->m_pNode[0]=te->m_pNode[1]=NULL;
				te->m_pNeighbourTinTri[0]=te->m_pNeighbourTinTri[1]=NULL;
				te->next->prev=te->prev;
				te->prev->next=te->next;
				te->next=te->prev=NULL;
				delete te;
			}
		}
	}
//////////////////////
	int i;
	int iNum,iPos;
	CPolygon *f,*tf;
	f=g_pPolygonHead->next;
	while(f!= g_pPolygonHead)
	{
		tf=f;
		f=f->next;
		if (tf->m_bTinPolygon)
		{
			iNum=0;
			iPos=0;
			for( i=0;i<3;i++)
			{
				if(tf->m_pConsistNodes[i]->m_nNodeID<0)
				{
					iNum++;
					iPos=i;
				}
			}
			if(iNum)
			{
				if(iNum==1)
				{
					if(tf->m_pConsistEdges[iPos]->m_pNeighbourTinTri[0]->m_nPolygonID
						==tf->m_nPolygonID)
						tf->m_pConsistEdges[iPos]->m_pNeighbourTinTri[0]=NULL;
					else
						tf->m_pConsistEdges[iPos]->m_pNeighbourTinTri[1]=NULL;
				}
				
				for(i=0;i<3;i++)
				{
					tf->m_pConsistNodes[i]=NULL;
					tf->m_pConsistEdges[i]=NULL;
				}
				tf->next->prev=tf->prev;
				tf->prev->next=tf->next;
				tf->next=tf->prev=NULL;
				delete tf;
			}
		}
	}
	////////////////////////

	////////////////////////
	CNode *pv,*pv1;
	pv = g_pNodeHead->next;
	for(i=0;i<4;i++)
	{
		pv1=pv;
		pv=pv->next;
		pv1->next->prev=pv1->prev;
		pv1->prev->next=pv1->next;
		delete pv1;
	}
}

void CTin::Leagalize(CNode *node, CPolygon *polygon)//交换对角线
{

	int ie;
	CEdge *edge0;
	CPolygon *polygon1,*polygon2;
	BOOL bLegal;
	bLegal=TRUE;
	ie=0;
	polygon1=polygon;
	edge0=polygon1->m_pConsistEdges[0];
	///////////////////////////
	if(edge0->m_nEdgeID<0)
		bLegal=TRUE;
	else 
	{
		if(edge0->m_pNeighbourTinTri[0]->m_nPolygonID==polygon1->m_nPolygonID)
			polygon2=edge0->m_pNeighbourTinTri[1];
		else
			polygon2=edge0->m_pNeighbourTinTri[0];
		////////////
		if(edge0->m_nEdgeID==polygon2->m_pConsistEdges[0]->m_nEdgeID)
			ie=0;
		else if(edge0->m_nEdgeID==polygon2->m_pConsistEdges[1]->m_nEdgeID)
			ie=1;
		else
			ie=2;
		////////////////////////////////////////////
		bLegal=TestEdge(node,polygon1->m_pConsistNodes[1],polygon2->m_pConsistNodes[ie],polygon1->m_pConsistNodes[2]);
	}
	
	/////////////////////////////
	if(!bLegal)
	{
		CEdge* edge2[4];
		CNode *node1,*node2,*node3;
		int polygon1Id,polygon2Id;
		polygon1Id=polygon1->m_nPolygonID;
		polygon2Id=polygon2->m_nPolygonID;
		node1=polygon1->m_pConsistNodes[1];
		node2=polygon1->m_pConsistNodes[2];
		node3=polygon2->m_pConsistNodes[ie];
		edge2[0]=polygon1->m_pConsistEdges[1];
		edge2[1]=polygon1->m_pConsistEdges[2];
		edge2[2]=polygon2->m_pConsistEdges[(ie+1)%3];
		edge2[3]=polygon2->m_pConsistEdges[(ie+2)%3];
		edge0->m_pNode[0]=node;
		edge0->m_pNode[1]=node3;
		polygon1->m_pConsistNodes[0]=node;
		polygon1->m_pConsistNodes[1]=node3;
		polygon1->m_pConsistNodes[2]=node2;
		
		polygon1->m_pConsistEdges[0]=edge2[3];
		polygon1->m_pConsistEdges[1]=edge2[0];
		polygon1->m_pConsistEdges[2]=edge0;
		
		polygon2->m_pConsistNodes[0]=node;
		polygon2->m_pConsistNodes[1]=node1;
		polygon2->m_pConsistNodes[2]=node3;
		
		polygon2->m_pConsistEdges[0]=edge2[2];
		polygon2->m_pConsistEdges[1]=edge0;
		polygon2->m_pConsistEdges[2]=edge2[1];
		
		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[3]->m_nEdgeID<0)
			edge2[3]->m_pNeighbourTinTri[0]=polygon1;
		else
		{
			if(edge2[3]->m_pNeighbourTinTri[0]->m_nPolygonID==polygon2Id)
				edge2[3]->m_pNeighbourTinTri[0]=polygon1;
			else
				edge2[3]->m_pNeighbourTinTri[1]=polygon1;
		}
     	Leagalize(node,polygon1);
		Leagalize(node,polygon2);
	}
}

bool CTin::TestEdge(CNode *pNode0, CNode *pNode1, CNode *pNode2, CNode *pNode3)//判断该凸四边形是否需要交换对角线
{
	double a,b,c,a1,b1;
	if(Area(pNode0,pNode1,pNode2)<=0 || Area(pNode3,pNode0,pNode2)<=0)
			return TRUE;
	a=Lenth2(pNode0,pNode1);
	b=Lenth2(pNode0,pNode3);
	if(a>b)
	{
		c=b;
		b=Lenth2(pNode1,pNode3);
		a1=Lenth2(pNode0,pNode2);
		b1=Lenth2(pNode3,pNode2);
	}
	else
	{
		c=a;
		a=Lenth2(pNode1,pNode3);
		a1=Lenth2(pNode0,pNode2);
		b1=Lenth2(pNode1,pNode2);
	}
	return (double)sqrt(a1*b1)*(a+b-c)<(double)sqrt(a*b)*(a1+b1-c);

}


///////////////////////////////////////////////////////////////
//用计算面积来判断点和三角形边的关系
double CTin::Area(CNode *pNode1, CNode *pNode2, CNode *pNode3)
{
	double area;
	area = ((pNode1->x) * (pNode2->y)) - ((pNode2->x) * (pNode1->y)) +
		((pNode3->x) * (pNode1->y)) - ((pNode1->x) * (pNode3->y)) +
		((pNode2->x) * (pNode3->y)) - ((pNode3->x) * (pNode2->y));
	return area;

}

void CTin::CreateCDTin()
{
	CPolygon *loc1,*loc2,*loc3,*loc4;
	    loc1=loc2=loc3=loc4=NULL;
		CNode *node1,*node2;
		CPolygon *pol1,*pol2,*poly1,*poly2;
		pol1=pol2=poly1=poly2=NULL;
		CEntity entity;
		node1=g_pNodeHead->next;
		node2=node1->next;
		CTin tin;
		int i;
		 CEdge *edge1,*edge2,*edge3,*edge4;
		 edge1=edge2=edge3=edge4=NULL;
		 float f1,f2,f3;
		CNode *noddd1,*noddd2,*noddd3;
		noddd1=noddd2=noddd3=NULL;
		if (!(loc1 = LocationNode(node1)))return;
		
		
		       noddd1=loc1->m_pConsistNodes[0];
			   noddd2=loc1->m_pConsistNodes[1];
			   noddd3=loc1->m_pConsistNodes[2];
			   f1=(noddd2->y-noddd1->y)*(noddd3->z-noddd1->z)-(noddd3->y-noddd1->y)*(noddd2->z-noddd1->z);
			   f2=(noddd2->x-noddd1->x)*(noddd3->z-noddd1->z)-(noddd3->x-noddd1->x)*(noddd2->z-noddd1->z);
			   f3=(noddd2->x-noddd1->x)*(noddd3->y-noddd1->y)-(noddd3->x-noddd1->x)*(noddd2->y-noddd1->y);
			   node1->z=noddd1->z+(f2*(node1->y-noddd1->y)-f1*(node1->x-noddd1->x))/f3;
			   node1->m_CDNode=true;
		   for (i=0;i<3;i++)
		   {  
			if (loc1->m_pConsistEdges[i]==GetCrossEdge(node1,node2,loc1,i))
			{
			   if (Lenth2(node1,loc1->m_pConsistNodes[0])>size*size
							&& Lenth2(node1,loc1->m_pConsistNodes[1])>size*size
							&& Lenth2(node1,loc1->m_pConsistNodes[2])>size*size)
				pol1=InsertNode2(node1,loc1,i);	
			   
			}
			   
		   }
		       
		   if (!(loc3 = LocationNode(node2)))return;
		       noddd1=loc3->m_pConsistNodes[0];
			   noddd2=loc3->m_pConsistNodes[1];
			   noddd3=loc3->m_pConsistNodes[2];
			   f1=(noddd2->y-noddd1->y)*(noddd3->z-noddd1->z)-(noddd3->y-noddd1->y)*(noddd2->z-noddd1->z);
			   f2=(noddd2->x-noddd1->x)*(noddd3->z-noddd1->z)-(noddd3->x-noddd1->x)*(noddd2->z-noddd1->z);
			   f3=(noddd2->x-noddd1->x)*(noddd3->y-noddd1->y)-(noddd3->x-noddd1->x)*(noddd2->y-noddd1->y);
			   node2->z=noddd1->z+(f2*(node2->y-noddd1->y)-f1*(node2->x-noddd1->x))/f3;
			   node2->m_CDNode=true;
		   for (i=0;i<3;i++)
		   {
			   if (loc3->m_pConsistEdges[i]==GetCrossEdge(node1,node2,loc3,i))
			   {
				   if (Lenth2(node2,loc3->m_pConsistNodes[0])>size*size
							&& Lenth2(node2,loc3->m_pConsistNodes[1])>size*size
							&& Lenth2(node2,loc3->m_pConsistNodes[2])>size*size)
				    pol2=InsertNode2(node2,loc3,i);
				   
			   }
		   }
		   edge1=pol1->m_pConsistEdges[0];
		  edge2=pol2->m_pConsistEdges[0];
		   if (edge2->m_pNeighbourTinTri[0]==pol2)
		   {
			   loc2=edge2->m_pNeighbourTinTri[1];
		   }
		   else if (edge2->m_pNeighbourTinTri[1]==pol2)
		   {
			   loc2=edge2->m_pNeighbourTinTri[0];
		   }
		   CPolygon *ppol1,*ppol2;
		   ppol1=ppol2=NULL;