tin3dview.cpp

Tin3D.rar 三维TIN的构建方面的东西

// CTin3DView.cpp : implementation of the CTin3DView class
//

#include "stdafx.h"
#include "Tin3D.h"

#include "Tin3DDoc.h"
#include "Tin3DView.h"

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

/////////////////////////////////////////////////////////////////////////////
// CTin3DView

IMPLEMENT_DYNCREATE(CTin3DView, CView)

BEGIN_MESSAGE_MAP(CTin3DView, CView)
//{{AFX_MSG_MAP(CTin3DView)
ON_WM_CREATE()
ON_WM_DESTROY()
ON_WM_SIZE()
ON_WM_PAINT()
ON_WM_LBUTTONDOWN()
ON_COMMAND(ID_TX, OnTx)
ON_COMMAND(ID_POINT, OnPoint)
//}}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()

/////////////////////////////////////////////////////////////////////////////
// CTin3DView construction/destruction

CTin3DView::CTin3DView()
{
	
	
	m_Rotateangle=0;
	MAX=624;
	IsOpen=0;
	n=0;
}

CTin3DView::~CTin3DView()
{
}

BOOL CTin3DView::PreCreateWindow(CREATESTRUCT& cs)
{
	cs.style |= (WS_CLIPCHILDREN | WS_CLIPSIBLINGS); 
	return 	CView::PreCreateWindow(cs);
	
}

/////////////////////////////////////////////////////////////////////////////
// CTin3DView drawing

void CTin3DView::OnDraw(CDC* pDC)
{
	CTin3DDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	CClientDC dc(this);
	
	
	// TODO: add draw code for native data here
}

/////////////////////////////////////////////////////////////////////////////
// CTin3DView printing

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



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

/////////////////////////////////////////////////////////////////////////////
// CTin3DView diagnostics

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

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

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

/////////////////////////////////////////////////////////////////////////////
// CTin3DView message handlers




void CTin3DView::TriDelaunay(Vertex p1,Vertex p2)
{   
	CClientDC dc(this);
	
    Vertex ThirdPoint;
    ThirdPoint.x=(GetThirdPoint(p1,p2)).x;
    ThirdPoint.y=(GetThirdPoint(p1,p2)).y;
    ThirdPoint.z=(GetThirdPoint(p1,p2)).z;
	
	
    if (ThirdPoint.x!=0 && ThirdPoint.y!=0)
	{		
		glBegin(GL_LINE_LOOP);
		glVertex3f(p1.x,p1.y,p1.z);
		glVertex3f(p2.x,p2.y,p2.z);
		glVertex3f(ThirdPoint.x,ThirdPoint.y,ThirdPoint.z);
		glEnd();
		Edge l1;
		l1.p1.x=p1.x;
		l1.p1.y=p1.y;
		l1.p1.z=p1.z;		
		
		l1.p2.x=p2.x;
		l1.p2.y=p2.y;
		l1.p2.z=p2.z;		
		
		m_edges.push_back(l1);
		
		Triangle triangle;
		triangle.ptr[0].x=p1.x;
		triangle.ptr[0].y=p1.y;
		triangle.ptr[0].z=p1.z;		
		
		triangle.ptr[1].x=p2.x;
		triangle.ptr[1].y=p2.y;
		triangle.ptr[1].z=p2.z;		
		
		triangle.ptr[2].x=ThirdPoint.x;
		triangle.ptr[2].y=ThirdPoint.y;
		triangle.ptr[2].z=ThirdPoint.z;		
		
		m_triangles.push_back(triangle);
	}
	
    else 
		return;//储存已构成的直线 
	
	TriDelaunay(p1,ThirdPoint) ;             
	TriDelaunay(ThirdPoint,p2) ;  //标记已构三角形的边，对尚未构三角形的边用算法进行递归调用
}

void CTin3DView::initial()
{
	
	int i;
	for (i=0;i<m_edges.size();i++)
	{
        m_edges[i].no=i+1;     
        m_edges[i].length=1.0;
        m_edges[i].usetimes=0;
		m_edges[i].p1.x=0;
		m_edges[i].p1.y=0;
		m_edges[i].p1.z=0;
		
		
		
		
		m_edges[i].p2.x=0;
		m_edges[i].p2.y=0;
		m_edges[i].p2.z=0;
		
		
		
	}
	/////////////////////////////////////////////////////////////
	for (i=0;i<m_triangles.size();i++)
	{
        m_triangles[i].no=i+1;
		m_triangles[i].edgeno[0]=-1;
		m_triangles[i].edgeno[1]=-1;	
        m_triangles[i].edgeno[2]=-1;
		
        m_triangles[i].Normal[0]=-1;
        m_triangles[i].Normal[1]=-1;
		m_triangles[i].Normal[2]=-1;
		
		
	}
	
}
Vertex CTin3DView::GetThirdPoint(Vertex p1, Vertex p2)
{
	/*-------------判定边是否被标记-------------------*/
	bool sign=true;
	Edge edge;
	
	edge.p1.x=p1.x;
	edge.p1.y=p1.y;
	edge.p1.z=p1.z;
	
	
	edge.p2.x=p2.x;
	edge.p2.y=p2.y;
	edge.p2.z=p2.z;
	
	
	
	for(int i=0;i<m_edges.size();i++)
	{
		if(edge.p1.x==m_edges[i].p1.x &&
			edge.p1.y==m_edges[i].p1.y&&
			edge.p1.z==m_edges[i].p1.z&&
			edge.p2.x==m_edges[i].p2.x&&
			edge.p2.y==m_edges[i].p2.y&&
			edge.p2.z==m_edges[i].p2.z)
			sign=false;
	}
	double temp=1;   //采用最大张角，即最小余弦的判别准则
	int j=0; 
	for( i=0;i<MAX;i++)
	{  
		double equation;
		equation = ((p1.y - p2.y) * (m_vertex[i].x - p2.x))
			- ((m_vertex[i].y - p2.y) * (p1.x - p2.x));//确定基线的方向
		if(equation<=0) continue;                      //沿基线>0固定方向
		double a=sqrt(pow(p1.x-m_vertex[i].x,2)+pow(p1.y-m_vertex[i].y,2));
		double b=sqrt(pow(p2.x-m_vertex[i].x,2)+pow(p2.y-m_vertex[i].y,2));
		double c=sqrt(pow(p1.x-p2.x,2)+pow(p1.y-p2.y,2));
		double d=(a*a+b*b-c*c)/(2*a*b);
		if(d<temp && equation>0 && sign)
		{
			temp=d;
			j=i;
		}	
	}
	if(j!=0)
		return m_vertex[j];
	else
	{
		Vertex temp_vertex;
		temp_vertex.x=0;
		temp_vertex.y=0;
		temp_vertex.z=0;
		
		return temp_vertex;	
	}
	
}







int CTin3DView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	
	if (CView::OnCreate(lpCreateStruct) == -1)	 return -1;
	HWND hWnd = GetSafeHwnd(); 
	HDC hDC = ::GetDC(hWnd); 
	
	
	
	
	
		 	
	
	
	if (SetWindowPixelFormat(hDC)==FALSE)  return 0; 
	if (CreateViewGLContext(hDC)==FALSE) 	return 0; 
	return 0; 
	
	
}

BOOL CTin3DView::SetWindowPixelFormat(HDC hDC)
{
	PIXELFORMATDESCRIPTOR pixelDesc; 
	pixelDesc.nSize = sizeof(PIXELFORMATDESCRIPTOR); 	pixelDesc.nVersion = 1; 
	pixelDesc.dwFlags = PFD_DRAW_TO_WINDOW | 		 			     PFD_DRAW_TO_BITMAP | 					    PFD_SUPPORT_OPENGL | 					    PFD_SUPPORT_GDI | 						   PFD_STEREO_DONTCARE; 	pixelDesc.iPixelType = PFD_TYPE_RGBA; 	pixelDesc.cColorBits = 32; 
	pixelDesc.cRedBits = 8;
	pixelDesc.cRedShift = 16;
	pixelDesc.cGreenBits = 8; 
	pixelDesc.cGreenShift = 8; 
	pixelDesc.cBlueBits = 8; 
	pixelDesc.cBlueShift = 0;
	pixelDesc.cAlphaBits = 0;
	pixelDesc.cAlphaShift = 0;
	pixelDesc.cAccumBits = 64; 
	pixelDesc.cAccumRedBits = 16; 
	pixelDesc.cAccumGreenBits = 16; 
	pixelDesc.cAccumBlueBits = 16; 
	pixelDesc.cAccumAlphaBits = 0;
	pixelDesc.cDepthBits = 32; 
	pixelDesc.cStencilBits = 8; 
	pixelDesc.cAuxBuffers = 0; 
	pixelDesc.iLayerType = PFD_MAIN_PLANE; 
	pixelDesc.bReserved = 0; 
	pixelDesc.dwLayerMask = 0; 
	pixelDesc.dwVisibleMask = 0; 
	pixelDesc.dwDamageMask = 0; 
	m_GLPixelIndex = ChoosePixelFormat( hDC, &pixelDesc);
	if (m_GLPixelIndex==0) // Let's choose a default index. 
	{    m_GLPixelIndex = 1; 
	if (DescribePixelFormat(hDC, m_GLPixelIndex, 		   		sizeof(PIXELFORMATDESCRIPTOR),&pixelDesc)==0) 
		return FALSE; 	
	} 
	if (SetPixelFormat( hDC, m_GLPixelIndex,&pixelDesc)==FALSE) 		 return FALSE; 
	return TRUE; 
	
	
	
}

BOOL CTin3DView::CreateViewGLContext(HDC hDC)
{
	m_hGLContext = wglCreateContext(hDC); 
	if (m_hGLContext == NULL) 
		return FALSE; 
	if (wglMakeCurrent(hDC, m_hGLContext)==FALSE) 		 return FALSE; 
	return TRUE; 
}

void CTin3DView::OnDestroy() 
{
    if(wglGetCurrentContext()!=NULL) 
		wglMakeCurrent(NULL, NULL) ; 
	if (m_hGLContext!=NULL) 
	{ 
		wglDeleteContext(m_hGLContext); 
		m_hGLContext = NULL; 
	} 	
	CView::OnDestroy();
}