计算机图形学实验三-openG几何图形转换

求哥哥带飞~~~

于 2023-10-24 08:58:41 发布

阅读量668

点赞数

文章标签： 1024程序员节

本文链接：https://blog.csdn.net/qq_46348492/article/details/125009721

版权

实验三openGL的几何变换
1．实验目的：
理解掌握一个 OpenGL 程序平移、旋转、缩放变换的方法。
2．实验内容：
（1）阅读实验原理，运行示范实验代码，掌握 OpenGL 程序平移、旋转、缩放变换的方
法；
（2）根据示范代码，尝试完成实验作业；
3．实验原理：
（1）OpenGL 下的几何变换
在 OpenGL 的核心库中，每一种几何变换都有一个独立的函数，所有变换都在三维空间中
定义。
平移矩阵构造函数为 glTranslate<f,d>(tx, ty, tz)，作用是把当前矩阵和一个表示移动
物体的矩阵相乘。tx, ty，tz 指定这个移动物体的矩阵，它们可以是任意的实数值，后缀为
f（单精度浮点 float）或 d（双精度浮点 double），对于二维应用来说，tz=0.0。
旋转矩阵构造函数为 glRotate<f,d>(theta, vx, vy, vz)，作用是把当前矩阵和一个表示
旋转物体的矩阵相乘。theta, vx, vy, vz 指定这个旋转物体的矩阵，物体将绕着(0,0,0)
到(x,y,z)的直线以逆时针旋转，参数 theta 表示旋转的角度。向量 v=(vx, vy，vz)的分量可以是任意的实数值，该向量用于定义通过坐标原点的旋转轴的方向，后缀为 f（单精度
浮点 float）或 d（双精度浮点 double），对于二维旋转来说，vx=0.0，vy=0.0，vz=1.
0。
缩放矩阵构造函数为 glScale<f,d>(sx, sy, sz)，作用是把当前矩阵和一个表示缩放物体
的矩阵相乘。sx, sy，sz 指定这个缩放物体的矩阵，分别表示在 x,y,z 方向上的缩放比例，
它们可以是任意的实数值，当缩放参数为负值时，该函数为反射矩阵，缩放相对于原点进行，
后缀为 f（单精度浮点 float）或 d（双精度浮点 double）。
注意这里都是说“把当前矩阵和一个表示移动<旋转, 缩放>物体的矩阵相乘”，而不是直接
说“这个函数就是旋转”或者“这个函数就是移动”，这是有原因的，马上就会讲到。
假设当前矩阵为单位矩阵，然后先乘以一个表示旋转的矩阵 R，再乘以一个表示移动的矩阵
T，最后得到的矩阵再乘上每一个顶点的坐标矩阵 v。那么，经过变换得到的顶点坐标就是((R
T)v)。由于矩阵乘法满足结合率，((RT)v) = R(Tv))，换句话说，实际上是先进行移动，
然后进行旋转。即：实际变换的顺序与代码中写的顺序是相反的。由于“先移动后旋转”和“先
旋转后移动”得到的结果很可能不同，初学的时候需要特别注意这一点。
（2）OpenGL 下的各种变换简介
我们生活在一个三维的世界——如果要观察一个物体，我们可以：
1、从不同的位置去观察它（人运动，选定某个位置去看）。（视图变换）
2、移动或者旋转它，当然了，如果它只是计算机里面的物体，我们还可以放大或缩小它（物
体运动，让人看它的不同部分）。（模型变换）
3、如果把物体画下来，我们可以选择：是否需要一种“近大远小”的透视效果。另外，我们
可能只希望看到物体的一部分，而不是全部（指定看的范围）。（投影变换）
4、我们可能希望把整个看到的图形画下来，但它只占据纸张的一部分，而不是全部（指定
在显示器窗口的那个位置显示）。（视口变换）
这些，都可以在 OpenGL 中实现。
从“相对移动”的观点来看，改变观察点的位置与方向和改变物体本身的位置与方向具有等效
性。在 OpenGL 中，实现这两种功能甚至使用的是同样的函数。
由于模型和视图的变换都通过矩阵运算来实现，在进行变换前，应先设置当前操作的矩阵为
“模型视图矩阵”。设置的方法是以 GL_MODELVIEW 为参数调用 glMatrixMode 函数，像
这样：
glMatrixMode(GL_MODELVIEW);
该语句指定一个 4×4 的建模矩阵作为当前矩阵。
通常，我们需要在进行变换前把当前矩阵设置为单位矩阵。把当前矩阵设置为单位矩阵的函
数为：
glLoadIdentity();
我们在进行矩阵操作时，有可能需要先保存某个矩阵，过一段时间再恢复它。当我们需要保
存时，调用 glPushMatrix（）函数，它相当于把当前矩阵压入堆栈。当需要恢复最近一次的保存时，调用 glPopMatrix（）函数，它相当于从堆栈栈顶弹出一个矩阵为当前矩阵。O
penGL 规定堆栈的容量至少可以容纳 32 个矩阵，某些 OpenGL 实现中，堆栈的容量实际
上超过了 32 个。因此不必过于担心矩阵的容量问题。
通常，用这种先保存后恢复的措施，比先变换再逆变换要更方便，更快速。
注意：模型视图矩阵和投影矩阵都有相应的堆栈。使用 glMatrixMode 来指定当前操作的
究竟是模型视图矩阵还是投影矩阵。

#include <GL/glut.h>
void init(void)
{
	glClearColor(1.0, 1.0, 1.0, 0.0);
	glMatrixMode(GL_PROJECTION);
	gluOrtho2D(-5.0, 5.0, -5.0, 5.0); //设置显示的范围是 X:-5.0~5.0, Y:-5.0~5.0
	glMatrixMode(GL_MODELVIEW);
}
void drawSquare(void) //绘制中心在原点，边长为 2 的正方形
{
	glBegin(GL_POLYGON); //顶点指定需要按逆时针方向
	glVertex2f(-1.0f, -1.0f);//左下点
	glVertex2f(1.0f, -1.0f);//右下点
	glVertex2f(1.0f, 1.0f);//右上点
	glVertex2f(-1.0f, 1.0f);//左上点
	glEnd();
}
void myDraw1(void)
{
	glClear(GL_COLOR_BUFFER_BIT); //清空
	glLoadIdentity(); //将当前矩阵设为单位矩阵
	glColor3f(1.0, 0.0, 0.0);
	drawSquare(); //在原点处绘制边长为 2 红色正方形
	glTranslatef(2.0, 3.0, 0.0); //向右移动 2 单位，向上移动 3 单位
	glColor3f(0.0, 1.0, 0.0);
	drawSquare(); //绘制边长为 2 绿色正方形
	glTranslatef(0.0, -3.0, 0.0); //再向下移动 3 单位
	glColor3f(0.0, 0.0, 1.0);
	drawSquare(); //绘制边长为 2 蓝色正方形
	glFlush();
}
void myDraw2(void)
{
	glClear(GL_COLOR_BUFFER_BIT); //清空
	glLoadIdentity(); //将当前矩阵设为单位矩阵
	glColor3f(1.0, 0.0, 0.0);
	drawSquare(); //在原点处绘制边长为 2 红色正方形
	glPushMatrix();
	glTranslatef(2.0, 3.0, 0.0); //向右移动 2 单位，向上移动 3 单位
	glColor3f(0.0, 1.0, 0.0);
	drawSquare(); //绘制边长为 2 绿色正方形
	glPopMatrix();
	glTranslatef(2.0, 0.0, 0.0); //再向右移动 2 单位
	glColor3f(0.0, 0.0, 1.0);
	drawSquare(); //绘制边长为 2 蓝色正方形
	glFlush();
}
void main(int argc, char** argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
	glutInitWindowPosition(0, 0);
	glutInitWindowSize(600, 600);
	glutCreateWindow("Translate 函数示例");
	init();
	glutDisplayFunc(myDraw1);
	glutMainLoop();
}

运行截图

注意理解：myDraw1（）和 myDraw2（）生成的图形完全相同，为什么？
实例2
#include <GL/glut.h>
void init(void)
{
	glClearColor(1.0, 1.0, 1.0, 0.0);
	glMatrixMode(GL_PROJECTION);
	gluOrtho2D(-5.0, 5.0, -5.0, 5.0); //设置显示的范围是 X:-5.0~5.0, Y:-5.0~5.0
	glMatrixMode(GL_MODELVIEW);
}
void drawSquare(void) //绘制中心在原点，边长为 2 的正方形
{
	glBegin(GL_POLYGON); //顶点指定需要按逆时针方向
	glVertex2f(-1.0f, -1.0f);//左下点
	glVertex2f(1.0f, -1.0f);//右下点
	glVertex2f(1.0f, 1.0f);//右上点
	glVertex2f(-1.0f, 1.0f);//左上点
	glEnd();
}
void myDraw1(void)
{
	glClear(GL_COLOR_BUFFER_BIT); //清空
	glLoadIdentity(); //将当前矩阵设为单位矩阵
	glColor3f(1.0, 0.0, 0.0);
	drawSquare(); //在原点处绘制边长为 2 红色正方形
	glTranslatef(2.0, 3.0, 0.0); //向右移动 2 单位，向上移动 3 单位
	glRotatef(30, 0.0, 0.0, 1.0); //顺时针旋转 30 角度
	glColor3f(0.0, 1.0, 0.0);
	drawSquare(); //绘制边长为 2 绿色正方形
	glLoadIdentity(); //将当前矩阵设为单位矩阵
	glTranslatef(-2.0, -3.0, 0.0); //向左移动 2 单位，向下移动 3 单位
	glRotatef(-30, 0.0, 0.0, 1.0); //逆时针旋转 30 角度
	glColor3f(0.0, 0.0, 1.0);
	drawSquare(); //绘制边长为 2 蓝色正方形
	glFlush();
}
void myDraw2(void)
{
	glClear(GL_COLOR_BUFFER_BIT); //清空
	glLoadIdentity(); //将当前矩阵设为单位矩阵
	glColor3f(1.0, 0.0, 0.0);
	drawSquare(); //在原点处绘制边长为 2 红色正方形
	glPushMatrix(); //把当前矩阵压入堆栈
	glTranslatef(2.0, 3.0, 0.0); //向右移动 2 单位，向上移动 3 单位
	glRotatef(30, 0.0, 0.0, 1.0); //顺时针旋转 30 角度
	glColor3f(0.0, 1.0, 0.0);
	drawSquare(); //绘制边长为 2 绿色正方形
	glPopMatrix(); //从堆栈栈顶弹出一个矩阵为当前矩阵
	glTranslatef(-2.0, -3.0, 0.0); //向左移动 2 单位，向下移动 3 单位
	glRotatef(-30, 0.0, 0.0, 1.0); //逆时针旋转 30 角度
	glColor3f(0.0, 0.0, 1.0);
	drawSquare(); //绘制边长为 2 蓝色正方形
	glFlush();
}
void main(int argc, char** argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
	glutInitWindowPosition(0, 0);
	glutInitWindowSize(600, 600);
	glutCreateWindow("Rotate 函数示例");
	init();
	glutDisplayFunc(myDraw1);
	glutMainLoop();
}

运行截图
在这里插入图片描述

实例3
#include <GL/glut.h>
void init(void)
{
	glClearColor(1.0, 1.0, 1.0, 0.0);
	glMatrixMode(GL_PROJECTION);
	gluOrtho2D(-5.0, 5.0, -5.0, 5.0); //设置显示的范围是 X:-5.0~5.0, Y:-5.0~5.0
	glMatrixMode(GL_MODELVIEW);
}
void drawSquare(void) //绘制中心在原点，边长为 2 的正方形
{
	glBegin(GL_POLYGON); //顶点指定需要按逆时针方向
	glVertex2f(-1.0f, -1.0f);//左下点
	glVertex2f(1.0f, -1.0f);//右下点
	glVertex2f(1.0f, 1.0f);//右上点
	glVertex2f(-1.0f, 1.0f);//左上点
	glEnd();
}
void myDraw1(void)
{
	glClear(GL_COLOR_BUFFER_BIT); //清空
	glLoadIdentity(); //将当前矩阵设为单位矩阵
	glColor3f(1.0, 0.0, 0.0);
	drawSquare(); //在原点处绘制边长为 2 红色正方形
	glTranslatef(2.0, 3.0, 0.0); //向右移动 2 单位，向上移动 3 单位
	glScalef(1.0, 1.5, 1.0); //X 和 Z 方向保持不变，Y 方向放大为原来的 1.5 倍
	glColor3f(0.0, 1.0, 0.0);
	drawSquare(); //绘制边长为 2 绿色正方形
	glLoadIdentity(); //将当前矩阵设为单位矩阵
	glTranslatef(-2.0, -3.0, 0.0); //向左移动 2 单位，向下移动 3 单位
	glScalef(0.5, 1.5, 1.0); //Z 方向保持不变，X 方向缩小为原来的 0.5 倍，Y 方向放大为原来的 1.5 倍
		glColor3f(0.0, 0.0, 1.0);
	drawSquare(); //绘制边长为 2 蓝色正方形
	glFlush();
}
void myDraw2(void)
{
	glClear(GL_COLOR_BUFFER_BIT); //清空
	glLoadIdentity(); //将当前矩阵设为单位矩阵
	glColor3f(1.0, 0.0, 0.0);
	drawSquare(); //在原点处绘制边长为 2 红色正方形
	glPushMatrix(); //把当前矩阵压入堆栈
	glTranslatef(2.0, 3.0, 0.0); //向右移动 2 单位，向上移动 3 单位
	glScalef(1.0, 1.5, 1.0); //X 和 Z 方向保持不变，Y 方向放大为原来的 1.5 倍
	glColor3f(0.0, 1.0, 0.0);
	drawSquare(); //绘制边长为 2 绿色正方形
	glPopMatrix(); //从堆栈栈顶弹出一个矩阵为当前矩阵
	glTranslatef(-2.0, -3.0, 0.0); //向左移动 2 单位，向下移动 3 单位
	glScalef(0.5, 1.5, 1.0); //Z 方向保持不变，X 方向缩小为原来的 0.5 倍，Y 方向放大为原来的 1.5 倍
		glColor3f(0.0, 0.0, 1.0);
	drawSquare(); //绘制边长为 2 蓝色正方形
	glFlush();
}
void main(int argc, char** argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
	glutInitWindowPosition(0, 0);
	glutInitWindowSize(600, 600);
	glutCreateWindow("Scale 函数示例");
	init();
	glutDisplayFunc(myDraw1);
	glutMainLoop();
}

运行截图
在这里插入图片描述

综合案例


#include <GL/glut.h>
void init(void)
{
	glClearColor(1.0, 1.0, 1.0, 0.0);
	glMatrixMode(GL_PROJECTION);
	gluOrtho2D(-5.0, 5.0, -5.0, 5.0); //设置显示的范围是 X:-5.0~5.0, Y:-5.0~5.0
	glMatrixMode(GL_MODELVIEW);
}
void drawSquare(void) //绘制中心在原点，边长为 2 的正方形
{
	glBegin(GL_POLYGON); //顶点指定需要按逆时针方向
	glVertex2f(-1.0f, -1.0f);//左下点
	glVertex2f(1.0f, -1.0f);//右下点
	glVertex2f(1.0f, 1.0f);//右上点
	glVertex2f(-1.0f, 1.0f);//左上点
	glEnd();
}
void myDraw(void)
{
	glClear(GL_COLOR_BUFFER_BIT); //清空
	glLoadIdentity(); //将当前矩阵设为单位矩阵
	glPushMatrix();
	glTranslatef(0.0f, 2.0f, 0.0f);
	glScalef(3.0, 0.5, 1.0);
	glColor3f(1.0, 0.0, 0.0);
	drawSquare(); //上面红色矩形
	glPopMatrix();
	glPushMatrix();
	glTranslatef(-3.0, 0.0, 0.0);
	glPushMatrix();
	glRotatef(45.0, 0.0, 0.0, 1.0);
	glColor3f(0.0, 1.0, 0.0);
	drawSquare(); //中间左菱形
	glPopMatrix();
	glTranslatef(3.0, 0.0, 0.0);
	glPushMatrix();
	glRotatef(45.0, 0.0, 0.0, 1.0);
	glColor3f(0.0, 0.7, 0.0);
	drawSquare(); //中间中菱形
	glPopMatrix();
	glTranslatef(3.0, 0.0, 0.0);
	glPushMatrix();
	glRotatef(45.0, 0.0, 0.0, 1.0);
	glColor3f(0.0, 0.4, 0.0);
	drawSquare(); //中间右菱形
	glPopMatrix();
	glPopMatrix();
	glTranslatef(0.0, -3.0, 0.0);
	glScalef(4.0, 1.5, 1.0);
	glColor3f(0.0, 0.0, 1.0);
	drawSquare(); //下面蓝色矩形
	glFlush();
}
void main(int argc, char** argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
	glutInitWindowPosition(0, 0);
	glutInitWindowSize(600, 600);
	glutCreateWindow("几何变换函数综合示例");
	init();
	glutDisplayFunc(myDraw);
	glutMainLoop();
}
运行截tu他t

#include <GL/glut.h>
#include <math.h>
#include<windows.h>
#include<stdio.h>
#define PI 3.14
#define DEG_TO_RAD 0.017453  //角度转为弧度的参数，即 2*PI/360

void init(void)
{
    glClearColor(1.0, 1.0, 1.0, 0.0);
    glMatrixMode(GL_PROJECTION);
    gluOrtho2D(-5.0, 5.0, -5.0, 5.0);
    glClear(GL_COLOR_BUFFER_BIT);
    glMatrixMode(GL_MODELVIEW);
}

void drawDiamond(void) //绘制中心在原点的菱形
{

    glBegin(GL_POLYGON); //顶点指定需要按逆时针方向
    glVertex2f(0.0f, -1.0f);//下点
    glVertex2f(2.0f, 0.0f);//右点
    glVertex2f(0.0f, 1.0f);//上点
    glVertex2f(-2.0f, 0.0f);//左点
    glEnd();
}
void display() {
    glClear(GL_COLOR_BUFFER_BIT); //清空

    glLoadIdentity();        //将当前矩阵设为单位矩阵
    glRotatef(90.0, 0.0, 0.0, 1.0); //顺时针旋转90角度
    glTranslatef(2.0, 0.0, 0.0);
    glColor3f(1.0f, 0.0f, 0.0f);//红色
    drawDiamond();

    glLoadIdentity();        //将当前矩阵设为单位矩阵
    glRotatef(30.0, 0.0, 0.0, 1.0);
    glTranslatef(-2.0, 0.0, 0.0);
    glColor3f(0.0f, 1.0f, 0.0f);//绿色
    drawDiamond();

    glLoadIdentity();        //将当前矩阵设为单位矩阵
    glRotatef(-30.0, 0.0, 0.0, 1.0);
    glTranslatef(2.0, 0.0, 0.0);
    glColor3f(0.0f, 0.0f, 1.0f);//蓝色
    drawDiamond();


    glFlush();
}

int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowPosition(50, 100);
    glutInitWindowSize(600, 600);
    glutCreateWindow("几何变换函数综合示例");
    init();
    glutDisplayFunc(display);
    glutMainLoop();
    return 0;
}

实验作业运行截图

求哥哥带飞~~~

关注

0
点赞
踩
12

收藏

觉得还不错? 一键收藏
打赏
0
评论
计算机图形学实验三-openG几何图形转换

实验三openGL的几何变换1．实验目的：理解掌握一个 OpenGL 程序平移、旋转、缩放变换的方法。2．实验内容：（1）阅读实验原理，运行示范实验代码，掌握 OpenGL 程序平移、旋转、缩放变换的方法；（2）根据示范代码，尝试完成实验作业；3．实验原理：（1）OpenGL 下的几何变换在 OpenGL 的核心库中，每一种几何变换都有一个独立的函数，所有变换都在三维空间中定义。平移矩阵构造函数为 glTranslate<f,d>(tx, ty, tz)，作用是把当前矩阵和
复制链接

扫一扫