OpenGL实验 逆向运动学

最新推荐文章于 2023-05-19 14:34:59 发布
最新推荐文章于 2023-05-19 14:34:59 发布
阅读量314 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_41560343/article/details/102694381
版权

光照 + 逆向运动 + 纹理


#include<GL/glut.h>
#include <iostream>
#include <cmath>
using namespace std;

GLfloat no_mat[] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat mat_ambient[] = { 0.7, 0.7, 0.7, 1.0 };
GLfloat mat_ambient_color[] = { 0.8, 0.8, 0.2, 1.0 };
GLfloat mat_diffuse[] = { 0.1, 0.2, 0.8, 1.0 };
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat no_shininess[] = { 0.5 };
GLfloat low_shininess[] = { 5.0 };
GLfloat high_shininess[] = { 100.0 };
GLfloat mat_emission[] = { 0.3, 0.2, 0.2, 0.0 };



float pyzy = 0, pyqh = 0, pysx = 0;
float times = 1;
float anglezy = 0, anglesx = 0;
float py_speed = 10;


float xx = 4, yy = 5, zz = 20;
float angle1 = 1.0, angle2 = 1.0, angle3 = 1.0;
float xOffset = 0, yOffset = 0;
float xPre = 0, yPre = 6;
float l1 = 3, l2 = 3;


#define stripeImageWidth 10
GLubyte stripeImage[4 * stripeImageWidth];

static GLuint texName;

/*  planes for texture coordinate generation  */
static GLfloat xequalzero[] = { 1.0, 0.0, 0.0, 0.0 };
static GLfloat slanted[] = { 1.0, 1.0, 1.0, 0.0 };
static GLfloat *currentCoeff;
static GLenum currentPlane;
static GLint currentGenMode;

void makeStripeImage(void) {
	int j;
	for (j = 0; j < stripeImageWidth; j++) {
		stripeImage[4 * j] = (GLubyte)((j <= 4) ? 255 : 0);
		stripeImage[4 * j + 1] = 255;//(GLubyte)((j > 4) ? 255 : 0);
		stripeImage[4 * j + 2] = (GLubyte)0;
		stripeImage[4 * j + 3] = (GLubyte)255;
	}
}

void init(void) {
	GLfloat ambient[] = { 0.5f, 0.5f, 0.5f, 1.0f }; //环境光参数，半亮白色
	GLfloat diffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f }; //漫射光参数，
	GLfloat position[] = { -10.0f, 10.0f, 0.0f, 1.0f }; //光源位置
	GLfloat lmodel_ambient[] = { 0.7, 0.7, 0.7, 1.0 };
	GLfloat local_view[] = { 0.0 };


	glClearColor(0, 0, 0, 0);

	glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
	glLightfv(GL_LIGHT0, GL_POSITION, position);
	glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
	glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, local_view);

	glShadeModel(GL_SMOOTH);
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT0);
}

void draw_belly(void) {
	glPushMatrix();

	glRotatef(angle1, 0, 0, 1);

	glColor3f(0.0, 1.0, 0.0);
	glTranslatef(0, 1, 0);
	glutSolidCube(2);


	glColor3f(0.0, 0.0, 1.0);
	glTranslatef(0, 2, 0);
	glRotatef(angle2, 0, 0, 1);
	glutWireSphere(1, 200, 500);


	makeStripeImage();

	glGenTextures(1, &texName);
	glBindTexture(GL_TEXTURE_1D, texName);

	glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);


	glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, stripeImageWidth, 0,
		GL_RGBA, GL_UNSIGNED_BYTE, stripeImage);

	//	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	currentCoeff = xequalzero;
	currentGenMode = GL_OBJECT_LINEAR;
	currentPlane = GL_OBJECT_PLANE;
	glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, currentGenMode);
	glTexGenfv(GL_S, currentPlane, currentCoeff);

	glEnable(GL_TEXTURE_GEN_S);
	glEnable(GL_TEXTURE_1D);

	glEnable(GL_AUTO_NORMAL);
	glEnable(GL_NORMALIZE);
	glFrontFace(GL_CW);

	glMaterialf(GL_FRONT, GL_SHININESS, 64.0);

	glColor3f(0.0, 1.0, 0.0);
	glTranslatef(0, 2, 0);
	glutSolidCube(2);

	glDisable(GL_TEXTURE_1D);
 
	glPopMatrix();
}

void draw_ball() {
	glPushMatrix();
	glColor3f(0.0, 0.7, 0.7);
	glTranslatef(xOffset, yOffset, 0);
	glutWireSphere(0.5, 200, 500);
	glPopMatrix();

}

void draw_move_leg(void) {
	if (xOffset*xOffset + yOffset * yOffset >= 36 || xOffset * xOffset + yOffset * yOffset <= 4) {
		printf("Wrong\n");
		return;
	}

	glPushMatrix();
	float Ja[2][2];
	Ja[0][0] = -1.0 * l1 * sin(angle1) - l2 * sin(angle1 + angle2);
	Ja[0][1] = -1.0 * l2 * sin(angle1 + angle2);
	Ja[1][0] = l1 * cos(angle1) + l2 * cos(angle1 + angle2);
	Ja[1][1] = l2 * cos(angle1 + angle2);

	float x_par = Ja[0][0] * Ja[1][1] - Ja[0][1] * Ja[1][0];
	float JaI[2][2];
	JaI[0][0] = Ja[1][1] / x_par;
	JaI[0][1] = -1 * Ja[0][1] / x_par;
	JaI[1][0] = -1 * Ja[1][0] / x_par;
	JaI[1][1] = Ja[0][0] / x_par;
	printf("%f,%f,%f,%f\n", JaI[0][0], JaI[0][0], JaI[0][1], JaI[1][0], JaI[1][1]);

	//float dy = yOffset - (6 - l1 * cos(angle1) - l2 * cos(angle1 + angle2));
	//float dx = xOffset - (-1* l1 * sin(angle1) - l2 * sin(angle1 + angle2));
	float dy = yOffset - yPre;
	float dx = xOffset - xPre;

	float theta1 = JaI[0][0] * dy + JaI[0][1] * dx;
	float theta2 = JaI[1][0] * dy + JaI[1][1] * dx;


	angle1 += theta1;
	angle2 += theta2;

	printf("%f, %f\n", xOffset, yOffset);
	printf("%f, %f\n", theta1, theta2);
	printf("%f, %f\n", angle1, angle2);
	yPre = yOffset;
	xPre = xOffset;
	glPopMatrix();
}

void draw_move(void) {
	if (xOffset*xOffset + yOffset * yOffset >= 36 || xOffset * xOffset + yOffset * yOffset <= 4) {
		printf("Wrong\n");
		return;
	}

	if (xOffset > 0) {
		yOffset = -1 * yOffset;
	}


	float summ = yOffset * yOffset + xOffset * xOffset;
	float alph3 = acos((summ - l1 * l1 - l2 * l2) / (-2 * l1*l2));
	alph3 = alph3 * 180 / 3.14;
	angle2 = 180 - alph3;
	

	float alph1 = acos((l2*l2 - l1 * l1 - summ) / (-2 * l1*sqrt(summ)));
	float alph2 = atan(yOffset / xOffset);
	alph1 = alph1 * 180 / 3.14;
	alph2 = alph2 * 180 / 3.14;
	angle1 = 90 - alph1 + alph2;

	if (xOffset >= 0) {
		angle1 = 360 - angle1;
		angle2 = 360 - angle2;
		yOffset = -1 * yOffset;

	}
	printf("%f, %f \n", xOffset, yOffset);
	printf("%f,%f \n", angle1, angle2);
}

void draw_float(void) {
	glPushMatrix();
	glColor3f(0.9f, 0.9f, 0.9f);
	glBegin(GL_QUADS);
	glVertex3f(-100.0f, -5.0f, -100.0f);
	glVertex3f(-100.0f, -5.0f, 100.0f);
	glVertex3f(100.0f, -5.0f, 100.0f);
	glVertex3f(100.0f, -5.0f, -100.0f);
	glEnd();
	glPopMatrix();
}

void draw_xyz() {
	glPushMatrix();
	glColor3f(1.0, 0.0, 0.0);
	glBegin(GL_LINES);
	glVertex3f(0.0f, -10.0f, 0.0f);         //直线起始坐标 
	glVertex3f(0.0f, 10.0f, 0.0f);         //直线结束坐标
	glEnd();
	glBegin(GL_LINES);
	glVertex3f(-10.0f, 0.0f, 0.0f);         //直线起始坐标 
	glVertex3f(10.0f, 0.0f, 0.0f);         //直线结束坐标
	glEnd();
	glBegin(GL_LINES);
	glVertex3f(0.0f, 0.0f, -10.0f);         //直线起始坐标 
	glVertex3f(0.0f, 0.0f, 10.0f);         //直线结束坐标
	glEnd();
	glPopMatrix();
}

void display(void) {
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glPushMatrix();
	glTranslatef(pyzy, pyqh, pysx);
	glScalef(times, times, times);
	glRotatef(anglezy, 0.0, 0.0, 1.0);
	glRotatef(anglesx, 1.0, 0.0, 0.0);

	draw_float();
	draw_xyz();

	draw_belly();
	draw_ball();

	glPopMatrix();
	glutSwapBuffers();
}

void reshape(int w, int h) {
	glViewport(0, 0, w, h);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrtho(-15, 15, -15, 15, -50, 30);
	//	gluPerspective(60, 1.0*w/h, 1, 10);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	//gluLookAt(r*cos(c*degree), 5, r*sin(c*degree), 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
	gluLookAt(xx, yy, zz, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
}

void keyboard(unsigned char key, int x, int y) {
	switch (key) {
	case 'a':
		angle1 += 10;
		glutPostRedisplay();
		break;
	case 's':
		angle2 += 10;
		glutPostRedisplay();
		break;

	case 'd':
		angle3 += 10;
		glutPostRedisplay();
		break;
	case 'q':
		angle1 -= 10;
		glutPostRedisplay();
		break;
	case 'w':
		angle2 -= 10;
		glutPostRedisplay();
		break;
	case 'e':
		angle3 -= 10;
		glutPostRedisplay();
		break;
	case 'i':
		xx++;
		glutPostRedisplay();
		break;
	case '8':
		anglesx -= 10.0;
		glutPostRedisplay();
		break;
	case '2':
		anglesx += 10.0;
		glutPostRedisplay();
		break;
	case '4':
		anglezy += 10.0;
		glutPostRedisplay();
		break;
	case '6':
		anglezy -= 10.0;
		glutPostRedisplay();
		break;
	case '+':
		times += 0.02f;
		glutPostRedisplay();
		break;
	case '-':
		times -= 0.02f;
		glutPostRedisplay();
		break;
	case 'W':
		pyqh += py_speed;
		glutPostRedisplay();
		break;
	case 'S':
		pyqh -= py_speed;
		glutPostRedisplay();
		break;
	case 'A':
		pyzy -= py_speed;
		glutPostRedisplay();
		break;
	case 'D':
		pyzy += py_speed;
		glutPostRedisplay();
		break;
	case 'Q':
		pysx -= py_speed;
		glutPostRedisplay();
		break;
	case 'E':
		pysx += py_speed;
		glutPostRedisplay();
		break;
	case 'R':
		pysx = pyzy = pyqh = anglezy = anglesx = 0.0;
		times = 1.0;
		glutPostRedisplay();
		break;

	case 'z':
		draw_move();
		glutPostRedisplay();
		break;
	}


}

void SpecialKey(GLint key, GLint x, GLint y) {
	if (key == GLUT_KEY_UP) {
		yOffset += 0.2;
		draw_move();
		glutPostRedisplay();
	}
	if (key == GLUT_KEY_LEFT) {
		xOffset -= 0.2;
		draw_move();
		glutPostRedisplay();
	}
	if (key == GLUT_KEY_DOWN) {
		yOffset -= 0.2;
		draw_move();
		glutPostRedisplay();
	}
	if (key == GLUT_KEY_RIGHT) {
		xOffset += 0.2;
		draw_move();
		glutPostRedisplay();
	}
	glutPostRedisplay();
}



int main(int argc, char** argv) {

	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RED | GLUT_RGBA);
	glutInitWindowSize(600, 600);
	glutInitWindowPosition(100, 100);
	glutCreateWindow(argv[0]);
	init();
	glutDisplayFunc(display);
	glutReshapeFunc(reshape);

	glutKeyboardFunc(keyboard);
	glutSpecialFunc(SpecialKey);
	glutMainLoop();
	return 0;
}

读取off文件并呈现

// lab2_sam.cpp : 
//

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include <assert.h>
#include <time.h>

#include<string>
#include<vector>
#include<iostream>
using namespace std;

// Windows include files 

#ifdef _WIN32
#include <windows.h>
#endif



// OpenGL include files 

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

float pyzy = 0, pyqh = 0, pysx = 0;
float times = 1;
float anglezy = 0, anglesx = 0;
float py_speed = 0.3;

typedef struct Vertex
{
	float x,y,z;
}Vertex;

typedef struct Facep
{
	int num;
	int order[3];
}Facep;

//static char *filename="boxcube.off";
static char *filename = "bird.off";

Vertex ver[10000];
Facep fap[20000];
int i,j,k,n_node,n_face,n_edge;
float scale=1,spin=0;
static int window_height = 800;
static int window_width = 800;

int readoff(const char* filename){
	FILE *fp;
	
	if(!(fp=fopen(filename,"r"))){
		fprintf(stderr,"Open fail");
		return 0;
	}


    char buffer[1024];
	if(fgets(buffer,1023,fp)){

		if(!strstr(buffer,"OFF")){
				printf("It's not a OFF FILE");
				return 0;
		}
		
		if(fgets(buffer,1023,fp)){

			sscanf(buffer,"%d %d %d",&n_node,&n_face,&n_edge);
			
			for(i=0;i<n_node;i++){
				fgets(buffer,1023,fp);
				sscanf(buffer,"%f %f %f",&ver[i].x,&ver[i].y,&ver[i].z);
			}

			for(i=0;i<n_face;i++){
				fgets(buffer,1023,fp);
				sscanf(buffer,"%d %d %d %d",&fap[i].num,&fap[i].order[0],&fap[i].order[1],&fap[i].order[2]);
			}
		}

    }
}


void redraw(void){

	glClearColor(0.0, 0.0, 0.0, 0.0);
    
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	glScalef(scale,scale,scale);
	glTranslatef(pyzy, pyqh, pysx);
	glRotatef(spin, 0.0, 0.0, 1.0);
	glRotatef(anglezy, 0.0, 0.0, 1.0);
	glRotatef(anglesx, 1.0, 0.0, 0.0);


	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glColor3f(1.0,0.0,0.0);

	glBegin(GL_TRIANGLES);
	for(i=0;i<n_face;i++){

		int count=fap[i].order[0];

		glVertex3f(ver[count].x,ver[count].y,ver[count].z);
		count=fap[i].order[1];

		glVertex3f(ver[count].x,ver[count].y,ver[count].z);
		count=fap[i].order[2];

		glVertex3f(ver[count].x,ver[count].y,ver[count].z);
	}

	glEnd();
	glFlush();
	glutSwapBuffers();


}

void keyboard(unsigned char key, int x, int y){
	switch(key){
	   case 'p':glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);glutPostRedisplay();break;
       case 'l':glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);glutPostRedisplay();break;
       case 'f':glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);glutPostRedisplay();break;
	   case 'q':exit(1); break;
	   case 'z':
		   spin+=10;
		   glutPostRedisplay();
		   break;
	   case 'x':
		   spin-=10;
		   glutPostRedisplay();
		   break;
	   case 'c':
		   scale+=0.1;
		   glutPostRedisplay();
		   break;
	   case 'v':
		   scale-=0.1;
		   glutPostRedisplay();
		   break;
	   case '+':
		   times += 0.02f;
		   glutPostRedisplay();
		   break;
	   case '-':
		   times -= 0.02f;
		   glutPostRedisplay();
		   break;
	   case 'W':
		   pyqh += py_speed;
		   glutPostRedisplay();
		   break;
	   case 'S':
		   pyqh -= py_speed;
		   glutPostRedisplay();
		   break;
	   case 'A':
		   pyzy -= py_speed;
		   glutPostRedisplay();
		   break;
	   case 'D':
		   pyzy += py_speed;
		   glutPostRedisplay();
		   break;
	   case 'Q':
		   pysx -= py_speed;
		   glutPostRedisplay();
		   break;
	   case 'E':
		   pysx += py_speed;
		   glutPostRedisplay();
		   break;
	   case 'R':
		   pysx = pyzy = pyqh = anglezy = anglesx = 0.0;
		   times = 1.0;
		   glutPostRedisplay();
		   break;
	}
}

void mouse(int button,int state,int x,int y){
	if(button==GLUT_LEFT_BUTTON && state==GLUT_DOWN){
		scale*=1.1;
		glutPostRedisplay();
	}
	if(button==GLUT_RIGHT_BUTTON && state==GLUT_DOWN){
		
		for(i=0;i<10;i++){
			spin=spin+1;
		    glutPostRedisplay();
			glFlush();
		}
	}
}

void SpecialKey(GLint key, GLint x, GLint y) {
	if (key == GLUT_KEY_UP) {
		anglesx += 10.0;
		glutPostRedisplay();
	}
	if (key == GLUT_KEY_LEFT) {
		anglezy += 10.0;
		glutPostRedisplay();
	}
	if (key == GLUT_KEY_DOWN) {
		anglesx -= 10.0;
		glutPostRedisplay();
	}
	if (key == GLUT_KEY_RIGHT) {
		anglezy -= 10.0;
		glutPostRedisplay();
	}
	glutPostRedisplay();
}

void init(int *argc, char **argv){
	// Open window 
	glutInit(argc, argv);
	glutInitWindowPosition(100, 100);
	glutInitWindowSize(window_width, window_height);
 
	glutCreateWindow("OFF MADE BY SAM JJX");

	// Initialize GLUT callback functions 
	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	//glutReshapeFunc(GLUTResize);
	glutDisplayFunc(redraw);
	glutKeyboardFunc(keyboard);
	glutMouseFunc(mouse);
	glutSpecialFunc(SpecialKey);
	glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
	//glutMotionFunc(motion);
	glutIdleFunc(0);

}

int main(int argc, char** argv)
{
	init(&argc,argv);
	
	readoff(filename);
	glutMainLoop();
	return 0;
}
華灯初上
关注
专栏目录
正向运动学和反向运动学
开发游戏，辉煌全中国
11-01 1万+
上次制作的骨骼动画例子程序并不完美，我在程序里面也说了，因为没有牵涉到反向运动学的知识，所以人物运动起来感觉脚无法收缩、头发无法飘逸的感觉。其实在现实中这样的情况是要避免的，但是由于在动画设计的时候要指定每一个关节，显得非常费事。所以引入了反向运动学这个概念。在介绍反向运动学之前，首先让我们看一下正向运动学。          正向运动学，通俗来说是给定父骨骼位置以及它的变换来得出子骨骼的位置以及变换，打一个比方，就像运动手臂，可以带动手肘，进而带动手掌运动。正向运动学的概念是非常容易理解的，实现起来也比
Opengl机器人运动学
03-03
最近开始接触了opengl，学了机器人的运动学，求正解与反解，3d图片导入，以及DH建模，机器人运动仿真系统。 下面是我学习成果和一些在网上找到的参考资料，对于刚开始接触机器人运动学的小伙伴们是非常有帮助的。
opengl反向z
最新发布
周航的专栏
05-19 161
【代码】opengl反向z。
反向运动学演示程序（含核心代码）
11-02
此资源是演示程序，但内部已将核心代码嵌入我已将代码写入程序中，需要的同行们可以下载。 ------------------------------------------------------------ 周五的时间总是美好的，今天也将自己制作的演示程序收官了。这篇文章是上一篇文章的继续，向大家介绍一下如何使用循环坐标下降（cyclic coordinate decent，CCD）算法来求解反向运动学问题。 注意到了没有？我们要解决的问题属于刚体运动学范畴，所以一切涉及到形变的因素都不用考虑，因此我们既可以使用四元数和一个向量表示骨骼的位置和平移，也可以将两者结合起来使用一个矩阵表示骨骼的所有变换。学过计算机图形学的同学都知道，旋转分量和平移分量是互不影响的，所以可以简单地分别将旋转和平移叠加来表示累次旋转和累次平移。
OpenGl学习之钢体运动
zhouzhouzf的专栏
09-15 2014
#include #include #include #include GLsizei winWidth = 600,winHeight = 600; GLfloat xwcmin = 0.0; GLfloat ywcmax = 225.0; GLfloat xwcmax = 255.0; GLfloat ywxmin = 0.0; class wcPt2d{ public: GLf
OpenGL实现的运动的小汽车
05-14
c++下基于opengl实现的运动的小汽车，一个简单的小例子，很适合初学opengl的同学，带注释。简单的画点画面 以及一些入门的函数 例如键盘回调函数 定时器等等。
用Delphi开发的逆向运动学程序
06-12
逆向运动学（Inverse Kinematics, IK）是计算机图形学中的一个重要概念，特别是在3D动画和游戏开发领域。它允许开发者根据目标位置或方向来计算角色的关节角度，以使角色的手、脚或其他部位准确地指向或触及目标。...
6R机器人工具端的运动学建模及仿真.pdf
08-14
本文档通过分析一个特定的机器人——三菱RV-13FL-D的运动学模型，演示了如何将工具坐标系从机器人连杆坐标系中分离，求解正向和逆向运动学，并利用OpenGL图形库完成仿真实验。最终验证了所提出的轨迹规划方法的可行...
服务机器人拟人臂和底盘运动学建模.pdf
09-21
实验部分，作者利用OpenGL和VC6.0进行了四轴拟人手臂的仿真，验证了所建立的正向和逆向运动学模型的正确性。OpenGL是一个开放图形库，常用于图形渲染和三维建模，而VC6.0是Visual C++的一个早期版本，用于编写和调试...
正逆运动学
热门推荐
weixin_39090239的博客
05-19 1万+
1、在机器人实际应用中，逆运动学往往更有用，这里可参看：http://blog.sina.com.cn/s/blog_131fa47b20102whij.html（选中后，右键转到.....）。机器人学导论中第三章和第四章亦可见。 2、逆运动学：如果知道一个物体的笛卡尔坐标位姿，那么机器人需要怎样的关节坐标才能接近这个物体。   以下主要说明 一般逆解不唯一： 以PUMA560模型为例（md...
几种三维模型文件在OpenGL中的输入与处理
07-18
几种三维模型文件在OpenGL中的输入与处理
机器人运动学(资料与源代码)-----基于OpenGL的三维重建
ZhangXiaoyu_sy的博客
03-03 3411
资料地址：https://github.com/ZhangChaoZhong/OpenGL 最近开始接触了opengl，学了机器人的运动学，求正解与反解，3d图片导入，以及DH建模，机器人运动仿真系统。 下面是我学习成果和一些在网上找到的参考资料，对于刚开始接触机器人运动学的小伙伴们是非常有帮助的。 这个存在一些bug。 这个存在一些bug。 相关资料下载链接:有需要的...
机器人的设计与逆运动学仿真
大胡子的博客
05-09 1872
更多AI资源请关注公众号：大胡子的AI 欢迎各位AI爱好者加入群聊交流学习：882345565（内有大量免费资源哦！） 版权声明：本文为博主原创文章，未经博主允许不得转载。如要转载请与本人联系。 ...
V-rep学习笔记：机器人逆运动学数值解法（The Jacobian Transpose Method）
weixin_34113237的博客
10-10 1499
　　机器人运动学逆解的问题经常出现在动画仿真和工业机器人的轨迹规划中：We want to know how the upper joints of the hierarchy would rotate if we want the end effector to reach some goal. IK Solutions： Analytical solutions are desirable...
骨骼动画反向动力学(IK)的实现
weixin_30765505的博客
04-02 1292
http://multi-crash.com/?p=45 反向动力学，Inverse Kinematics，简称IK。简单地说，由父骨骼的方位和子骨骼的相对变换得到子骨骼的方位，称为正向动力学（Forward Kinematics，FK）；而IK则是先确定子骨骼的方位，反向推导出其继承链上n级父骨骼方位的方法。 IK在游戏里最常见的应用是foot placement，就是当角色站...
【OpenGL】02 - OpenGL中的坐标系
ronintao的专栏
06-30 1万+
【目标】：学习OpenGL中的坐标系统。   【参考】： 1、《计算机图形学(OpenGL版) （第三版）》 Francis著 （本文主要涉及第三章~第七章） 2、《计算机图形学(OpenGL版) （第三版）》 Donald著   一、前言         坐标系应该是任何图像系统的基石。在学习Cocos2D的过程中，对着《权威指南》上草草结束的坐标系介绍，实在是看的一头雾水，找了本
【spine】反向动力学 Inverse Kinematics (IK)
weixin_34358365的博客
08-14 750
通常情况下，我们使用FK工具设置动画，它是正向动力学的缩写。当设置手部位置动画时，FK从上至下驱动，先转动大臂，再转动小臂来实现。大多数情况下它能很好的达到我们想要的效果。但某些特殊情况比如：一个坐着的角色手扶桌面，慢慢起身，这时FK需要不段的调整手部的位置，以使其能保持按在桌面上。这将需要创建大量关键帧来实现。IK对于这种情况会更合适，它是反向动力学的缩写。IK从下至上驱动...
游戏中反向运动学(ik)的研究与简介
weixin_30702413的博客
11-12 715
　反向运动学(ik)，英文名称是inverse kinematics，主要应用在机器人手臂操作及计算机动画等领域，它与正向运动学即fk是相反的过程，具体定义在此不多说，感兴趣的可以看下wikipedia对于ik的定义。本文主要讲述一下我所看过的求解ik的方法。求解Ik的方法主要分为两种，一种是分析法，即通过三角函数等进行分析计算，对于骨骼数少的可以进行此种运算，但是对于链很长的情况，用此方法就行不...
OpenGL实验：几何图形变换探索
"该实验报告涉及的是计算机图形学领域，主要使用OpenGL库在VC++环境中进行几何图形的变换实验。实验旨在让学生掌握计算机图形变换的基本理论和方法，包括二维和三维图形的几何变换，如平移、比例、旋转等。实验内容...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值