trianglulationview.cpp

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

// trianglulationView.cpp : implementation of the CTrianglulationView class
//

#include "stdafx.h"
#include "trianglulation.h"

#include "trianglulationDoc.h"
#include "trianglulationView.h"
#include "math.h"

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

#define  PI   3.14159
#define  pointnumer1            1000
#define  edgestacknum        150000
#define  triangularstacknum  10000
#define  edgenum             7000


Tpoint        controlpoint[9];
Tpoint        viewpoint;
CPoint        projectpoint[9];
CPoint        mypoint[100];
Edge          edgestack[edgestacknum];
Triangular    triangular[triangularstacknum];
int           RelPoint1=-1,RelPoint2=-1;
int           stacknum=0;
int           triangularnum=0;
int           buttonpointnum=9;
Edge          edgeout[edgenum];
CPoint        edgepoint[6];
Tpoint        canshupoint[25];
CPoint        pointxy[25];
int           pointnum=9;
//CPoint        edgepoint[1000];

/////////////////////////////////////////////////////////////////////////////
// CTrianglulationView

IMPLEMENT_DYNCREATE(CTrianglulationView, CView)

BEGIN_MESSAGE_MAP(CTrianglulationView, CView)
	//{{AFX_MSG_MAP(CTrianglulationView)
	ON_WM_LBUTTONDOWN()
	ON_COMMAND(ID_TRIANGULATE, OnTriangulate)
	ON_WM_MOUSEMOVE()
	ON_COMMAND(ID_TUXING, OnTuxing)
	ON_COMMAND(ID_3d, On3d)
	ON_COMMAND(ID_2d, On2d)
	ON_COMMAND(ID_developedsurface, Ondevelopedsurface)
	ON_COMMAND(ID_SelectPoint, OnSelectPoint)
	ON_COMMAND(ID_uvtriangulation, Onuvtriangulation)
	ON_COMMAND(ID_ll, Onll)
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CTrianglulationView construction/destruction

CTrianglulationView::CTrianglulationView()
{
	// TODO: add construction code here
    controlpoint[0].x =0;
	controlpoint[0].y =0;
	controlpoint[0].z =0;

	controlpoint[1].x =50;
	controlpoint[1].y =120;
	controlpoint[1].z =100;

	controlpoint[2].x =100;
	controlpoint[2].y =40;
	controlpoint[2].z =50;

	controlpoint[3].x =10;
	controlpoint[3].y =80;
	controlpoint[3].z =150;

	controlpoint[4].x =75;
	controlpoint[4].y =80;
	controlpoint[4].z =200;

	controlpoint[5].x =123;
	controlpoint[5].y =70;
	controlpoint[5].z =-13;

	controlpoint[6].x =-15;
	controlpoint[6].y =120;
	controlpoint[6].z =60;

	controlpoint[7].x =80;
	controlpoint[7].y =160;
	controlpoint[7].z =178;

	controlpoint[8].x =130;
	controlpoint[8].y =190;
	controlpoint[8].z =123;

    viewpoint.x =100;
    viewpoint.y =200;
	viewpoint.z =278;

    
	
	//the coordinate of the points
	mypoint[0].x =200+(0.6+0.2*cos(0*PI/4))*160;                           
	mypoint[0].y =200+(0.5+0.3*sin(0*PI/4))*160;

	mypoint[1].x =200+(0.6+0.2*cos(1*PI/4))*160;
	mypoint[1].y =200+(0.5+0.3*sin(1*PI/4))*160;

	mypoint[2].x =200+(0.6+0.2*cos(2*PI/4))*160;
	mypoint[2].y =200+(0.5+0.3*sin(2*PI/4))*160;

	mypoint[3].x =200+(0.6+0.2*cos(3*PI/4))*160;
	mypoint[3].y =200+(0.5+0.3*sin(3*PI/4))*160;

	mypoint[4].x =200+(0.6+0.2*cos(4*PI/4))*160;
	mypoint[4].y =200+(0.5+0.3*sin(4*PI/4))*160;

	mypoint[5].x =200+(0.6+0.2*cos(5*PI/4))*160;
	mypoint[5].y =200+(0.5+0.3*sin(5*PI/4))*160;

	mypoint[6].x =200+(0.6+0.2*cos(6*PI/4))*160;
	mypoint[6].y =200+(0.5+0.3*sin(6*PI/4))*160;

	mypoint[7].x =200+(0.6+0.2*cos(7*PI/4))*160;
	mypoint[7].y =200+(0.5+0.3*sin(7*PI/4))*160;

	mypoint[8].x =200+(0.6+0.2*cos(8*PI/4))*160;
	mypoint[8].y =200+(0.5+0.3*sin(8*PI/4))*160;

	edgepoint[0].x =100;
	edgepoint[0].y =50;

	edgepoint[1].x =250;
	edgepoint[1].y =75;

	edgepoint[2].x =210;
	edgepoint[2].y =200;

	edgepoint[3].x =270;
	edgepoint[3].y =320;

	edgepoint[4].x =190;
	edgepoint[4].y =300;

	edgepoint[5].x =150;
	edgepoint[5].y =175;

	for (int i=0;i<edgestacknum;i++)
	{
		edgestack[i].number1 =-1;
		edgestack[i].number2 =-1;
	}
	for (i=0;i<triangularstacknum;i++)
	{
		triangular[i].number1 =-1;
		triangular[i].number2 =-1;
		triangular[i].number3 =-1;
	}
	edgeout[0].number1=0;
	edgeout[0].number2=1;

	edgeout[1].number1=1;
	edgeout[1].number2=2;

	edgeout[2].number1=2;
	edgeout[2].number2=3;

	edgeout[3].number1=3;
	edgeout[3].number2=4;

	edgeout[4].number1=4;
	edgeout[4].number2=5;

	edgeout[5].number1=5;
	edgeout[5].number2=0;

	edgeout[6].number1=-1;
	edgeout[6].number2=-1;

/*    mypoint[0].x =221;
	mypoint[0].y =146;

	mypoint[1].x =(292+222)/2;
	mypoint[1].y =(180+146)/2;

	mypoint[2].x =292;
	mypoint[2].y =180;

	mypoint[3].x =(266+327)/2;
	mypoint[3].y =(133+156)/2;

	mypoint[4].x =228;
	mypoint[4].y =173;

	mypoint[5].x =200;
	mypoint[5].y =160;*/

	mypoint[96].x =150;
	mypoint[96].y =120;

	mypoint[97].x =150;
	mypoint[97].y =180;

	mypoint[98].x =120;
	mypoint[98].y =150;

	mypoint[99].x =180;
	mypoint[99].y =150;
}

CTrianglulationView::~CTrianglulationView()
{
}

BOOL CTrianglulationView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CTrianglulationView drawing

void CTrianglulationView::OnDraw(CDC* pDC)
{
	CTrianglulationDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc); 
/*	pDC->MoveTo (edgepoint[0].x ,edgepoint[0].y);
	pDC->LineTo (edgepoint[1].x ,edgepoint[1].y);
	pDC->LineTo (edgepoint[2].x ,edgepoint[2].y);
	pDC->LineTo (edgepoint[3].x ,edgepoint[3].y);
	pDC->LineTo (edgepoint[4].x ,edgepoint[4].y);
	pDC->LineTo (edgepoint[5].x ,edgepoint[5].y);
	pDC->LineTo (edgepoint[0].x ,edgepoint[0].y);*/

//	triangulate();
//	parametricspace();
//	lunkuo();
}

/////////////////////////////////////////////////////////////////////////////
// CTrianglulationView printing

BOOL CTrianglulationView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	return DoPreparePrinting(pInfo);
}

void CTrianglulationView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add extra initialization before printing
}

void CTrianglulationView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add cleanup after printing
}

/////////////////////////////////////////////////////////////////////////////
// CTrianglulationView diagnostics

#ifdef _DEBUG
void CTrianglulationView::AssertValid() const
{
	CView::AssertValid();
}

void CTrianglulationView::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

CTrianglulationDoc* CTrianglulationView::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CTrianglulationDoc)));
	return (CTrianglulationDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CTrianglulationView message handlers

void CTrianglulationView::parametricspace()
{
	//在三维空间生成表示曲面的形状
	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.1;
		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.1;
		v=0.;
	}
    
	double t=0;
	u=0.5+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))
	{