dlut可视化大作业2————三维空间点集凸包计算

最新推荐文章于 2022-07-26 18:41:42 发布
最新推荐文章于 2022-07-26 18:41:42 发布
阅读量237 收藏
点赞数
分类专栏： sun的垃圾场
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43941795/article/details/115479946
版权 
#include <windows.h>
#include <gl\gl.h>
#include <gl\glu.h>
#include <gl\glaux.h>
#include <stdio.h>
#include<math.h>

HDC			hDC=NULL;
HGLRC		hRC=NULL;
HWND		hWnd=NULL;
HINSTANCE	hInstance = NULL;

bool		keys[256];
bool		active=TRUE;
bool		fullscreen=TRUE;
bool        changed;

float x=0.0f;
float y=0.0f;
float z=0.0f;

float startPostion_x=0;
float startPostion_y=0;
float startPostion_z=0;

float max_x=20.0f;
float max_y=20.0f;
float max_z=20.0f;

float min_x=-20.0f;
float min_y=-20.0f;
float min_z=-20.0f;

float nv_x=-sqrt(1.0f/3.0f);
float nv_y=sqrt(1.0f/3.0f);
float nv_z=-sqrt(1.0f/3.0f);


float num;

float a=-0.01f;
float dic=0.95f;

float radious=0.7f;

float vx=0.0f;
float vy=0.0f;
float vz=0.0f;

float distance=100.0f;

static GLfloat LightAmb[] = {0.7f, 0.7f, 0.7f, 1.0f};
static GLfloat LightDif[] = {1.0f, 1.0f, 1.0f, 1.0f};
static GLfloat LightPos[] = {4.0f, 4.0f, 6.0f, 1.0f};

GLUquadricObj	*q;

GLfloat		xrot		=  0.0f;
GLfloat		yrot		=  0.0f;
GLfloat		xrotspeed	=  0.0f;
GLfloat		yrotspeed	=  0.0f;
GLfloat		zoom		= -60.0f;
GLfloat		height		=  0.0f;

GLuint		texture[6];

LRESULT	CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

GLvoid ReSizeGLScene(GLsizei width, GLsizei height)
{
	if (height==0)
	{
		height=1;
	}

	glViewport(0,0,width,height);

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();

	gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}

AUX_RGBImageRec *LoadBMP(char *Filename)
{
	FILE *File=NULL;
	if (!Filename)
	{
		return NULL;
	}
	File=fopen(Filename,"r");
	if (File)
	{
		fclose(File);
		return auxDIBImageLoad(Filename);
	}
	return NULL;
}

int LoadGLTextures()
{
    int Status=FALSE;
    AUX_RGBImageRec *TextureImage[6];
    memset(TextureImage,0,sizeof(void *)*6);
    if ((TextureImage[0]=LoadBMP("Data/EnvWall.bmp")) &&
        (TextureImage[1]=LoadBMP("Data/Ball.bmp")) &&
        (TextureImage[2]=LoadBMP("Data/EnvRoll.bmp"))
		&&(TextureImage[3]=LoadBMP("Data/up.bmp"))&&
		(TextureImage[4]=LoadBMP("Data/blue.bmp"))
		&&(TextureImage[5]=LoadBMP("Data/back.bmp")))
	{
		Status=TRUE;
		glGenTextures(6, &texture[0]);
		for (int loop=0; loop<6; loop++)
		{
			glBindTexture(GL_TEXTURE_2D, texture[loop]);
			glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[loop]->sizeX, TextureImage[loop]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[loop]->data);
			glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
			glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
		}
		for (int loop=0; loop<6; loop++)
		{
			if (TextureImage[loop])
			{
				if (TextureImage[loop]->data)
				{
					free(TextureImage[loop]->data);
				}
				free(TextureImage[loop]);
			}
		}
	}
	return Status;
}

int InitGL(GLvoid)
{
	if (!LoadGLTextures())
	{
		return FALSE;
	}
	glShadeModel(GL_SMOOTH);
	glClearColor(0.2f, 0.5f, 1.0f, 1.0f);
	glClearDepth(1.0f);
	glClearStencil(0);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
	glEnable(GL_TEXTURE_2D);

	glLightfv(GL_LIGHT0, GL_AMBIENT, LightAmb);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, LightDif);
	glLightfv(GL_LIGHT0, GL_POSITION, LightPos);

	glEnable(GL_LIGHT0);
	glEnable(GL_LIGHTING);

	q = gluNewQuadric();
	gluQuadricNormals(q, GL_SMOOTH);
	gluQuadricTexture(q, GL_TRUE);

	glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
	glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);

	return TRUE;
}

void DrawObject()
{
	glColor3f(1.0f, 1.0f, 1.0f);
	glBindTexture(GL_TEXTURE_2D, texture[1]);
	gluSphere(q, radious, 32, 16);

	glBindTexture(GL_TEXTURE_2D, texture[2]);
	glColor4f(1.0f, 1.0f, 1.0f, 0.4f);
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
	glEnable(GL_TEXTURE_GEN_S);
	glEnable(GL_TEXTURE_GEN_T);

	gluSphere(q, radious+1.0f, 32, 16);
	glDisable(GL_TEXTURE_GEN_S);
	glDisable(GL_TEXTURE_GEN_T);
	glDisable(GL_BLEND);
}

void DrawFloor()
{
	glBindTexture(GL_TEXTURE_2D, texture[4]);
	glBegin(GL_QUADS);
		glNormal3f(0.0, 1.0, 0.0);
			glTexCoord2f(0.0f, 1.0f);
			glVertex3f(min_x, min_y, max_z);
			glTexCoord2f(0.0f, 0.0f);
			glVertex3f(min_x, min_y,min_z);
			glTexCoord2f(1.0f, 0.0f);
			glVertex3f( max_x,min_y,min_z);
			glTexCoord2f(1.0f, 1.0f);
			glVertex3f(max_x, min_y, max_z);
	glEnd();
	glBindTexture(GL_TEXTURE_2D,texture[4]);
	glBegin(GL_QUADS);
	glNormal3f(0.0, 1.0, 0.0);
	        glTexCoord2f(0.0f,1.0f);
			glVertex3f(min_x,min_y,max_z);
			glTexCoord2f(0.0f,0.0f);
			glVertex3f(min_x,min_y,min_z);
			glTexCoord2f(1.0f,0.0f);
			glVertex3f(min_x,max_y,min_z);
			glTexCoord2f(1.0f,1.0f);
			glVertex3f(min_x,max_y,max_z);
	glEnd();
	glBegin(GL_QUADS);
	        glTexCoord2f(0.0f,1.0f);
			glVertex3f(max_x,min_y,max_z);
			glTexCoord2f(0.0f,0.0f);
			glVertex3f(max_x,min_y,min_z);
			glTexCoord2f(1.0f,0.0f);
			glVertex3f(max_x,max_y,min_z);
			glTexCoord2f(1.0f,1.0f);
			glVertex3f(max_x,max_y,max_z);
	glEnd();
	    glBindTexture(GL_TEXTURE_2D,texture[4]);
		glBegin(GL_QUADS);
		glNormal3f(0.0, 1.0, 0.0);
			glTexCoord2f(0.0f, 1.0f);
			glVertex3f(min_x, max_y, max_z);
			glTexCoord2f(0.0f, 0.0f);
			glVertex3f(min_x, max_y,min_z);
			glTexCoord2f(1.0f, 0.0f);
			glVertex3f(max_x, max_y,min_z);
			glTexCoord2f(1.0f, 1.0f);
			glVertex3f( max_x, max_y, max_z);
	glEnd();
    glBindTexture(GL_TEXTURE_2D,texture[4]);
	glBegin(GL_QUADS);
	      glTexCoord2f(0.0f,1.0f);
		  glVertex3f(min_x,max_y,min_z);
		  glTexCoord2f(0.0f,0.0f);
		  glVertex3f(max_x,max_y,min_z);
		  glTexCoord2f(1.0f,0.0f);
		  glVertex3f(max_x,min_y,min_z);
		  glTexCoord2f(1.0f,1.0f);
		  glVertex3f(min_x,min_y,min_z);
	glEnd();
	glColor3f(1.0f,1.0f,1.0f);
	glBegin(GL_TRIANGLES);
	    glVertex3f(min_x,max_y,max_z);
        glVertex3f(max_x,min_y,max_z);
		glVertex3f(max_x,max_y,min_z);
	glEnd();
}

int DrawGLScene(GLvoid)
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
	double eqr[] = {0.0f,-1.0f, 0.0f, 0.0f};
	glLoadIdentity();
	glTranslatef(0.0f, -0.6f, zoom);
	glColorMask(0,0,0,0);
	glEnable(GL_STENCIL_TEST);
	glStencilFunc(GL_ALWAYS, 1, 1);
	glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
	glDisable(GL_DEPTH_TEST);
	DrawFloor();
	glEnable(GL_DEPTH_TEST);
	glColorMask(1,1,1,1);
	glStencilFunc(GL_EQUAL, 1, 1);
	glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
	glEnable(GL_CLIP_PLANE0);
	glClipPlane(GL_CLIP_PLANE0, eqr);
	glPushMatrix();
		glScalef(1.0f, -1.0f, 1.0f);
		glLightfv(GL_LIGHT0, GL_POSITION, LightPos);
		glTranslatef(x,y+height, z);
		glRotatef(xrot, 1.0f, 0.0f, 0.0f);
		glRotatef(yrot, 0.0f, 1.0f, 0.0f);
		DrawObject();
	glPopMatrix();
	glDisable(GL_CLIP_PLANE0);
	glDisable(GL_STENCIL_TEST);
	glLightfv(GL_LIGHT0, GL_POSITION, LightPos);
	glEnable(GL_BLEND);
	glDisable(GL_LIGHTING);
	glColor4f(1.0f, 1.0f, 1.0f, 0.8f);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	DrawFloor();
	glEnable(GL_LIGHTING);
	glDisable(GL_BLEND);
	glTranslatef(x,y+height, z);
	glRotatef(xrot, 1.0f, 0.0f, 0.0f);
	glRotatef(yrot, 0.0f, 1.0f, 0.0f);
	DrawObject();
	xrot += xrotspeed;
	yrot += yrotspeed;
	glFlush();
	return TRUE;
}

void getNvPosition(float x1,float y1,float z1,float x2,float y2,float z2,float x3,float y3,float z3)
{
	float a1=x2-x1;
    float a2=x3-x2;
	float a3=x3-x1;
	float b1=y2-y1;
	float b2=y3-y2;
	float b3=y3-y1;
	float c1=z2-z1;
	float c2=z3-z2;
	float c3=z3-z1;

	if((a1==0&&b1==0&&c1==0)||(a2==0&&b2==0&&c2==0)||(a3==0&&b3==0&&c3==0))
	{
		MessageBox(NULL,"给出的平面坐标中，有两点坐标相同，请重新赋值","法向计算函数错误",MB_OK | MB_ICONINFORMATION);
		return;
	}
	if((a1*b2-a2*b1==0)&&(c2*b1-c1*b2==0))
	{
		MessageBox(NULL,"给出的三点在同一直线上，因此无法计算该面法向","法向计算函数错误",MB_OK | MB_ICONINFORMATION);
		return;
	}
	nv_x=-1.0f;
	if((b1*c2-b2*c1)!=0.0f)
	{
		nv_y=-nv_x*(a1*c2-a2*c1)/(b1*c2-b2*c1);
	}
	else if((b2*c3-b3*c2)!=0.0f)
	{
		nv_y=-nv_x*(a2*c3-a3*c2)/(b2*c3-b3*c2);
	}
	else if ((b1*c3-b3*c1)!=0.0f)
	{
		nv_y=-nv_x*(a1*c3-a3*c1)/(b1*c3-b3*c1);
	}

	else
	{
		nv_x=0.0f;
		if((c2-c1)!=0.0f)
		{
			nv_y=1.0f;
        	nv_z=-(b2-b1)/(c2-c1);
		}
		else if((c3-c2)!=0.0f)
		{
			nv_y=1.0f;
		    nv_z=-(b3-b2)/(c3-c2);
		}
		else if((c3-c1)!=0.0f)
		{
			nv_y=1.0f;
		    nv_z=-(b3-b1)/(c3-c1);
		}
		else
		{
			nv_x=0.0f;
			nv_y=0.0f;
			nv_z=1.0f;
		}
	}
	if((c1*b2-c2*b1)!=0.0f)
	{
		nv_z=-nv_x*(a1*b2-a2*b1)/(c1*b2-c2*b1);
	}
	else if((c2*b3-c3*b2)!=0.0f)
	{
		nv_z=-nv_x*(a2*b3-a3*b2)/(c2*b3-c3*b2);
	}
	else
	{
		nv_z=-nv_x*(a1*b3-a3*b1)/(c1*b3-c3*b1);
	}
	float temp=nv_x*nv_x+nv_y*nv_y+nv_z*nv_z;
	nv_x=nv_x/sqrt(temp);
	nv_y=nv_y/sqrt(temp);
	nv_z=nv_z/sqrt(temp);
}

float getDis(float x1,float y1,float z1)
{
	float temp1=x1-x;
	float temp2=y1-y;
	float temp3=z1-z;
	distance=temp1*nv_x+temp2*nv_y+temp3*nv_z;
	return distance;
}

void getAfterV()
{
	vx=vx;
	vy=vy+a*num;
	vz=vz;
	if((vx*nv_x+vy*nv_y+vz*nv_z)<0.0f)
	{
		nv_x=-nv_x;
		nv_y=-nv_y;
		nv_z=-nv_z;
	}
	float k=vx*nv_x+vy*nv_y+vz*nv_z;
	vx=vx-2*k*nv_x;
	vy=vy-2*k*nv_y;
	vz=vz-2*k*nv_z;
	vx=dic*vx;
	vy=dic*vy;
	vz=dic*vz;
}
void move()
{
	num+=1.0f;
	x=vx*num+startPostion_x;
	z=vz*num+startPostion_z;
	y=vy*num+0.5f*a*num*num+startPostion_y;
	if(nv_x==0.0f&&nv_y==0.0f&&nv_z==0.0f)
	{
		MessageBox(NULL,"hit.","hirt",MB_OK | MB_ICONINFORMATION);
	}
	float tempDis=getDis(min_x,max_y,max_z);
	if(tempDis<radious)
	{
		getAfterV();
		startPostion_x=x;
		startPostion_y=y;
		startPostion_z=z;
		num=0.0f;
	}
	if(y<min_y+radious)
	{
		startPostion_x=x;
		startPostion_z=z;
		startPostion_y=min_y+radious;
		vy=0.0f-(vy+a*num)*dic;
		num=0.0f;
	}
	if(y>max_y-radious)
	{
		startPostion_x=x;
		startPostion_z=z;
		startPostion_y=max_y-radious;
		vy=0.0f-(vy+a*num)*dic;
		num=0.0f;
	}
	if(x>max_x-radious)
	{
        startPostion_x=max_x-radious;
		startPostion_y=y;
		startPostion_z=z;
		vx=0.0f-vx*dic;
		vy=vy+a*num;
		num=0.0f;
	}
	if(x<min_x+radious)
	{
        startPostion_x=min_x+radious;
		startPostion_y=y;
		startPostion_z=z;
		vx=0.0f-vx*dic;
		vy=vy+a*num;
		num=0.0f;
	}
	if(z<min_z+radious)
	{
		startPostion_z=min_z+radious;
		startPostion_x=x;
		startPostion_y=y;
		vy=vy+a*num;
		vz=0.0f-vz*dic;
		num=0.0f;
	}
	if(z>max_z-radious)
	{
		startPostion_z=max_z-radious;
		startPostion_x=x;
		startPostion_y=y;
		vy=vy+a*num;
		vz=0.0f-vz*dic;
		num=0.0f;
	}
}

void ProcessKeyboard()
{
	if (keys[VK_RIGHT])		yrotspeed += 0.08f;
	if (keys[VK_LEFT])		yrotspeed -= 0.08f;
	if (keys[VK_DOWN])		xrotspeed += 0.08f;
	if (keys[VK_UP])		xrotspeed -= 0.08f;
	if (keys['B'])
	{			zoom +=0.05f;
	}
	if (keys['N'])			zoom -=0.05f;

	if (keys[VK_PRIOR])
	{
		if(height+x<max_y-0.03f)
		{

		}
	}
	if (keys[VK_NEXT])
	{
		if(height+x>min_y+0.03f)
		{

		}
	}
	if(keys[VK_F4])
	{
		radious+=0.01f;
	}
	if(keys[VK_F5])
	{
		radious+=-0.01f;
	}

}

GLvoid KillGLWindow(GLvoid)
{
	if (hRC)
	{
		if (!wglMakeCurrent(NULL,NULL))
		{
			MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
		}

		if (!wglDeleteContext(hRC))
		{
			MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
		}
		hRC=NULL;
	}
	if (hDC && !ReleaseDC(hWnd,hDC))
	{
		MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
		hDC=NULL;
	}
	if (hWnd && !DestroyWindow(hWnd))
	{
		MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
		hWnd=NULL;
	}
	if (fullscreen)
	{
		ChangeDisplaySettings(NULL,0);
		ShowCursor(TRUE);
	}
	if (!UnregisterClass("OpenGL",hInstance))
	{
		MessageBox(NULL,"Could Not Unregister Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
		hInstance=NULL;
	}
}

BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
	GLuint		PixelFormat;
	WNDCLASS	wc;
	DWORD		dwExStyle;
	DWORD		dwStyle;

	fullscreen=fullscreenflag;

	hInstance			= GetModuleHandle(NULL);
	wc.style			= CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
	wc.lpfnWndProc		= (WNDPROC) WndProc;
	wc.cbClsExtra		= 0;
	wc.cbWndExtra		= 0;
	wc.hInstance		= hInstance;
	wc.hIcon			= LoadIcon(NULL, IDI_WINLOGO);
	wc.hCursor			= LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground	= NULL;
	wc.lpszMenuName		= NULL;
	wc.lpszClassName	= "OpenGL";
	if (!RegisterClass(&wc))
	{
		MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;
	}
	if (fullscreen)
	{
		DEVMODE dmScreenSettings;
		memset(&dmScreenSettings,0,sizeof(dmScreenSettings));
		dmScreenSettings.dmSize=sizeof(dmScreenSettings);
		dmScreenSettings.dmPelsWidth	= width;
		dmScreenSettings.dmPelsHeight	= height;
		dmScreenSettings.dmBitsPerPel	= bits;
		dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
		if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
		{
			if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
			{
				fullscreen=FALSE;
			}
			else
			{
				MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
				return FALSE;
			}
		}
	}

	if (fullscreen)
	{
		dwExStyle=WS_EX_APPWINDOW;
		dwStyle=WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
		ShowCursor(FALSE);
	}
	else
	{
		dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
		dwStyle=WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
	}
	if (!(hWnd=CreateWindowEx(	dwExStyle,
								"OpenGL",
								title,
								dwStyle,
								0, 0,
								width, height,
								NULL,
								NULL,
								hInstance,
								NULL)))
	{
		KillGLWindow();
		MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;
	}
	static	PIXELFORMATDESCRIPTOR pfd=
	{
		sizeof(PIXELFORMATDESCRIPTOR),
		1,
		PFD_DRAW_TO_WINDOW |
		PFD_SUPPORT_OPENGL |
		PFD_DOUBLEBUFFER,
		PFD_TYPE_RGBA,
		bits,
		0, 0, 0, 0, 0, 0,
		0,
		0,
		0,
		0, 0, 0, 0,
		16,
		1,
		0,
		PFD_MAIN_PLANE,
		0,
		0, 0, 0
	};
	if (!(hDC=GetDC(hWnd)))
	{
		KillGLWindow();
		MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;
	}
	if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd)))
	{
		KillGLWindow();
		MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;
	}
	if(!SetPixelFormat(hDC,PixelFormat,&pfd))
	{
		KillGLWindow();
		MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;
	}

	if (!(hRC=wglCreateContext(hDC)))
	{
		KillGLWindow();
		MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;
	}

	if(!wglMakeCurrent(hDC,hRC))
	{
		KillGLWindow();
		MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;
	}
	ShowWindow(hWnd,SW_SHOW);
	SetForegroundWindow(hWnd);
	SetFocus(hWnd);
	ReSizeGLScene(width, height);

	if (!InitGL())
	{
		KillGLWindow();
		MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;
	}

	return TRUE;
}


LRESULT CALLBACK WndProc(	HWND	hWnd,
							UINT	uMsg,
							WPARAM	wParam,
							LPARAM	lParam)
{
	switch (uMsg)
	{
		case WM_ACTIVATE:
		{
			if (!HIWORD(wParam))
			{
				active=TRUE;
			}
			else
			{
				active=FALSE;
			}

			return 0;
		}

		case WM_SYSCOMMAND:
		{
			switch (wParam)
			{
				case SC_SCREENSAVE:
				case SC_MONITORPOWER:
				return 0;
			}
			break;
		}
		case WM_CLOSE:
		{
			PostQuitMessage(0);
			return 0;
		}
		case WM_KEYDOWN:
		{
			keys[wParam] = TRUE;
			return 0;
		}
		case WM_KEYUP:
		{
			keys[wParam] = FALSE;
			return 0;
		}
		case WM_SIZE:
		{
			ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));
			return 0;
		}
	}
	return DefWindowProc(hWnd,uMsg,wParam,lParam);
}
int WINAPI WinMain(	HINSTANCE	hInstance,
					HINSTANCE	hPrevInstance,
					LPSTR		lpCmdLine,
					int			nCmdShow)
{
	MSG		msg;
	BOOL	done=FALSE;
	if (MessageBox(NULL,"Would You Like To Run In Fullscreen Mode?", "Start FullScreen?",MB_YESNO|MB_ICONQUESTION)==IDNO)
	{
		fullscreen=FALSE;
	}
	if (!CreateGLWindow("Banu Octavian & NeHe's Stencil & Reflection Tutorial", 640, 480, 32, fullscreen))
	{
		return 0;
	}
	getNvPosition(min_x,max_y,max_z,max_x,min_y,max_z,max_x,max_y,min_z);
	while(!done)
	{
		if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
		{
			if (msg.message==WM_QUIT)
			{
				done=TRUE;
			}
			else
			{
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
		}
		else
		{
			if (active)
			{
				if (keys[VK_ESCAPE])
				{
					done=TRUE;
				}
				else
				{
					DrawGLScene();
					SwapBuffers(hDC);
					ProcessKeyboard();
				}
			}
		}
		if(keys['W'])
			{
				changed=true;
				vy+=0.01f;
			}
            if(keys['S'])
			{
				changed=true;
				vy+=-0.01f;
			}
			if(keys['A'])
			{
				changed=true;
				vx+=-0.01f;
			}
            if(keys['D'])
			{
				changed=true;
				vx+=0.01f;
			}
			if(keys['Q'])
			{
				changed=true;
				vz+=-0.01f;
			}
			if(keys['E'])
			{
				changed=true;
				vz+=0.01f;
			}
			if(keys[VK_F2])
			{
                vx+=1.0f;
				vy+=1.0f;
				vz+=1.0f;
				changed=true;
			}
			if(keys[VK_F3])
			{
				changed=false;
				num=0.0f;
				x=0.0f;
			    y=0.0f;
				z=0.0f;
				vx=0.0f;
				vy=0.0f;
				vz=0.0f;
				startPostion_x=0.0f;
				startPostion_y=0.0f;
				startPostion_z=0.0f;
			}
			if(keys[VK_F6])
			{
				keys[VK_F6]=FALSE;
				changed=!changed;
			}
			if(changed==true)
			{
					move();
			}
			if (keys[VK_F1])
			{
				keys[VK_F1]=FALSE;
				KillGLWindow();
				fullscreen=!fullscreen;
				if (!CreateGLWindow("Banu Octavian & NeHe's Stencil & Reflection Tutorial",640,480,16,fullscreen))
				{
					return 0;
				}
			}
	}
	KillGLWindow();
	return (msg.wParam);
}



import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.tri as mtri
from scipy.spatial import Delaunay

# u, v are parameterisation variables
u = np.array([0,0,0.5,1,1])
v = np.array([0,1,0.5,0,1])

x = u
y = v
z = np.array([0,0,1,0,0])

# Triangulate parameter space to determine the triangles
#tri = mtri.Triangulation(u, v)
tri = Delaunay(np.array([u,v]).T)

print('polyhedron(faces = [')
#for vert in tri.triangles:
for vert in tri.simplices:
    print('[%d,%d,%d],' % (vert[0],vert[1],vert[2]))
print('], points = [')
for i in range(x.shape[0]):
    print('[%f,%f,%f],' % (x[i], y[i], z[i]))
print(']);')


fig = plt.figure()
ax = fig.add_subplot(1, 1, 1, projection='3d')

# The triangles in parameter space determine which x, y, z points are
# connected by an edge
#ax.plot_trisurf(x, y, z, triangles=tri.triangles, cmap=plt.cm.Spectral)
ax.plot_trisurf(x, y, z, triangles=tri.simplices, cmap=plt.cm.Spectral)


plt.show()

python yyds!!!

子小氵告木木
关注
专栏目录
dlut 可视化大作业1————椭球碰撞检测
weixin_43941795的博客
04-07 259
#include <windows.h> #include <gl\gl.h> #include <gl\glu.h> #include <gl\glaux.h> #include <stdio.h> #include<math.h> HDC hDC=NULL; HGLRC hRC=NULL; HWND hWnd=NULL; HINSTANCE hInstance = NULL; bool keys[256]; bool
dlut可视化大作业3————复变函数积分可视化
04-07
dlut可视化大作业3————复变函数积分可视化
椭球体和顶点之间的碰撞检测。
tarkey的专栏
01-26 2381
对于某些比较特殊的模型，用包围盒碰撞得到的精确度会有些偏差，尤其是在对于人物背后的披风和人物模型发生碰撞的时候，用普通的包围盒碰撞会得到非常不协调的结果。 这个时候椭球体碰撞就显得尤其的重要，那么下面我们就来看看如何判断一个椭球体和一个顶点的碰撞。 首先我们需要的是一个数据结构来描叙一个椭球体： vector3 midpoint; vector3 radius; vector3 direction
椭球碰撞检测 智能检测
04-20
椭球的碰撞检测 纯算法实现 你可以仔细想、阅读代码 虽然有些难懂 但成果会很大 坚持
可视化画凸包
08-27
这种方法要比快包方法的速度快，虽不太完善，但对于5个点以上还是很不错的，达到100000，就是点多的时候，重绘点比较慢，但画出凸包还是挺快的
C++PPT（DLUT版含上机作业）
10-28
DLUT版C++上课，内含上机作业！希望能给予您帮助
Simple-Calculator-Android：大连理工大学软件学院20级大一上学期OurEDA实验室安卓组大作业DLUT OurEDA Android分配
02-15
大连理工大学软件学院20级大一上学期OurEDA实验室安卓组大作业 项目说明 实现了一个简易的科学计算器，支持竖版的简易功能和横屏后的科学计算功能 由于只是个作业，以后随缘更新（就是不更新了的意思 另外使用的科学...
DLUT计算机二级模拟考试题三.doc
11-30
6. **for循环结构**：for循环的三个表达式（初始化、条件测试、更新）之间用逗号分隔，每个表达式后跟一个分号。 7. **数组越界**：在C语言中，访问数组的越界元素是未定义行为，所以`for (i=0;i;i++) a[i]=i;`会...
凸包的可视化程序，即使画出凸包
07-30
清楚描述出凸包，算法优良，代码清晰，基于MFC
Python——碰撞测试
surymy
11-30 7497
简单地说，碰撞测试指的是两个动画精灵何时接触或重叠。两个移动的东西相互碰到一起，这就是一个碰撞。
可视化程序设计大作业——英语背单词软件
02-15
需要手动添加excel表格至本地mysql数据库(建议通过navicat for Mysql 来导入),否则无法使用。文件附有源码，可查看。
计算几何——关于凸包的graham算法的实现并将其可视化，以及一个问题希望大神能解答
derbi123123的博客
05-27 534
graham算法是先要对顶点进行预处理： 首先通过找到起始点LTL，然后其他点按照与起始点间极角的大小排序。 然后我们利用两个堆栈来对点集中的点进行操作，先是初始化： 之后我们会对T逐个元素的扫描看其是否为极点，每次扫描后都会让问题的规模线性减少，也就是必然有一个堆栈中的一个元素被剔除（判断为非极点），最终栈S中剩下的元素就是逆时针排放好的极点集合。 代码实现： #include <iostream> #include <vector> #include <map>
Python 完美碰撞检测
qq_45209973的博客
10-09 2709
两个常见的碰撞问题及解决 圆形物体碰撞时, 默认情况下使用的是"矩形区域"去计算碰撞, 导致有时候矩形区域的"角"碰撞了, 也被判断为碰撞 解决: 圆形物体实例需要有一个 radius 属性, 即, 半径 碰撞检测的方法设置碰撞检测函数 collided=pygame.sprite.collide_circle # collide 就是第四个参数 pygame.sprite.spritecollide(ball, ball_group, True, pygame.sprite.collide
PCL 重建点云凸包并可视化
热门推荐
点云侠的博客
02-09 36万+
使用PCL1.11.1和PCL1.14.1实现的重建点云凸包并进行可视化，以及凸包面积和体积的计算。
凸包问题分治法（可视化）
weixin_45850035的博客
06-01 1002
#include <stdio.h> #include <stdlib.h> #include <math.h> #include <graphics.h> #include <time.h> #define MAX 100 int min = 0, max = 0, high, n = 40, UpOrDown, flag, frequency = 0, flag1 = 0, A1, B1;//flag标志，1表示上面还有点，0表示上面没有点;f
我的布料实时动画 + 椭球体碰撞的DEMO。
tarkey的专栏
02-05 2408
http://gd.91.com/Modules/07e890be-21a9-44d3-bc51-e3844d86d761.htm其中F2 - F4控制椭球体在x-y平面上运动。除了风力之外其他参数因为我老大不让我开放，所以暂时只开放了对风力参数的调整。 Waiting for your comments =)
【计几】三维凸包
ZhgDgE的博客
10-05 882
三维凸包算法（增量法）（时间复杂度：O(n2n^2n2)） 文章： 三维凸包模板(增量法) The Worm in the Apple 增量法（三维凸包）代码详细解释 较模板化，直接上代码（求三维凸包及其表面积）： #include<iostream> #include<cstdio> #include<cmath> #include<algorithm> using namespace std; typedef long long LL; const i
计算几何之求取三维维点集的凸包/ 凸多边形包围盒(2D、3D点集)
z444_579的博客
10-23 3089
QuickHull(二维、三维空间点专用) // 方法思路：寻找一个凸核，并慢慢扩张成一个凸体包围盒; 1. 寻找各个方向上极值点 (2D则是4个，3D则是6个) 构成凸核(注意这个凸核一定包含于最终的凸包); 2. 删除凸核内的点集; 3. 若剩余点集非空，寻找各边(3D是各面) 的最远点加入凸包(注意必定是凸包上的点); 若点集为空，结束，返回凸包; 4. 构成新的凸核，转STEP2
Python:实现lamberts ellipsoidal distance朗伯椭球距离算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
07-26 231
Python:实现lamberts ellipsoidal distance朗伯椭球距离算法(附完整源码)
DLUT计算机二级模拟考试题解析与知识点总结
本资源是一份DLUT计算机二级模拟考试题，涵盖了C语言基础和数据结构的相关知识点。以下是对部分试题的详细解析： 1. 判断题部分： - 误区：在C程序中，虽然注释通常紧跟在语句后面，但并非强制规定，注释可以独立...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值