mesh.cpp

快速fft变换的c实现

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

#include "stdafx.h"
#include "FastRBF.h"
#include "Mesh.h"
#include <math.h>
#include <GL\glut.h>

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

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

Mesh::Mesh()
{
	m_iFaceNum = 0;
	m_iVertexNum = 0;
	m_pFaceIndex = 0;
	m_pFNormal = 0;
	m_pValue = 0;
	m_pVertex = 0;
	m_pVNormal = 0;
}

Mesh::~Mesh()
{
	if (m_pFaceIndex)
	{
		delete[] m_pFaceIndex;
		m_pFaceIndex = 0;
	}
	if (m_pFNormal)
	{
		delete[] m_pFNormal;
		m_pFNormal = 0;
	}
	if (m_pValue)
	{
		delete[] m_pValue;
		m_pValue = 0;
	}
	if (m_pVertex)
	{
		delete[] m_pVertex;
		m_pVertex = 0;
	}
	if (m_pVNormal)
	{
		delete[] m_pVNormal;
		m_pVNormal = 0;
	}
}

void Mesh::SetVertexCount(int N)
{
	if (m_pVertex)
		delete[] m_pVertex;

	m_iVertexNum = N;
	m_pVertex = new float[N][3];
//	m_pVNormal = new float[N][3];
}

void Mesh::SetFaceCount(int N)
{
	if (m_pFaceIndex)
		delete[] m_pFaceIndex;

	m_iFaceNum = N;
	m_pFaceIndex = new int[N][3];
}

int Mesh::GetVertexCount()
{
	return m_iVertexNum;
}

int Mesh::GetFaceCount()
{
	return m_iFaceNum;
}

void Mesh::ComputeFaceNormal()
{
	if(!m_pFNormal)
		m_pFNormal = new float[m_iFaceNum][3];

	for(int i=0; i<m_iFaceNum; i++)
	{
		int *f = m_pFaceIndex[i];
		
		double nor[3];
		nor[0] = nor[1] = nor[2] = 0;
		for(int j=0; j<3; j++)
		{
			int i1 = f[j];
			int i2 = f[(j+1)%3];
			nor[0] += (m_pVertex[i1][1] - m_pVertex[i2][1])*(m_pVertex[i1][2] + m_pVertex[i2][2]);
			nor[1] += (m_pVertex[i1][2] - m_pVertex[i2][2])*(m_pVertex[i1][0] + m_pVertex[i2][0]);
			nor[2] += (m_pVertex[i1][0] - m_pVertex[i2][0])*(m_pVertex[i1][1] + m_pVertex[i2][1]);
		}
		double len = LENGTH(nor);
		if((float)len != 0)
		{
			m_pFNormal[i][0] = (float)(-nor[0]/len);
			m_pFNormal[i][1] = (float)(-nor[1]/len);
			m_pFNormal[i][2] = (float)(-nor[2]/len);
		}
		else
		{
			m_pFNormal[i][0] = m_pFNormal[i][1] = m_pFNormal[i][2] = 0;
		}
	}
}

void Mesh::ComputeVertexNormal()
{
	if (!m_pVNormal)
		m_pVNormal = new float[m_iVertexNum][3];

	for (int i=0; i<m_iVertexNum; i++)
		m_pVNormal[i][0] = m_pVNormal[i][1] = m_pVNormal[i][2] = 0;

	for (i=0; i<m_iFaceNum; i++)
	{
		int *f = m_pFaceIndex[i];
		double nor[3];
		nor[0] = nor[1] = nor[2] = 0;
		if(f[0] < 0)
			continue;

		for(int j=0; j<3; j++)
		{
			int i1 = f[j];
			int i2 = f[(j+1)%3];
			nor[0] += (m_pVertex[i1][1] - m_pVertex[i2][1])*(m_pVertex[i1][2] + m_pVertex[i2][2]);
			nor[1] += (m_pVertex[i1][2] - m_pVertex[i2][2])*(m_pVertex[i1][0] + m_pVertex[i2][0]);
			nor[2] += (m_pVertex[i1][0] - m_pVertex[i2][0])*(m_pVertex[i1][1] + m_pVertex[i2][1]);
		}
		for(j=0; j<3; j++)
		{
			int v = m_pFaceIndex[i][j];
			m_pVNormal[v][0] += (float)nor[0];
			m_pVNormal[v][1] += (float)nor[1];
			m_pVNormal[v][2] += (float)nor[2];
		}
	}

	for(i=0; i<m_iVertexNum; i++)
	{
		double len = LENGTH((double*)m_pVNormal[i]);
		if((float)len != 0)
		{
			m_pVNormal[i][0] /= (float)len;
			m_pVNormal[i][1] /= (float)len;
			m_pVNormal[i][2] /= (float)len;
		}
	}
}

double Mesh::LENGTH(double v[])
{
	return sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
}

BOOL Mesh::WriteFile(CString fileName, CString fileExt)
{
	if (fileExt != "mesh")
	{
		TRACE("Unknow file format!");
		return FALSE;
	}

	FILE *out = fopen(fileName, "w");
	if (!out)
		return FALSE;

	fprintf(out, "%d\n", m_iVertexNum);

	for (int i=0; i<m_iVertexNum; i++)
		fprintf(out, "%f %f %f\n", m_pVertex[i][0], m_pVertex[i][1], m_pVertex[i][2]);

	fprintf(out, "%d\n", m_iFaceNum);

	for (i=0; i<m_iFaceNum; i++)
		fprintf(out, "%d %d %d\n", m_pFaceIndex[i][0], m_pFaceIndex[i][1], m_pFaceIndex[i][2]);

	fclose(out);
	return TRUE;
}

BOOL Mesh::OpenFile(CString fileName, CString fileExt)
{
/*	switch (fileExt)
	{
	case "obj":
		break;
	case "3ds":
		break;
	default:
		TRACE("Unknow file format!");
		return FALSE;
	}*/
	return TRUE;
}

void Mesh::GetBoundingBox(float *minCoord, float *maxCoord)
{
	minCoord[0] = minCoord[1] = minCoord[2] = (float)1E+38;
	maxCoord[0] = maxCoord[1] = maxCoord[2] = (float)-1E+38;

	for (int i=0; i<m_iVertexNum; i++)
	{
		for (int j=0; j<3; j++)
		{
			if (m_pVertex[i][j] < minCoord[j])
				minCoord[j] = m_pVertex[i][j];
			if (m_pVertex[i][j] > maxCoord[j])
				maxCoord[j] = m_pVertex[i][j];
		}
	}
}

void Mesh::DrawBox()
{
	if (!m_iVertexNum || !m_pVertex)
		return;

	GLfloat a[3], b[3];
	GetBoundingBox(a, b);

	glShadeModel(GL_SMOOTH);
	glEnable(GL_LIGHTING);

	glBegin(GL_LINE_LOOP);
	glVertex3f(a[0], a[1], b[2]);
	glVertex3f(b[0], a[1], b[2]);
	glVertex3f(b[0], b[1], b[2]);
	glVertex3f(a[0], b[1], b[2]);
	glEnd();

	glBegin(GL_LINES);
	glVertex3f(a[0], a[1], b[2]);
	glVertex3f(a[0], a[1], a[2]);

	glVertex3f(a[0], b[1], b[2]);
	glVertex3f(a[0], b[1], a[2]);

	glVertex3f(b[0], b[1], b[2]);
	glVertex3f(b[0], b[1], a[2]);

	glVertex3f(b[0], a[1], b[2]);
	glVertex3f(b[0], a[1], a[2]);
	glEnd();

	glBegin(GL_LINE_LOOP);
	glVertex3f(a[0], a[1], a[2]);
	glVertex3f(a[0], b[1], a[2]);
	glVertex3f(b[0], b[1], a[2]);
	glVertex3f(b[0], a[1], a[2]);
	glEnd();
	glFlush();
	glDisable(GL_POINT_SMOOTH);
	glHint(GL_POINT_SMOOTH_HINT, GL_FASTEST);
}

void Mesh::SmoothShading()
{
//	glEnable(GL_LINE_SMOOTH);
//	glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
	glEnable(GL_POLYGON_SMOOTH);
	glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
}

float* Mesh::GetVertex(int index)
{
	return m_pVertex[index];
}

vec3f Mesh::GetVertex()
{
	return m_pVertex;
}

int* Mesh::GetFaceIndex(int index)
{
	return m_pFaceIndex[index];
}

vec3i Mesh::GetFaceIndex()
{
	return m_pFaceIndex;
}

void Mesh::DrawWireframes()
{
	glShadeModel(GL_SMOOTH);
	glDisable(GL_LIGHTING);
	glBegin(GL_LINE_LOOP);
	for (int i=0; i<m_iFaceNum; i++)
	{
		int i1 = m_pFaceIndex[i][0];
		int i2 = m_pFaceIndex[i][1];
		int i3 = m_pFaceIndex[i][2];
		glVertex3fv(m_pVertex[i1]);
		glVertex3fv(m_pVertex[i2]);
		glVertex3fv(m_pVertex[i3]);
	}
	glEnd();
	glFlush();
	glDisable(GL_LINE_SMOOTH);
	glHint(GL_LINE_SMOOTH_HINT, GL_FASTEST);
}

void Mesh::DrawShadedWires()
{
	if (!m_pFNormal)
		ComputeFaceNormal();
	if (!m_pVNormal)
		ComputeVertexNormal();
	glShadeModel(GL_SMOOTH);
	glEnable(GL_LIGHTING);
	glBegin(GL_LINE_LOOP);
	for (int i=0; i<m_iFaceNum; i++)
	{
		int i1 = m_pFaceIndex[i][0];
		int i2 = m_pFaceIndex[i][1];
		int i3 = m_pFaceIndex[i][2];
		
		glNormal3fv(m_pVNormal[i1]);
		glVertex3fv(m_pVertex[i1]);
		glNormal3fv(m_pVNormal[i2]);
		glVertex3fv(m_pVertex[i2]);
		glNormal3fv(m_pVNormal[i3]);
		glVertex3fv(m_pVertex[i3]);
	}
	glEnd();
	glFlush();
	glDisable(GL_LINE_SMOOTH);
	glHint(GL_LINE_SMOOTH_HINT, GL_FASTEST);
}

void Mesh::DrawSolid()
{
	if (!m_pFNormal)
		ComputeFaceNormal();
	
	glShadeModel(GL_SMOOTH);
	glEnable(GL_LIGHTING);
	glBegin(GL_TRIANGLES);
	for (int i=0; i<m_iFaceNum; i++)
	{
		int i1 = m_pFaceIndex[i][0];
		int i2 = m_pFaceIndex[i][1];
		int i3 = m_pFaceIndex[i][2];
		
		glNormal3fv(m_pFNormal[i]);
		glVertex3fv(m_pVertex[i1]);
		glVertex3fv(m_pVertex[i2]);
		glVertex3fv(m_pVertex[i3]);
	}
	glEnd();
	glFlush();
	glDisable(GL_POLYGON_SMOOTH);
	glHint(GL_POLYGON_SMOOTH_HINT, GL_FASTEST);
}

void Mesh::DrawSmooth()
{
	if (!m_pFNormal)
		ComputeFaceNormal();
	if (!m_pVNormal)
		ComputeVertexNormal();
	
	glShadeModel(GL_SMOOTH);
	glEnable(GL_LIGHTING);
	glBegin(GL_TRIANGLES);
	for (int i=0; i<m_iFaceNum; i++)
	{
		int i1 = m_pFaceIndex[i][0];
		int i2 = m_pFaceIndex[i][1];
		int i3 = m_pFaceIndex[i][2];
		
		glNormal3fv(m_pVNormal[i1]);
		glVertex3fv(m_pVertex[i1]);
		glNormal3fv(m_pVNormal[i2]);
		glVertex3fv(m_pVertex[i2]);
		glNormal3fv(m_pVNormal[i3]);
		glVertex3fv(m_pVertex[i3]);
	}
	glEnd();
	glFlush();
	glDisable(GL_POLYGON_SMOOTH);
	glHint(GL_POLYGON_SMOOTH_HINT, GL_FASTEST);
}

void Mesh::SetVertex(int index, float x, float y, float z)
{
	m_pVertex[index][0] = x;
	m_pVertex[index][1] = y;
	m_pVertex[index][2] = z;
}

void Mesh::SetFace(int index, int i, int j, int k)
{
	m_pFaceIndex[index][0] = i;
	m_pFaceIndex[index][1] = j;
	m_pFaceIndex[index][2] = k;
}