useful.cpp

marchingcube源代码

//#include "math.h"
//#include "gl\gl.h"
//#include "gl\glu.h"
#include <stdio.h>

#include "Useful.h"

//MyGL primitives:
//================
void MyGLTranslate(Point3D *Location)
{
	//glTranslated(Location->x, Location->y, Location->z);
}
void MyGLRotate(double teta, Point3D *Axe)
{
	//glRotated(teta*(180/PI), Axe->x, Axe->y, Axe->z);
}
void MyGLRestorLocation()
{
	//glPopMatrix();
	///glPushMatrix();
}

void MyGLRelocate(Point3D *Location, Point3D *Direction, Point3D *Up)
{
	double m[16];
	Point3D W = Point3D_VecProd(Up,Direction);
	//colum 1:
	m[0] = Direction->x; m[1] = Direction->y; m[2] = Direction->z; m[3] = 0;
	//colum 2:
	m[4] = W.x; m[5] = W.y; m[6] = W.z; m[7] = 0;
	//colum 3:
	m[8] = Up->x; m[9] = Up->y; m[10] = Up->z; m[11] = 0;
	//colum 4:
	m[12] = Location->x; m[13] = Location->y; m[14] = Location->z; m[15] = 1;

	//glMultMatrixd(m);
}

void MyGLNormal(Point3D *APoint)
{
	//glNormal3d(APoint->x, APoint->y, APoint->z);
}

void MyGLVertex(Point3D *APoint)
{
	//glVertex3d(APoint->x, APoint->y, APoint->z);
}

void MyGLColor()
{
	//glColor3d(0, 0, 150);
}

void MyGLBegin(int type)
{
	//glBegin(type);
}

void MyGLEnd()
{
	//glEnd();
}

//Point3D class
Point3D *new_Point3D(Point3D *APoint3D)
{
	Point3D *tmp = (Point3D *)malloc(sizeof(Point3D));
	*tmp = *APoint3D;
	return tmp;
}
Point3D Point3D_Point3D(Point3D *APoint3D)
{
	Point3D tmp;
	tmp = *APoint3D;
	return tmp;
}
Point3D Point3D_Point3D3(double Ax, double Ay, double Az)
{
	Point3D tmp;
	tmp.x = Ax;
	tmp.y = Ay;
	tmp.z = Az;
	return tmp;
}
void Point3D_reset1(Point3D *This, Point3D *A)
{
	This->x = A->x;
	This->y = A->y;
	This->z = A->z;
}

void Point3D_reset3(Point3D *This, double ax, double ay, double az)
{
	This->x = ax;
	This->y = ay;
	This->z = az;
}

void Point3D_reset(Point3D *This){This->x=0;This->y=0;This->z=0;}

void Point3D_Invert(Point3D *This){This->x=-This->x; This->y=-This->y; This->z=-This->z;}

int/*bool*/ Point3D_IsNull(Point3D *This) {return This->x==0 && This->y==0 && This->z==0;}

double Point3D_GetNorm(Point3D *This)
{
	return sqrt((This->x*This->x)+(This->y*This->y)+(This->z*This->z));
}

double Point3D_Normalize(Point3D *This)
{
	double norm = Point3D_GetNorm(This);
	if (norm>0)
	{
		This->x = This->x/norm;
		This->y = This->y/norm;
		This->z = This->z/norm;
	}
	return norm;
}

double Point3D_Normalize1(Point3D *This, double Value)
{
	double norm = Point3D_GetNorm(This);
	if (norm>0)
	{
		This->x = (This->x*Value)/norm;
		This->y = (This->y*Value)/norm;
		This->z = (This->z*Value)/norm;
	}
	return norm;
}

Point3D Point3D_VecProd (Point3D *This, Point3D *A)
{
	Point3D tmp;
	Point3D_reset3(&tmp,
		(This->y*A->z-This->z*A->y),
		(This->z*A->x-This->x*A->z),
		(This->x*A->y-This->y*A->x)
	);
	return tmp;
}

double Point3D_Angle (Point3D *This, Point3D A)
{
	Point3D B;
	Point3D_reset1(&B,This);
	Point3D_Normalize(&B);
	Point3D_Normalize(&A);
	return acos(limit(-1,Point3D_ScalProd(&A,&B),1));
}

void Point3D_XRotate (Point3D *This, double teta)
{
	double CosO = cos(teta);
	double SinO = sin(teta);
	Point3D_reset3(This, This->x, CosO*This->y - SinO*This->z, SinO*This->y + CosO*This->z);
}

void Point3D_YRotate (Point3D *This, double teta)
{
	double CosO = cos(teta);
	double SinO = sin(teta);
	Point3D_reset3(This, CosO*This->x + SinO*This->z, This->y, SinO*This->x - CosO*This->z);
}

void Point3D_ZRotate (Point3D *This, double teta)
{
	double CosO = cos(teta);
	double SinO = sin(teta);
	Point3D_reset3(This, CosO*This->x - SinO*This->y, SinO*This->x + CosO*This->y, This->z);
}

/*void Point3D_Rotate(Point3D *This, Point3D K)
{
	Point3D I,J;
	double X,Y,Z;
	double CosO;
	double SinO;
	double teta = Normalize(&K);
	if (teta != 0)
	{
		CosO = cos(teta);
		SinO = sin(teta);

		J = Point3D_VecProd(&K,This);
		Normalize(&J);
		I = Point3D_VecProd(&J,&K);
		X = Point3D_ScalProd(&I,This);
		Y = Point3D_ScalProd(&J,This);
		Z = Point3D_ScalProd(&K,This);
		//line to be modified:
		*this = I*(CosO*X - SinO*Y) + J*(SinO*X + CosO*Y) + K*Z;
	}
}*/

Point3D Point3D_div (Point3D *This, double factor)
{
	Point3D tmp;
	Point3D_reset3(&tmp, This->x/factor, This->y/factor, This->z/factor);
	return tmp;
}

double Point3D_ScalProd (Point3D *This, Point3D *A)
{
	return (This->x*A->x + This->y*A->y + This->z*A->z);
}

Point3D Point3D_mult (Point3D *This, double factor)
{
	Point3D tmp;
	Point3D_reset3(&tmp, This->x*factor, This->y*factor, This->z*factor);
	return tmp;
}

Point3D Point3D_sub (Point3D *This, Point3D *A)
{
	Point3D tmp;
	Point3D_reset3(&tmp, This->x-A->x, This->y-A->y, This->z-A->z);
	return tmp;
}

Point3D Point3D_add (Point3D *This, Point3D *A)
{
	Point3D tmp;
	Point3D_reset3(&tmp, This->x+A->x, This->y+A->y, This->z+A->z);
	return tmp;
}

void Point3D_addeq (Point3D *This, Point3D *A)
{
	This->x += A->x;
	This->y += A->y;
	This->z += A->z;
}

void Point3D_multeq (Point3D *This, double factor)
{
	This->x *= factor;
	This->y *= factor;
	This->z *= factor;
}

void Point3D_subeq (Point3D *This, Point3D *A)
{
	This->x -= A->x;
	This->y -= A->y;
	This->z -= A->z;
}

void Point3D_diveq (Point3D *This, double denom)
{
	This->x /= denom;
	This->y /= denom;
	This->z /= denom;
}

/*MyPoint Point3D_LessZAxe(Point3D *This)
{
	MyPoint tmp(x,y);
	return tmp;
}*/

double Point3D_sin(Point3D A, Point3D B)
{
	Point3D_Normalize(&A);
	Point3D_Normalize(&B);
	return (Point3D_VecProd(&A,&B)).z;
}

double Point3D_cos(Point3D A, Point3D B)
{
	Point3D_Normalize(&A);
	Point3D_Normalize(&B);
	return Point3D_ScalProd(&A,&B);
}

void Point3D_read(Point3D *This, FILE *infile)
{
	float x,y,z;
	fscanf(infile, "%f %f %f ", &x, &y, &z);
	This->x = (double)x;
	This->y = (double)y;
	This->z = (double)z;
}


void Point3D_write(Point3D *This, FILE *outfile)
{
	float x,y,z;
	x = (float)This->x;
	y = (float)This->y;
	z = (float)This->z;
	fprintf(outfile, "%f %f %f\n", x, y, z);
}

Triangle *new_Triangle(Triangle *ATriangle)
{
	Triangle *tmp = (Triangle *)malloc(sizeof(Triangle));
	*tmp = *ATriangle;
	return tmp;
}

Triangle *new_Triangle3(int Aa, int Ab, int Ac)
{
	Triangle *tmp = (Triangle *)malloc(sizeof(Triangle));
	tmp->a = Aa;
	tmp->b = Ab;
	tmp->c = Ac;
	tmp->next = 0;
	return tmp;
}

Triangle Triangle_Triangle()
{
	Triangle tmp;
	tmp.next = 0;
	return tmp;
}

Triangle Triangle_Triangle3(int Aa, int Ab, int Ac)
{
	Triangle tmp;
	tmp.a = Aa;
	tmp.b = Ab;
	tmp.c = Ac;
	tmp.next = 0;
	return tmp;
}

Triangle Triangle_Triangle1(Triangle *ATriangle)
{
	Triangle tmp;
	tmp.a = ATriangle->a;
	tmp.b = ATriangle->b;
	tmp.c = ATriangle->c;
	tmp.next = 0;
	return tmp;
}

void Triangle_write (Triangle *This, FILE *outfile)
{
	fprintf(outfile,"3 %i %i %i\n",This->b,This->a,This->c);
}

Edge Edge_Edge()
{
	Edge tmp;
	tmp.corner1 = -1;
	tmp.corner2 = -1;
	return tmp;
}

Edge Edge_Edge2(int Acorner1, int Acorner2)
{
	Edge tmp;
	tmp.corner1 = Acorner1;
	tmp.corner2 = Acorner2;
	return tmp;
}

TriangleList TriangleList_TriangleList()
{
	TriangleList tmp;
	tmp.Head = 0;
	tmp.Tail = 0;
	return tmp;
}

void TriangleList_Add(TriangleList *This, Triangle *ATriangle)
{
	if (This->Head)
		This->Tail->next = ATriangle;
	else
		This->Head = ATriangle;
	This->Tail = ATriangle;
	This->Tail->next = 0;
}



void TriangleList_Concat(TriangleList *This, TriangleList *ATriangleList)
{
	if (This->Head)//the list is not empty
	{
		This->Tail->next = ATriangleList->Head;
		if (ATriangleList->Tail)
			This->Tail = ATriangleList->Tail;
	}
	else
	{//the list is empty
		This->Head = ATriangleList->Head;
		This->Tail = ATriangleList->Tail;
	}
	ATriangleList->Head = 0;
	ATriangleList->Tail = 0;
	if (This->Tail) This->Tail->next = 0;
}