tin.cpp

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

		   ppol1=g_pPolygonHead->next;
		   while (ppol1!=pol2)
		   {
			   ppol1=ppol1->next;
		   }
		   ppol1->prev->next=ppol1->next;
		   ppol1->next->prev=ppol1->prev;
		   				pol2->next = g_pPolygonHead->next;
	            pol2->prev = g_pPolygonHead;
	            g_pPolygonHead->next = pol2;
	            pol2->next->prev  = pol2;

				ppol2=g_pPolygonHead->next;
		   while (ppol2!=pol2)
		   {
			   ppol2=ppol2->next;
		   }
		   ppol2->prev->next=ppol1->next;
		   ppol2->next->prev=ppol2->prev;
		   	loc2->next = g_pPolygonHead->next;
	            loc2->prev = g_pPolygonHead;
	            g_pPolygonHead->next = loc2;
	            loc2->next->prev  = loc2;
				CPolygon *polll;
				polll=g_pPolygonHead->next;
		        GetTheCrossEdge(node1,node2,edge2,edge1,polll);
		 
				CNode *nood1,*nood2,*nood3,*nood4;
				nood1=nood2=nood3=nood4=NULL;
				nood1=g_pNodeHead->next;
				nood2=nood1->next;
				// nood3=nood2->next;
				while (nood2!=nood1)
				{
					nood2=nood2->next;
				}
				nood2->prev->next=nood2->next;
				nood2->next->prev=nood2->prev;
				// free(nood2);

				 for (i=0;i<3;i++)
				 {
					 CEdge *edgee;
		             CNode *ndd;
		             ndd=g_pNodeHead->next;
		             CPolygon *poll,*polyg,*polly;
		             poll=polly=polyg=NULL;
					 edgee=g_pEdgeHead->next;
		             poll=g_pPolygonHead->next;
			         if (edgee->m_pNeighbourTinTri[0]==poll)
					 {
				        polyg=edgee->m_pNeighbourTinTri[1];
					 }
			         else polyg=edgee->m_pNeighbourTinTri[0];
					 if (edgee==poll->m_pConsistEdges[i])
					 {
						 CrossPolygon(ndd,edgee,poll,polyg,pol2,i);
					 }   
				 }							
}

//判断约束线段与哪个三角形的边相互跨立
bool CTin::TestCross(CNode *node1, CNode *node2, CNode *node3, CNode *node4)
{
	float f,f0,f1,f2,f3,f4,f5,f6;
	f=node2->y-node1->y;
	f0=node2->x-node1->x;
	f1=(node3->x-node1->x)*f-(node3->y-node1->y)*f0;
	f2=f0*(node4->y-node1->y)-f*(node4->x-node1->x);
	f3=node4->x-node3->x;
	f4=node4->y-node3->y;
	f5=(node1->x-node3->x)*f4-(node1->y-node3->y)*f3;
	f6=f3*(node2->y-node3->y)-f4*(node2->x-node3->x);
	f1=f1*f2;
	f5=f5*f6;
	if((f1>=0)&&(f5>=0))return true;
	  return false;

}

CPolygon* CTin::InsertNode1(CNode *pNode,CNode *node,CPolygon *pTinTriangle,CPolygon *poly,CEdge *edge,int m)//将约束线的端点插入Tin网中
{
	CEdge *edge0,*edge1,*edge2,*edge3,*edgee0,*edgee1,*edgee2,*edgee3;
	CPolygon *poly1,*poly2;
	int polygon1Id,polygon2Id;
	CEntity entity;
	for (int i=0;i<3;i++)
	{
		if (edge==poly->m_pConsistEdges[i%3])
		{
			if (poly->m_pConsistEdges[(i+1)%3]==GetCrossEdge(pNode,node,poly,(i+1)%3))
			{
					edge0=entity.InitEdge();
					edge0->m_pNode[0]=pNode;
					edge0->m_pNode[1]=pTinTriangle->m_pConsistNodes[m%3];
						edge0->m_nEdgeType=1;
					edgee0=pTinTriangle->m_pConsistEdges[(m+1)%3];

					edge1=entity.InitEdge();
					edge1->m_pNode[0]=pNode;
					edge1->m_pNode[1]=pTinTriangle->m_pConsistNodes[(m+1)%3];
						edge1->m_nEdgeType=1;
					edgee1=pTinTriangle->m_pConsistEdges[(m+2)%3];

					edge2=entity.InitEdge();
					edge2->m_pNode[0]=pNode;
					edge2->m_pNode[1]=pTinTriangle->m_pConsistNodes[(m+2)%3];
						edge2->m_nEdgeType=1;
					edgee2=poly->m_pConsistEdges[(i+1)%3];

					edge3=entity.InitEdge();
					edge3->m_pNode[0]=pNode;
					edge3->m_pNode[1]=poly->m_pConsistNodes[i];
						edge3->m_nEdgeType=1;
					edgee3=poly->m_pConsistEdges[(i+2)%3];

					polygon1Id=pTinTriangle->m_nPolygonID;
					pTinTriangle->m_pConsistNodes[0]=pNode;
					pTinTriangle->m_pConsistNodes[1]=edge1->m_pNode[1];
					pTinTriangle->m_pConsistNodes[2]=edge3->m_pNode[1];
					pTinTriangle->m_pConsistEdges[0]=edgee2;
					pTinTriangle->m_pConsistEdges[1]=edge3;
					pTinTriangle->m_pConsistEdges[2]=edge1;

					polygon2Id=poly->m_nPolygonID;
					poly->m_pConsistNodes[0]=pNode;
					poly->m_pConsistNodes[1]=edge3->m_pNode[1];
					poly->m_pConsistNodes[2]=edge2->m_pNode[1];
					poly->m_pConsistEdges[0]=edgee3;
					poly->m_pConsistEdges[1]=edge2;
					poly->m_pConsistEdges[2]=edge3;
					


					poly1=entity.InitPolygon();
					poly1->m_pConsistNodes[0]=pNode;
					poly1->m_pConsistNodes[1]=edge2->m_pNode[1];
					poly1->m_pConsistNodes[2]=edge0->m_pNode[1];
					poly1->m_pConsistEdges[0]=edgee0;
					poly1->m_pConsistEdges[1]=edge0;
					poly1->m_pConsistEdges[2]=edge2;
					poly1->m_nSurfaceLayer = m_nCurrentLayer;
		            poly1->m_nConsistNodeNum = 3;


					poly2=entity.InitPolygon();
					poly2->m_pConsistNodes[0]=pNode;
					poly2->m_pConsistNodes[1]=edge0->m_pNode[1];
					poly2->m_pConsistNodes[2]=edge1->m_pNode[1];
					poly2->m_pConsistEdges[0]=edgee1;
					poly2->m_pConsistEdges[1]=edge1;
					poly2->m_pConsistEdges[2]=edge0;
					poly2->m_nSurfaceLayer = m_nCurrentLayer;
		            poly2->m_nConsistNodeNum = 3;


					edge0->m_pNeighbourTinTri[0]=poly1;
					edge0->m_pNeighbourTinTri[1]=poly2;
					edge1->m_pNeighbourTinTri[0]=poly2;
					edge1->m_pNeighbourTinTri[1]=pTinTriangle;
					edge2->m_pNeighbourTinTri[0]=poly;
					edge2->m_pNeighbourTinTri[1]=poly1;
					edge3->m_pNeighbourTinTri[0]=pTinTriangle;
					edge3->m_pNeighbourTinTri[1]=poly;
					
					
			}
			else if (poly->m_pConsistEdges[(i+2)%3]==GetCrossEdge(pNode,node,poly,(i+2)%3))
			{
				edge0=entity.InitEdge();
					edge0->m_pNode[0]=pNode;
					edge0->m_pNode[1]=pTinTriangle->m_pConsistNodes[m%3];
						edge0->m_nEdgeType=1;
					edgee0=pTinTriangle->m_pConsistEdges[(m+1)%3];

					edge1=entity.InitEdge();
					edge1->m_pNode[0]=pNode;
					edge1->m_pNode[1]=pTinTriangle->m_pConsistNodes[(m+1)%3];
						edge1->m_nEdgeType=1;
					edgee1=pTinTriangle->m_pConsistEdges[(m+2)%3];

					edge2=entity.InitEdge();
					edge2->m_pNode[0]=pNode;
					edge2->m_pNode[1]=pTinTriangle->m_pConsistNodes[(m+2)%3];
						edge2->m_nEdgeType=1;
					edgee2=poly->m_pConsistEdges[(i+1)%3];

					edge3=entity.InitEdge();
					edge3->m_pNode[0]=pNode;
					edge3->m_pNode[1]=poly->m_pConsistNodes[i];
						edge3->m_nEdgeType=1;
					edgee3=poly->m_pConsistEdges[(i+2)%3];

					polygon1Id=pTinTriangle->m_nPolygonID;
					pTinTriangle->m_pConsistNodes[0]=pNode;
					pTinTriangle->m_pConsistNodes[1]=edge3->m_pNode[1];
					pTinTriangle->m_pConsistNodes[2]=edge2->m_pNode[1];
					pTinTriangle->m_pConsistEdges[0]=edgee3;
					pTinTriangle->m_pConsistEdges[1]=edge2;
					pTinTriangle->m_pConsistEdges[2]=edge3;

					polygon2Id=poly->m_nPolygonID;
					poly->m_pConsistNodes[0]=pNode;
					poly->m_pConsistNodes[1]=edge1->m_pNode[1];
					poly->m_pConsistNodes[2]=edge3->m_pNode[1];
					poly->m_pConsistEdges[0]=edgee2;
					poly->m_pConsistEdges[1]=edge3;
					poly->m_pConsistEdges[2]=edge1;
					


					poly1=entity.InitPolygon();
					poly1->m_pConsistNodes[0]=pNode;
					poly1->m_pConsistNodes[1]=edge2->m_pNode[1];
					poly1->m_pConsistNodes[2]=edge0->m_pNode[1];
					poly1->m_pConsistEdges[0]=edgee0;
					poly1->m_pConsistEdges[1]=edge0;
					poly1->m_pConsistEdges[2]=edge2;
					poly1->m_nSurfaceLayer = m_nCurrentLayer;
		            poly1->m_nConsistNodeNum = 3;


					poly2=entity.InitPolygon();
					poly2->m_pConsistNodes[0]=pNode;
					poly2->m_pConsistNodes[1]=edge0->m_pNode[1];
					poly2->m_pConsistNodes[2]=edge1->m_pNode[1];
					poly2->m_pConsistEdges[0]=edgee1;
					poly2->m_pConsistEdges[1]=edge1;
					poly2->m_pConsistEdges[2]=edge0;
					poly2->m_nSurfaceLayer = m_nCurrentLayer;
		            poly2->m_nConsistNodeNum = 3;


					edge0->m_pNeighbourTinTri[0]=poly1;
					edge0->m_pNeighbourTinTri[1]=poly2;
					edge1->m_pNeighbourTinTri[0]=poly2;
					edge1->m_pNeighbourTinTri[1]=poly;
					edge3->m_pNeighbourTinTri[0]=poly;
					edge3->m_pNeighbourTinTri[1]=pTinTriangle;
					edge2->m_pNeighbourTinTri[0]=pTinTriangle;
					edge2->m_pNeighbourTinTri[1]=poly1;
					
			}
		}
		 
	}
	
   return pTinTriangle;
		
}

CEdge* CTin::GetCrossEdge(CNode *node1, CNode *node2, CPolygon *polygon,int i)//获得与约束边相交的三角形的某一条边
{

	int n;
	n=i;
	CEdge *edge;
	edge=polygon->m_pConsistEdges[n];
	CNode *nodee1,*nodee2;
	nodee1=edge->m_pNode[0];
	nodee2=edge->m_pNode[1];
	k1=(node2->y-node1->y)/(node2->x-node1->x);
	
	k2=(polygon->m_pConsistEdges[n]->m_pNode[0]->y-polygon->m_pConsistEdges[n]->m_pNode[1]->y)/(polygon->m_pConsistEdges[n]->m_pNode[0]->x-polygon->m_pConsistEdges[n]->m_pNode[1]->x);
		x0=(polygon->m_pConsistEdges[n]->m_pNode[0]->y-node2->y+k1*node2->x-k2*polygon->m_pConsistEdges[n]->m_pNode[0]->x)/(k1-k2);
		y0=k1*(x0-node2->x)+node2->y;
		CEntity entity;
		CNode *node;
		

		node=entity.InitNode();
		// edge=entity.InitEdge();
		node->x=x0;
		node->y=y0;
		node->z=((node->x-nodee1->x)/(nodee2->x-nodee1->x))*(nodee2->z-nodee1->z)+nodee1->z;
		node->m_CDNode=true;


		if(k1==k2)
		{
			return NULL;
		}
		else 
		{

			edge=polygon->m_pConsistEdges[n]; 
			edge->next=g_pEdgeHead->next;
			edge->prev=g_pEdgeHead;
			g_pEdgeHead->next=edge;
			edge->next->prev=edge;
			edge->m_nCrossEdge=true;
			return edge;
		}
	
}

void CTin::GetTheCrossEdge(CNode *node1, CNode *node2, CEdge *edge1,CEdge *edge2, CPolygon *loc)//貌似只需要一个三角形
{//获得所有与约束边相交的三角形的边和交点并存到链表中，搜索时可以从链表头开始
	    
   if(edge1!=edge2)
   {
	   CPolygon *polynew;
		polynew=NULL;
		CEdge *edgenew;
		edgenew=NULL;
	     for (int i=0;i<3;i++)
		 {
		   if (edge1==loc->m_pConsistEdges[i])
		   {
			 if (loc->m_pConsistEdges[(i+1)%3]==GetCrossEdge(node1,node2,loc,(i+1)%3))
			 {
				 edgenew=loc->m_pConsistEdges[(i+1)%3];
				 if (edgenew->m_pNeighbourTinTri[0]==loc)
				 {
					 polynew=edgenew->m_pNeighbourTinTri[1];
					 
				 }
				 else polynew=edgenew->m_pNeighbourTinTri[0];
				 polynew->next = g_pPolygonHead->next;
	            polynew->prev = g_pPolygonHead;
	            g_pPolygonHead->next = polynew;
	            polynew->next->prev  = polynew;
					 GetTheCrossEdge(node1,node2,edgenew,edge2,polynew);
			 }
			 else if (loc->m_pConsistEdges[(i+2)%3]==GetCrossEdge(node1,node2,loc,(i+2)%3))
			 {
				 edgenew=loc->m_pConsistEdges[(i+2)%3];
				 if (edgenew->m_pNeighbourTinTri[0]==loc)
				 {
					 polynew=edgenew->m_pNeighbourTinTri[1];
					 
				 }
				 else polynew=edgenew->m_pNeighbourTinTri[0];
				 polynew->next = g_pPolygonHead->next;
	            polynew->prev = g_pPolygonHead;
	            g_pPolygonHead->next = polynew;
	            polynew->next->prev  = polynew;
				GetTheCrossEdge(node1,node2,edgenew,edge2,polynew);	 
			 }

		   }
		 }
	} 	
}

void CTin::InverseInsert(CEdge *edge1, CPolygon *ploy1,CPolygon *poly2,CNode *nod,CNode *nodebegin)
{
//	int poly1ID,poly2ID,poly3ID,poly4ID;
//	CEdge *edge0,*edge2,*edge3,*edge4,*edge5,*edge6,*edge7;
//	CPolygon *polygon1,*polygon2;
//	//poly1ID=ploy1->m_nPolygonID;
//	poly2ID=poly2->m_nPolygonID;
//	CEntity entity;
//	CNode *node;
//	node=g_pNodeHead->next;
//	CPolygon *poc;
//	CPolygon *poc1,*poc2;
//	for (int i=0;i<3;i++)
//	{
//		if (edge1==ploy1->m_pConsistEdges[i])
//		{
//            CPolygon *poc;
//			// poc=InsertNode1(nod,ploy1,poly2,edge1,i);
//		}
//		if (edge1==poly2->m_pConsistEdges[i])
//		{
//			
//			while(poly2->m_pConsistNodes[i]!=nodebegin)
//			{
//				//调用一个函数
//				//InsertCrossNode(nod,edge1,);//还未完成
//			}
//			
//			poly1ID=poc->m_nPolygonID;
//			edge1=poc->m_pConsistEdges[1];
//			edge2=poc->m_pConsistEdges[2];
//			edge3->m_pNode[0]=node;
//			edge3->m_pNode[1]=edge1->m_pNode[1];
//			edge4->m_pNode[0]=node;
//			edge4->m_pNode[1]=edge2->m_pNode[1];
//            edge0=entity.InitEdge();
//			edge0->m_pNode[0]=nod;
//			edge0->m_pNode[1]=node;
//            poc->m_pConsistNodes[0]=nod;
//			poc->m_pConsistNodes[1]=edge2->m_pNode[1];
//			poc->m_pConsistNodes[2]=node;
//			poc1=entity.InitPolygon();
//			poc1->m_pConsistNodes[0]=nod;
//			poc1->m_pConsistNodes[1]=node;
//			poc1->m_pConsistNodes[2]=edge1->m_pNode[1];
//
//			edge0->m_pNeighbourTinTri[0]=poc;
//			edge0->m_pNeighbourTinTri[1]=poc1;
//
//
//
//
////应该有一个循环的！！！
//			poc2=entity.InitPolygon();
//			edge5=entity.InitEdge();
//			edge5->m_pNode[0]=poly2->m_pConsistNodes[i];
//				edge5->m_pNode[1]=node;
//			edge6=poly2->m_pConsistEdges[(i+1)%3];
//			edge6->m_pNode[0]=poly2->m_pConsistNodes[(i+2)%3];
//			edge6->m_pNode[1]=poly2->m_pConsistNodes[i];
//			edge7=poly2->m_pConsistEdges[(i+2)%3];
//			edge7->m_pNode[0]=poly2->m_pConsistNodes[i];
//			edge7->m_pNode[1]=poly2->m_pConsistNodes[(i+1)%3];
//
//			poly2->m_pConsistNodes[0]=edge5->m_pNode[0];
//
//			poly2->m_pConsistNodes[1]=node;
//			poly2->m_pConsistNodes[2]=edge6->m_pNode[0];
//
//			poly2->m_pConsistEdges[0]=edge4;
//			poly2->m_pConsistEdges[1]=edge6;
//			poly2->m_pConsistEdges[2]=edge5;
//
//			poc2->m_pConsistNodes[0]=edge5->m_pNode[0];
//			poc2->m_pConsistNodes[1]=edge7->m_pNode[1];
//			poc2->m_pConsistNodes[2]=node;
//
//
//			poc2->m_pConsistEdges[0]=edge3;
//			poc2->m_pConsistEdges[1]=edge5;
//			poc2->m_pConsistEdges[2]=edge7;
//
//			edge3->m_pNeighbourTinTri[0]=poc1;
//			edge3->m_pNeighbourTinTri[1]=poc2;
//
//			edge4->m_pNeighbourTinTri[0]=poc;
//			edge4->m_pNeighbourTinTri[1]=poly2;
//
//			edge5->m_pNeighbourTinTri[0]=poc2;
//			edge5->m_pNeighbourTinTri[1]=poly2;
//			poc->m_CDPolygon=true;
//			poly2->m_CDPolygon=true;
//			poc2->m_CDPolygon=true;
//			poc1->m_CDPolygon=true;