trianglulationview.cpp

用数值方法做的三角剖分程序

	   return m;
   else 
   {
	   m=-m;
	   return m;
   }
}

double CTrianglulationView::edge(int number1, int number2)
{
    double   d;
	d=sqrt((mypoint[number1].x -mypoint[number2].x )*(mypoint[number1].x -mypoint[number2].x)
		+(mypoint[number1].y -mypoint[number2].y )*(mypoint[number1].y -mypoint[number2].y));
    return d;
}

bool CTrianglulationView::IsOutSide(int number1, int number2)
{
   // for (i=0;i<edgeout)
	return 1;
}

void CTrianglulationView::AboutEdge()
{
 /*   CPen  penblack;
	CPen  *oldpen;
	CDC *pDC=GetDC();
	penblack.CreatePen (PS_SOLID,1,1);
	oldpen=pDC->SelectObject (&penblack);
	pDC->Arc (100,100,400,400,250,100,251,100);
//	pDC->Arc (200,200,300,300,250,200,251,200);
	pDC->SelectObject (oldpen);*/

    double  t,t0=0.;
	double  d=30.;
	double  r=100.; 
	double  m=150.,n=150.;
	double  x,y;

	CDC   *pDC=GetDC();
/*	pDC->MoveTo(250,150);
	while (t<=2*PI)
	{
        t=t0+acos(1-(d*d)/(r*r));
		x=m+r*cos(t);
		y=n+r*sin(t);
		t0=t;
		pDC->LineTo((int)x,(int)y);
	}*/

	pDC->MoveTo (mypoint[0].x ,mypoint[0].y );
	pDC->LineTo (mypoint[1].x ,mypoint[1].y );
	pDC->LineTo (mypoint[2].x ,mypoint[2].y );
	pDC->LineTo (mypoint[3].x ,mypoint[3].y );
	pDC->LineTo (mypoint[4].x ,mypoint[4].y );
	pDC->LineTo (mypoint[5].x ,mypoint[5].y );
	pDC->LineTo (mypoint[6].x ,mypoint[6].y );
	pDC->LineTo (mypoint[7].x ,mypoint[7].y );
	pDC->LineTo (mypoint[8].x ,mypoint[8].y );
}

void CTrianglulationView::OnTuxing() 
{
	// TODO: Add your command handler code here
	AboutEdge();
}

int CTrianglulationView::Isout(int number1, int number2,int number3)
{
    bool  intersect1,intersect2,intersect3,intersect4,intersect5,intersect6,intersect7,intersect8;
	intersect1=IsIntersect(0,1,number1,number3);
    intersect2=IsIntersect(1,2,number1,number3);
	intersect3=IsIntersect(2,3,number1,number3);
	intersect4=IsIntersect(3,4,number1,number3);
	intersect5=IsIntersect(4,5,number1,number3);
	intersect6=IsIntersect(5,6,number1,number3);
	intersect7=IsIntersect(6,7,number1,number3);
	intersect8=IsIntersect(7,8,number1,number3);

	if ((intersect1==0)&&(intersect2==0)&&(intersect3==0)&&(intersect4==0)
		&&(intersect5==0)&&(intersect6==0)&&(intersect7==0)&&(intersect8==0))
	{
       intersect1=IsIntersect(0,1,number1,number3);
    intersect2=IsIntersect(1,2,number2,number3);
	intersect3=IsIntersect(2,3,number2,number3);
	intersect4=IsIntersect(3,4,number2,number3);
	intersect5=IsIntersect(4,5,number2,number3);
	intersect6=IsIntersect(5,6,number2,number3);
	intersect7=IsIntersect(6,7,number2,number3);
	intersect8=IsIntersect(7,8,number1,number3);
	   if ((intersect1==0)&&(intersect2==0)&&(intersect3==0)&&(intersect4==0)
		&&(intersect5==0)&&(intersect6==0)&&(intersect7==0)&&(intersect8==0))
		   return  1;
	   else 
		   return 0;
	}
	else
		return  0;//is not out
}

void CTrianglulationView::lunkuo()
{
    CDC  *pDC=GetDC();
    double u=0.,v=0.;
	Tpoint  firstpoint;
	CPoint  nextpoint;

	while ((v<=1.))
	{
		firstpoint.x =(int)((1-u)*(1-u)*(controlpoint[0].x *(1-v)*(1-v)+2*controlpoint[1].x *v *(1-v)+controlpoint[2].x *v*v)
				+2*u*(1-u)*(controlpoint[3].x *(1-v)*(1-v)+2*controlpoint[4].x *v *(1-v)+controlpoint[5].x *v*v)
				+u*u*(controlpoint[6].x *(1-v)*(1-v)+2*controlpoint[7].x *v *(1-v)+controlpoint[8].x *v*v));
		firstpoint.y =(int)((1-u)*(1-u)*(controlpoint[0].y *(1-v)*(1-v)+2*controlpoint[1].y *v *(1-v)+controlpoint[2].y *v*v)
				+2*u*(1-u)*(controlpoint[3].y *(1-v)*(1-v)+2*controlpoint[4].y *v *(1-v)+controlpoint[5].y *v*v)
				+u*u*(controlpoint[6].y *(1-v)*(1-v)+2*controlpoint[7].y *v *(1-v)+controlpoint[8].y *v*v));
		firstpoint.z =(int)((1-u)*(1-u)*(controlpoint[0].z *(1-v)*(1-v)+2*controlpoint[1].z *v *(1-v)+controlpoint[2].z *v*v)
				+2*u*(1-u)*(controlpoint[3].z *(1-v)*(1-v)+2*controlpoint[4].z *v *(1-v)+controlpoint[5].z *v*v)
				+u*u*(controlpoint[6].z *(1-v)*(1-v)+2*controlpoint[7].z *v *(1-v)+controlpoint[8].z *v*v));
        nextpoint.x =(int)(viewpoint.x +(firstpoint.x -viewpoint.x )*viewpoint.z /(viewpoint.z -firstpoint.z +0.0001))+500;
        nextpoint.y =(int)(viewpoint.y +(firstpoint.y -viewpoint.x )*viewpoint.z /(viewpoint.z -firstpoint.z +0.0001));
		pDC->MoveTo (nextpoint.x ,nextpoint.y );

		while (u<1.0)
		{
			firstpoint.x =(int)((1-u)*(1-u)*(controlpoint[0].x *(1-v)*(1-v)+2*controlpoint[1].x *v *(1-v)+controlpoint[2].x *v*v)
				+2*u*(1-u)*(controlpoint[3].x *(1-v)*(1-v)+2*controlpoint[4].x *v *(1-v)+controlpoint[5].x *v*v)
				+u*u*(controlpoint[6].x *(1-v)*(1-v)+2*controlpoint[7].x *v *(1-v)+controlpoint[8].x *v*v));
			firstpoint.y =(int)((1-u)*(1-u)*(controlpoint[0].y *(1-v)*(1-v)+2*controlpoint[1].y *v *(1-v)+controlpoint[2].y *v*v)
				+2*u*(1-u)*(controlpoint[3].y *(1-v)*(1-v)+2*controlpoint[4].y *v *(1-v)+controlpoint[5].y *v*v)
				+u*u*(controlpoint[6].y *(1-v)*(1-v)+2*controlpoint[7].y *v *(1-v)+controlpoint[8].y *v*v));
			firstpoint.z =(int)((1-u)*(1-u)*(controlpoint[0].z *(1-v)*(1-v)+2*controlpoint[1].z *v *(1-v)+controlpoint[2].z *v*v)
				+2*u*(1-u)*(controlpoint[3].z *(1-v)*(1-v)+2*controlpoint[4].z *v *(1-v)+controlpoint[5].z *v*v)
				+u*u*(controlpoint[6].z *(1-v)*(1-v)+2*controlpoint[7].z *v *(1-v)+controlpoint[8].z *v*v));

			nextpoint.x =(int)(viewpoint.x +(firstpoint.x -viewpoint.x )*viewpoint.z /(viewpoint.z -firstpoint.z +0.0001))+500;
			nextpoint.y =(int)(viewpoint.y +(firstpoint.y -viewpoint.x )*viewpoint.z /(viewpoint.z -firstpoint.z +0.0001));

			pDC->LineTo (nextpoint.x ,nextpoint.y );
			u=u+0.1;
		}
		v=v+0.99999999;
		u=0.;
	}

	u=0.;v=0.;
    while (u<=1.)
	{
		firstpoint.x =(int)((1-u)*(1-u)*(controlpoint[0].x *(1-v)*(1-v)+2*controlpoint[1].x *v *(1-v)+controlpoint[2].x *v*v)
				+2*u*(1-u)*(controlpoint[3].x *(1-v)*(1-v)+2*controlpoint[4].x *v *(1-v)+controlpoint[5].x *v*v)
				+u*u*(controlpoint[6].x *(1-v)*(1-v)+2*controlpoint[7].x *v *(1-v)+controlpoint[8].x *v*v));
		firstpoint.y =(int)((1-u)*(1-u)*(controlpoint[0].y *(1-v)*(1-v)+2*controlpoint[1].y *v *(1-v)+controlpoint[2].y *v*v)
				+2*u*(1-u)*(controlpoint[3].y *(1-v)*(1-v)+2*controlpoint[4].y *v *(1-v)+controlpoint[5].y *v*v)
				+u*u*(controlpoint[6].y *(1-v)*(1-v)+2*controlpoint[7].y *v *(1-v)+controlpoint[8].y *v*v));
		firstpoint.z =(int)((1-u)*(1-u)*(controlpoint[0].z *(1-v)*(1-v)+2*controlpoint[1].z *v *(1-v)+controlpoint[2].z *v*v)
				+2*u*(1-u)*(controlpoint[3].z *(1-v)*(1-v)+2*controlpoint[4].z *v *(1-v)+controlpoint[5].z *v*v)
				+u*u*(controlpoint[6].z *(1-v)*(1-v)+2*controlpoint[7].z *v *(1-v)+controlpoint[8].z *v*v));
        nextpoint.x =(int)(viewpoint.x +(firstpoint.x -viewpoint.x )*viewpoint.z /(viewpoint.z -firstpoint.z +0.0001))+500;
        nextpoint.y =(int)(viewpoint.y +(firstpoint.y -viewpoint.x )*viewpoint.z /(viewpoint.z -firstpoint.z +0.0001));
		pDC->MoveTo (nextpoint.x ,nextpoint.y );

		while (v<=1.0)
		{
			firstpoint.x =(int)((1-u)*(1-u)*(controlpoint[0].x *(1-v)*(1-v)+2*controlpoint[1].x *v *(1-v)+controlpoint[2].x *v*v)
				+2*u*(1-u)*(controlpoint[3].x *(1-v)*(1-v)+2*controlpoint[4].x *v *(1-v)+controlpoint[5].x *v*v)
				+u*u*(controlpoint[6].x *(1-v)*(1-v)+2*controlpoint[7].x *v *(1-v)+controlpoint[8].x *v*v));
			firstpoint.y =(int)((1-u)*(1-u)*(controlpoint[0].y *(1-v)*(1-v)+2*controlpoint[1].y *v *(1-v)+controlpoint[2].y *v*v)
				+2*u*(1-u)*(controlpoint[3].y *(1-v)*(1-v)+2*controlpoint[4].y *v *(1-v)+controlpoint[5].y *v*v)
				+u*u*(controlpoint[6].y *(1-v)*(1-v)+2*controlpoint[7].y *v *(1-v)+controlpoint[8].y *v*v));
			firstpoint.z =(int)((1-u)*(1-u)*(controlpoint[0].z *(1-v)*(1-v)+2*controlpoint[1].z *v *(1-v)+controlpoint[2].z *v*v)
				+2*u*(1-u)*(controlpoint[3].z *(1-v)*(1-v)+2*controlpoint[4].z *v *(1-v)+controlpoint[5].z *v*v)
				+u*u*(controlpoint[6].z *(1-v)*(1-v)+2*controlpoint[7].z *v *(1-v)+controlpoint[8].z *v*v));

			nextpoint.x =(int)(viewpoint.x +(firstpoint.x -viewpoint.x )*viewpoint.z /(viewpoint.z -firstpoint.z +0.0001))+500;
			nextpoint.y =(int)(viewpoint.y +(firstpoint.y -viewpoint.x )*viewpoint.z /(viewpoint.z -firstpoint.z +0.0001));

			pDC->LineTo (nextpoint.x ,nextpoint.y );
			v=v+0.1;
		}
		u=u+0.999999;
		v=0.;
	}
    
	double t=0;
	u=0.6+0.2*cos(t);
	v=0.5+0.2*sin(t);
    firstpoint.x =(int)((1-u)*(1-u)*(controlpoint[0].x *(1-v)*(1-v)+2*controlpoint[1].x *v *(1-v)+controlpoint[2].x *v*v)
				+2*u*(1-u)*(controlpoint[3].x *(1-v)*(1-v)+2*controlpoint[4].x *v *(1-v)+controlpoint[5].x *v*v)
				+u*u*(controlpoint[6].x *(1-v)*(1-v)+2*controlpoint[7].x *v *(1-v)+controlpoint[8].x *v*v));
    firstpoint.y =(int)((1-u)*(1-u)*(controlpoint[0].y *(1-v)*(1-v)+2*controlpoint[1].y *v *(1-v)+controlpoint[2].y *v*v)
				+2*u*(1-u)*(controlpoint[3].y *(1-v)*(1-v)+2*controlpoint[4].y *v *(1-v)+controlpoint[5].y *v*v)
				+u*u*(controlpoint[6].y *(1-v)*(1-v)+2*controlpoint[7].y *v *(1-v)+controlpoint[8].y *v*v));
	firstpoint.z =(int)((1-u)*(1-u)*(controlpoint[0].z *(1-v)*(1-v)+2*controlpoint[1].z *v *(1-v)+controlpoint[2].z *v*v)
				+2*u*(1-u)*(controlpoint[3].z *(1-v)*(1-v)+2*controlpoint[4].z *v *(1-v)+controlpoint[5].z *v*v)
				+u*u*(controlpoint[6].z *(1-v)*(1-v)+2*controlpoint[7].z *v *(1-v)+controlpoint[8].z *v*v));

	nextpoint.x =(int)(viewpoint.x +(firstpoint.x -viewpoint.x )*viewpoint.z /(viewpoint.z -firstpoint.z +0.0001))+500;
	nextpoint.y =(int)(viewpoint.y +(firstpoint.y -viewpoint.x )*viewpoint.z /(viewpoint.z -firstpoint.z +0.0001));
	pDC->MoveTo (nextpoint.x ,nextpoint.y);

	while (t<=(2*PI))
	{
		u=0.6+0.2*cos(t);
		v=0.5+0.3*sin(t);
        firstpoint.x =(int)((1-u)*(1-u)*(controlpoint[0].x *(1-v)*(1-v)+2*controlpoint[1].x *v *(1-v)+controlpoint[2].x *v*v)
				+2*u*(1-u)*(controlpoint[3].x *(1-v)*(1-v)+2*controlpoint[4].x *v *(1-v)+controlpoint[5].x *v*v)
				+u*u*(controlpoint[6].x *(1-v)*(1-v)+2*controlpoint[7].x *v *(1-v)+controlpoint[8].x *v*v));
		firstpoint.y =(int)((1-u)*(1-u)*(controlpoint[0].y *(1-v)*(1-v)+2*controlpoint[1].y *v *(1-v)+controlpoint[2].y *v*v)
					+2*u*(1-u)*(controlpoint[3].y *(1-v)*(1-v)+2*controlpoint[4].y *v *(1-v)+controlpoint[5].y *v*v)
					+u*u*(controlpoint[6].y *(1-v)*(1-v)+2*controlpoint[7].y *v *(1-v)+controlpoint[8].y *v*v));
		firstpoint.z =(int)((1-u)*(1-u)*(controlpoint[0].z *(1-v)*(1-v)+2*controlpoint[1].z *v *(1-v)+controlpoint[2].z *v*v)
					+2*u*(1-u)*(controlpoint[3].z *(1-v)*(1-v)+2*controlpoint[4].z *v *(1-v)+controlpoint[5].z *v*v)
					+u*u*(controlpoint[6].z *(1-v)*(1-v)+2*controlpoint[7].z *v *(1-v)+controlpoint[8].z *v*v));

		nextpoint.x =(int)(viewpoint.x +(firstpoint.x -viewpoint.x )*viewpoint.z /(viewpoint.z -firstpoint.z +0.0001))+500;
		nextpoint.y =(int)(viewpoint.y +(firstpoint.y -viewpoint.x )*viewpoint.z /(viewpoint.z -firstpoint.z +0.0001));
		pDC->LineTo (nextpoint.x ,nextpoint.y );
		t=t+0.1;
	}  
}

void CTrianglulationView::uvpingmian()
{
     CDC  *pDC=GetDC();
	 double   u,v;
	 double   t=0.;

	 pDC->MoveTo (200+0.8*100,0.5*100+200);
	 while (t<(2*PI))
	 {
        u=200+(0.6+0.2*cos(t))*100;
		v=200+(0.5+0.3*sin(t))*100;
		pDC->LineTo (u,v);
		t=t+0.1;
	 }
	 pDC->MoveTo (200,200);
	 pDC->LineTo (300,200);
	 pDC->LineTo (300,300);
	 pDC->LineTo (200,300);
	 pDC->LineTo (200,200);
}

void CTrianglulationView::On3d() 
{
	// TODO: Add your command handler code here
//	Invalidate();
//	lunkuo();
	parametricspace();
}

void CTrianglulationView::On2d() 
{
	// TODO: Add your command handler code here
//	Invalidate();
	uvpingmian();
}

void CTrianglulationView::Ondevelopedsurface() 
{
	// TODO: Add your command handler code here
/*	CPoint    linshipoint[9];
	linshipoint[0].x =400;
	linshipoint[0].y =200;

	double   d;
	d=length(controlpoint[2],controlpoint[5]);
	linshipoint[1].x =(int)(linshipoint[0].x +d);
	linshipoint[1].y =linshipoint[0].y ;

	double    jiaodu;
	jiaodu =jiajiao(controlpoint[2],controlpoint[1],controlpoint[5]);
	d =length(controlpoint[2],controlpoint[1]);
	linshipoint[2].x =(int)(linshipoint[0].x +d*cos(jiaodu));
	linshipoint[2].y =(int)(linshipoint[0].y +d*sin(jiaodu));

	CDC  *pDC=GetDC();
	pDC->MoveTo(linshipoint[0].x ,linshipoint[0].y);
	pDC->LineTo (linshipoint[1].x ,linshipoint[1].y );
	pDC->MoveTo (linshipoint[0].x ,linshipoint[0].y );
	pDC->LineTo (linshipoint[2].x ,linshipoint[2].y );

	double m,n;
	double p,q;
	double r1,r2,r3;
	int x,y;
	int x1,y1,x2,y2;
	double a,b;
	r1=length(controlpoint[1],controlpoint[4]);
	r2=length(controlpoint[5],controlpoint[4]);
	r3=length(controlpoint[2],controlpoint[4]);

	m=linshipoint[2].x ;
	n=linshipoint[2].y ;
	p=linshipoint[1].x ;
	q=linshipoint[1].y ;

	a=((double)r1*r1-r2*r2+q*q-n*n)/(2*((double)p-m))+(p-(double)m)/2.;
	b=((double)q-n)/((double)p-m);

    y1=(int)((a*b+n+sqrt((a*b+n)*(a*b+n)-(b*b+1)*(a*a+n*n-r1*r1)))/(b*b+1));
	x1=(int)(a+m-b*y1);

	y2=(int)((a*b+n-sqrt((a*b+n)*(a*b+n)-(b*b+1)*(a*a+n*n-r1*r1)))/(b*b+1));
	x2=(int)(a+m-b*y2);

	Edge  myedge[20];
	for (int i=0;i<20;i++)
	{
		myedge[i].number1 =-1;
		myedge[i].number2 =-1;
	}
	myedge[0].number1 =0;
	myedge[0].number2 =1;

	myedge[1].number1 =0;
	myedge[1].number2 =2;

	bool   intersect=0;
	i=0;
	while ((i<9)&&!intersect)
	{
		intersect=Intersect(linshipoint[myedge[i].number1 ].x,linshipoint[myedge[i].number1 ].y ,linshipoint[myedge[i].number2 ].x ,
			linshipoint[myedge[i].number2 ].y ,)
	}
	double  error1,error2;
	double  d1,d2;
	d1=sqrt((x1-linshipoint[0].x )*(x1-linshipoint[0].x )+(y1-linshipoint[0].y)*(y1-linshipoint[0].y ));
    d2=sqrt((x2-linshipoint[0].x )*(x2-linshipoint[0].x )+(y2-linshipoint[0].y)*(y2-linshipoint[0].y ));
	error1=abc(d1,0);
	error2=abc(d2,0);
	if (error1<=error2)
	{
		x=x1;
		y=y1;
	}
	else
	{
		x=x2;
		y=y2;
	}
	pDC->MoveTo (linshipoint[1].x ,linshipoint[1].y );
	pDC->LineTo (x1,y1);
	pDC->LineTo (linshipoint[2].x ,linshipoint[2].y );

    linshipoint[3].x =x1;
	linshipoint[3].y =y1;

    jiaodu =jiajiao(controlpoint[5],controlpoint[4],controlpoint[8]);
	d =length(controlpoint[5],controlpoint[8]);
	linshipoint[4].x =(int)(linshipoint[1].x +d*sin(jiaodu));
	linshipoint[4].y =(int)(linshipoint[1].y +d*cos(jiaodu));

	pDC->MoveTo (linshipoint[1].x ,linshipoint[1].y );
	pDC->LineTo (linshipoint[4].x ,linshipoint[4].y );

	jiaodu =jiajiao(controlpoint[1],controlpoint[0],controlpoint[4]);
	d =length(controlpoint[0],controlpoint[1]);
	linshipoint[5].x =(int)(linshipoint[2].x +d*cos(jiaodu));
	linshipoint[5].y =(int)(linshipoint[2].y +d*sin(jiaodu));

	pDC->MoveTo (linshipoint[2].x ,linshipoint[2].y );
	pDC->LineTo (linshipoint[5].x ,linshipoint[5].y );

    r1=length(controlpoint[7],controlpoint[4]);
	r2=length(controlpoint[7],controlpoint[8]);
	r3=length(controlpoint[7],controlpoint[5]);

	m=linshipoint[3].x ;
	n=linshipoint[3].y ;
	p=linshipoint[4].x ;
	q=linshipoint[4].y ;

	a=((double)r1*r1-r2*r2+q*q-n*n)/(2*((double)p-m))+(p-(double)m)/2.;
	b=((double)q-n)/((double)p-m);

    y1=(int)((a*b+n+sqrt((a*b+n)*(a*b+n)-(b*b+1)*(a*a+n*n-r1*r1)))/(b*b+1));
	x1=(int)(a+m-b*y1);

	y2=(int)((a*b+n-sqrt((a*b+n)*(a*b+n)-(b*b+1)*(a*a+n*n-r1*r1)))/(b*b+1));
	x2=(int)(a+m-b*y2);

	d1=sqrt((x1-linshipoint[1].x )*(x1-linshipoint[1].x )+(y1-linshipoint[1].y)*(y1-linshipoint[1].y ));
    d2=sqrt((x2-linshipoint[1].x )*(x2-linshipoint[1].x )+(y2-linshipoint[1].y)*(y2-linshipoint[1].y ));
	error1=abc(d1,0);
	error2=abc(d2,0);
	if (error1<=error2)
	{
		x=x1;
		y=y1;
	}
	else
	{
		x=x2;
		y=y2;
	}   

	linshipoint[6].x =400;
	linshipoint[6].y =625;