计算及图形学——实验四

最新推荐文章于 2022-11-25 15:47:53 发布
最新推荐文章于 2022-11-25 15:47:53 发布
阅读量3.2k 收藏 4
点赞数 5
文章标签： 图形学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44049693/article/details/111247073
版权

题一

// 提示：在合适的地方修改或添加代码
#include <GL/freeglut.h>
#include<stdio.h>
#include<iostream>
// 评测代码所用头文件-开始
#include<opencv2/core/core.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
using namespace std;
// 评测代码所用头文件-结束
// 请在此添加你的代码
/********** Begin ********/
GLfloat points1[4][3] = {{-1,0,1},{1,0,1},{0,0,-0.7},{0,1.7,0}};
GLfloat Colors1[4][3] = {{0,1,0},{1,0,0},{1,1,0},{0,0,1}};
int vertice1[4][3] = {{0,1,2},{1,2,3},{0,2,3},{0,1,3}};
/********** End **********/
void InitGL(GLvoid)
{
    glShadeModel(GL_SMOOTH);
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    glClearDepth(1.0f);
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);
    glEnable(GL_COLOR_MATERIAL);
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
}
void Create()                //创建三棱锥
{
    glBegin(GL_TRIANGLES);
    for (int i = 0; i < 4; i++)
    {
        glColor3fv(Colors1[i]);
        for (int j = 0; j < 3; j++)
        {
            int VtxId = vertice1[i][j];
            glVertex3fv(points1[VtxId]);
        }
    }
    glEnd();
}
void display(void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();	               
    // 请在此添加你的代码
    /********** Begin ********/
    glPushMatrix();
    glTranslatef(0.0f,0.2f,-3.0f);	//平移至左侧
    glRotatef(95.0,1.0,0.0,0.0);
    /********** End **********/
    Create(); 	              //三棱锥
    glPopMatrix();
    glutSwapBuffers();
}
void reshape(int width, int 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();
}

int main(int argc, char *argv[])
{
	GLubyte* pPixelData = (GLubyte*)malloc(400 * 400 * 3);//分配内存
    GLint viewport[4] = {0};
	glutInit(&argc, argv);
	glutInitWindowPosition(100, 100);
	glutInitWindowSize(400, 400);
	glutCreateWindow("几何变换示例");
    InitGL();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutMainLoopEvent();     
     
    /*************以下为评测代码，与本次实验内容无关，请勿修改**************/
    glReadBuffer(GL_FRONT);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
    glGetIntegerv(GL_VIEWPORT, viewport);
    glReadPixels(viewport[0], viewport[1], viewport[2], viewport[3], GL_RGB, GL_UNSIGNED_BYTE, pPixelData);
    cv::Mat img;
    std::vector<cv::Mat> imgPlanes;
    img.create(400, 400, CV_8UC3);
    cv::split(img, imgPlanes);

    for (int i = 0; i < 400; i++) {
        unsigned char* plane0Ptr = imgPlanes[0].ptr<unsigned char>(i);
        unsigned char* plane1Ptr = imgPlanes[1].ptr<unsigned char>(i);
        unsigned char* plane2Ptr = imgPlanes[2].ptr<unsigned char>(i);
        for (int j = 0; j < 400; j++) {
            int k = 3 * (i * 400 + j);
            plane2Ptr[j] = pPixelData[k];
            plane1Ptr[j] = pPixelData[k + 1];
            plane0Ptr[j] = pPixelData[k + 2];
        }
    }
    cv::merge(imgPlanes, img);
    cv::flip(img, img, 0);
    cv::namedWindow("openglGrab");
    cv::imshow("openglGrab", img);
    //cv::waitKey();
    cv::imwrite("../img_step1/test.jpg", img);
    return 0;
}

题二(别人的代码，我的画好过不来，我看了看画球的函数不一样，参数一样)

// 提示：在合适的地方修改或添加代码
#include <GL/freeglut.h>
#include<stdio.h>

// 评测代码所用头文件-开始
#include<opencv2/core/core.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
// 评测代码所用头文件-结束

GLint winWidth = 500, winHeight =500 ; 	      //设置初始化窗口大小

/*观察坐标系参数设置*/
GLfloat x0 = 2.0, yy = 2.0, z0 = 5.0;	   //设置观察坐标系原点 
GLfloat xref = 0.0, yref = 0.0, zref = 0.0;	//设置观察坐标系参考点（视点） 
GLfloat Vx = 0.0, Vy = 1.0, Vz = 0.0;	   //设置观察坐标系向上向量（y轴） 

/*观察体参数设置 */
GLfloat xwMin = -1.0, ywMin = -1.0, xwMax = 1.0, ywMax = 1.0;//设置裁剪窗口坐标范围
GLfloat dnear = 1.5, dfar = 20.0;	      //设置远、近裁剪面深度范围

void init(void)
{
    glClearColor(0.0, 0.0, 0.0, 0.0);
}
void display(void)
{
    glClear(GL_COLOR_BUFFER_BIT);

    glLoadIdentity();
    /*观察变换*/
    gluLookAt(x0, yy, z0, xref, yref, zref, Vx, Vy, Vz);        //指定三维观察参数

    // 请在此添加你的代码
    /********** Begin ********/

    glPushMatrix();
    glColor3f(1.0,1.0,1.0);
    glTranslatef(0.0f,1.4f,0.0f); // 脖子
    glScalef(0.5,0.7,0.5);
    glutSolidCube(0.5);
    glPopMatrix();


    glPushMatrix();
    glColor3f(1.0, 0.5, 0.2);
    glTranslatef(0.0f,1.9f,0.0f); // 头
    glScalef(1.5,1.5,0.5);
    glutSolidCube(0.5);
    glPopMatrix();

    glPushMatrix();
    glColor3f(1.0,0.0,0.0);
    glTranslatef(0.0f,0.25f,0.0f); // 身体
    glScalef(4.0,4.0,0.5);
    glutSolidCube(0.5);
    glPopMatrix();

    glPushMatrix();
    glColor3f(1.0, 1.0, 0.0);
    glTranslatef(-1.25f,0.5f,0.0f); // 手
    glScalef(1.0,3.0,0.5);
    glutSolidCube(0.5);
    glPopMatrix();
    glPushMatrix();
    glColor3f(1.0, 1.0, 0.0);
    glTranslatef(1.25f,0.5f,0.0f); 
    glScalef(1.0,3.0,0.5);
    glutSolidCube(0.5);
    glPopMatrix();

    glPushMatrix();
    glColor3f(0.5,0.5,1.5);  // 腿
    glTranslatef(-0.5f,-1.5f,0.0f); 
    glScalef(1.0,3.0,0.5);
    glutSolidCube(0.5);
    glPopMatrix();

    glPushMatrix();
    glColor3f(0.5,0.5,1.5);
    glTranslatef(0.5f,-1.5f,0.0f); 
    glScalef(1.0,3.0,0.5);
    glutSolidCube(0.5);
    glPopMatrix();

    GLUquadricObj *sphere;  //定义二次曲面对象
    sphere=gluNewQuadric(); 

    glPushMatrix();  // 球
    glColor3f(1.0, 0.5, 0.2);
    glTranslatef(-1.25f,-0.5f,0.0f); 
    glScalef(1,1.5,1);
    gluSphere(sphere,0.25,50,50);
    glPopMatrix();
    glPushMatrix();
    glColor3f(1.0, 0.5, 0.2);
    glTranslatef(1.25f,-0.5f,0.0f); 
    glScalef(1,1.5,1);
    gluSphere(sphere,0.25,50,50);
    glPopMatrix();

    /********** End **********/
    glFlush();
}

void reshape(GLint newWidth, GLint newHeight)
{
    /*视口变换*/
    glViewport(0, 0, newWidth, newHeight);	//定义视口大小

    /*投影变换*/
    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    /*透视投影，设置透视观察体*/
	glFrustum(xwMin, xwMax, ywMin, ywMax, dnear, dfar);

    /*模型变换*/
    glMatrixMode(GL_MODELVIEW);
    
    winWidth = newWidth;
    winHeight = newHeight;
}
int main(int argc, char* argv[])
{
    GLubyte* pPixelData = (GLubyte*)malloc(500 * 500 * 3);//分配内存
    GLint viewport[4] = { 0 };
    glutInit(&argc, argv);
    glutInitWindowPosition(100, 100);
    glutInitWindowSize( 500 , 500 );        //设置初始化窗口大小
    glutCreateWindow("三维观察");
    init();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutMainLoopEvent();





    /*************以下为评测代码，与本次实验内容无关，请勿修改**************/
    glReadBuffer(GL_FRONT);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
    glGetIntegerv(GL_VIEWPORT, viewport);
    glReadPixels(viewport[0], viewport[1], viewport[2], viewport[3], GL_RGB, GL_UNSIGNED_BYTE, pPixelData);
    cv::Mat img;
    std::vector<cv::Mat> imgPlanes;
    img.create(500, 500, CV_8UC3);
    cv::split(img, imgPlanes);

    for (int i = 0; i < 500; i++) {
        unsigned char* plane0Ptr = imgPlanes[0].ptr<unsigned char>(i);
        unsigned char* plane1Ptr = imgPlanes[1].ptr<unsigned char>(i);
        unsigned char* plane2Ptr = imgPlanes[2].ptr<unsigned char>(i);
        for (int j = 0; j < 500; j++) {
            int k = 3 * (i * 500 + j);
            plane2Ptr[j] = pPixelData[k];
            plane1Ptr[j] = pPixelData[k + 1];
            plane0Ptr[j] = pPixelData[k + 2];
        }
    }
    cv::merge(imgPlanes, img);
    cv::flip(img, img, 0);
    cv::namedWindow("openglGrab");
    cv::imshow("openglGrab", img);
    //cv::waitKey();
    cv::imwrite("../img_step2/test.jpg", img);
    return 0;
}

题三

// 提示：在合适的地方修改或添加代码
#include <GL/freeglut.h>
#include<stdio.h>
#include <stdlib.h>
#include <vector>
// 评测代码所用头文件-开始
#include<opencv2/core/core.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
// 评测代码所用头文件-结束


using namespace std;

struct Point
{
	int x, y;
};

Point bz[11], bspt[11];     //bz为Bezier曲线，bspt为B样条曲线

int nInput;
//Bezier曲线控制点
Point pt[4] = { { 50, 100}, { 140,300},{250, 320}, {290, 120} };
//B样条曲线控制点
/**********请在此处添加你的代码*******/
 /************** Begin ************/
Point pt2[4]={ { 450, 100}, { 540,300},{650, 320}, {690, 120}  };
/*************** end **************/

void CalcBZPoints()                              //Bezier曲线算法
{
	float a0, a1, a2, a3, b0, b1, b2, b3;
	a0 = pt[0].x;
	a1 = -3 * pt[0].x + 3 * pt[1].x;
	a2 = 3 * pt[0].x - 6 * pt[1].x + 3 * pt[2].x;
	a3 = -pt[0].x + 3 * pt[1].x - 3 * pt[2].x + pt[3].x;
	b0 = pt[0].y;
	b1 = -3 * pt[0].y + 3 * pt[1].y;
	b2 = 3 * pt[0].y - 6 * pt[1].y + 3 * pt[2].y;
	b3 = -pt[0].y + 3 * pt[1].y - 3 * pt[2].y + pt[3].y;

	float t = 0;
	float dt = 0.01;
	for (int i = 0; t < 1.1; t += 0.1, i++)
	{
		bz[i].x = a0 + a1 * t + a2 * t * t + a3 * t * t * t;
		bz[i].y = b0 + b1 * t + b2 * t * t + b3 * t * t * t;
	}
}


void CalcBSPoints()                          //B样条曲线
{
/**********请在此处添加你的代码*******/
 /************** Begin ************/
    float a0, a1, a2, a3, b0, b1, b2, b3;
	a0 = pt2[0].x + 4 * pt2[1].x + pt2[2].x;
	a1 = -3 * pt2[0].x + 3 * pt2[2].x;
	a2 = 3 * pt2[0].x - 6 * pt2[1].x + 3 * pt2[2].x;
	a3 = -pt2[0].x + 3 * pt2[1].x - 3 * pt2[2].x + pt2[3].x;
	b0 = pt2[0].y + 4 * pt2[1].y + pt2[2].y;
	b1 = -3 * pt2[0].y + 3 * pt2[2].y;
	b2 = 3 * pt2[0].y - 6 * pt2[1].y + 3 * pt2[2].y;
	b3 = -pt2[0].y + 3 * pt2[1].y - 3 * pt2[2].y + pt2[3].y; 

	float t = 0;
	float dt = 0.01;
	for (int i = 0; t < 1.1; t += 0.1, i++)
	{
		bspt[i].x =  ( a0 + a1 * t + a2 * t * t + a3 * t * t * t ) / 6;
		bspt[i].y =  ( b0 + b1 * t + b2 * t * t + b3 * t * t * t ) / 6;
	}
}
/************* end ************/
void ControlPoint()
{
	glPointSize(2);
	for (int i = 0; i < 4; i++)
	{
		glBegin(GL_POINTS);
		glColor3f(1.0f, 0.0f, 0.0f);
		glVertex2i(pt[i].x, pt[i].y);
		glEnd();
	
	}
}

void PolylineGL(Point* pt, int num)
{
	glBegin(GL_LINE_STRIP);
	for (int i = 0; i < num; i++)
	{   
		glColor3f(0.0f, 1.0f, 0.0f);
		glVertex2i(pt[i].x, pt[i].y);
	}
	glEnd();
}
void PolylineGL1(Point* pt, int num)
{
	glBegin(GL_LINE_STRIP);
	for (int i = 0; i < num; i++)
	{   
		glColor3f(1.0f, 1.0f, 1.0f);
		glVertex2i(pt[i].x, pt[i].y);
	}
	glEnd();
}

void display()
{
	glClear(GL_COLOR_BUFFER_BIT);
	glColor3f(1.0f, 1.0f, 1.0f);

	ControlPoint();              //画4个控制点

	PolylineGL1(pt, 4);           //画4个点之间的线段

	CalcBZPoints();

	PolylineGL(bz, 11);

	PolylineGL1(pt2, 4);

	CalcBSPoints();

	PolylineGL(bspt, 11);

	glFlush();
}

void init()
{
	glClearColor(0.0, 0.0, 0.0, 0.0);
	glShadeModel(GL_SMOOTH);
}

void reshape(int w, int h)
{
	glViewport(0, 0, (GLsizei)w, (GLsizei)h);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluOrtho2D(0.0, (GLdouble)w, 0.0, (GLdouble)h);
}




int main(int argc, char* argv[])
{
    GLubyte* pPixelData = (GLubyte*)malloc(800 * 400 * 3);//分配内存
    GLint viewport[4] = { 0 };
    glutInit(&argc, argv);
    glutInitWindowPosition(100, 100);
    glutInitWindowSize( 800 , 400 );        //设置初始化窗口大小
    glutCreateWindow("三维观察");
    init();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutMainLoopEvent();





    /*************以下为评测代码，与本次实验内容无关，请勿修改**************/
    glReadBuffer(GL_FRONT);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
    glGetIntegerv(GL_VIEWPORT, viewport);
    glReadPixels(viewport[0], viewport[1], viewport[2], viewport[3], GL_RGB, GL_UNSIGNED_BYTE, pPixelData);
    cv::Mat img;
    std::vector<cv::Mat> imgPlanes;
    img.create(400, 800, CV_8UC3);
    cv::split(img, imgPlanes);

    for (int i = 0; i < 400; i++) {
        unsigned char* plane0Ptr = imgPlanes[0].ptr<unsigned char>(i);
        unsigned char* plane1Ptr = imgPlanes[1].ptr<unsigned char>(i);
        unsigned char* plane2Ptr = imgPlanes[2].ptr<unsigned char>(i);
        for (int j = 0; j < 800; j++) {
            int k = 3 * (i * 800 + j);
            plane2Ptr[j] = pPixelData[k];
            plane1Ptr[j] = pPixelData[k + 1];
            plane0Ptr[j] = pPixelData[k + 2];
        }
    }
    cv::merge(imgPlanes, img);
    cv::flip(img, img, 0);
    cv::namedWindow("openglGrab");
    cv::imshow("openglGrab", img);
    //cv::waitKey();
    cv::imwrite("../img_step3/test.jpg", img);
    return 0;
}
山上有强强
关注
  • 5
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
计算机图形学（Intro/Math）
John Raymond的博客
02-01 700
Introduction 图形学领域 三大主要领域： 建模：用计算机能存储的格式描述物体的形状和外表性质 渲染：从3D模型创建图像 动画：从一系列图像中创建运动效果，同时使用建模和渲染 下列是否是图形学核心领域仍存疑 人机交互：(研究设备的界面以及其他可感知的反馈) 虚拟现实、数据可视化、图像处理、3D扫描、计算 主要应用 游戏：越来越多使用复杂3D模型和渲染算法 卡通：很多传统2D卡通也用3D渲...
计算机图形学实验四
weixin_34296641的博客
05-12 377
#include <gl/glut.h> static GLsizei iMode = 1; static GLfloat xRot = 0.0f; static GLfloat yRot = 0.0f; int winWidth = 400, winHeight = 200; int iPointNum = 0; int x1=0,...
图形学入门
weixin_30908103的博客
11-09 260
转载自http://www.cppblog.com/lai3d/archive/2008/12/30/70796.htmltemp_span3D图形学的学习策略感谢七星重剑 from http://www.cppblog.com/ 以我现在的水平观之,3D图形学分3大块的学习内容: a.空间几何数学:空间几何变换,加速算法,多边形技术,曲线和曲面,相交测试,碰撞测试。 b.光...
图形学
lushixin118118的专栏
06-04 235
二位图形学   逻辑坐标设备坐标和屏幕坐标 投影   锯齿
计算机图形学——基于MFC三维图形开发 孔令德版
03-06
在本资源中，"计算机图形学——基于MFC三维图形开发 孔令德版"，作者孔令德提供了一套针对MFC（Microsoft Foundation Classes）框架的三维图形编程教程，帮助学习者深入理解计算机图形学在实际应用中的实现方式。...
计算机图形学实验——真实感图形场景的生成.doc
04-26
"计算机图形学实验——真实感图形场景的生成" 本实验旨在创建一个真实感的图形场景，通过OpenGL框架和C++语言实现。实验的主要内容包括创建一个简单的场景，场景中有一个复杂的三维几何体，并通过一系列处理使得...
图形学大实验报告_计算机图形学_
09-30
这样的实验设计能够帮助我们理解和应用图形学中的关键概念和技术。 首先，要创建这样一个动态场景，我们需要对三维空间中的坐标系统有深入理解。球体的位置、速度和方向都将用向量表示，这些向量在坐标轴上变化，...
虚拟现实技术中计算机图形学的应用——三维计算机图形.pdf
10-10
"虚拟现实技术中计算机图形学的应用——三维计算机图形" 虚拟现实技术是在计算机图形学的基础上发展起来的一种新型技术，它使用户可以通过计算机模拟产生一个三维空间的虚拟世界，提供使用者关于视觉、听觉、触觉等...
计算机图形学实验二多边形有效边表填充算法
05-05
计算机图形学是信息技术领域的一个重要分支，主要研究如何在计算机中表示、处理和显示图形。在实际应用中，如游戏开发、3D建模、视觉效果等，填充多边形是一项基础但至关重要的任务。本实验——“多边形有效边表填充...
计算机图形学
11-24
计算机图形学第三版 注意涵盖图形学开发的方方面面，是经典书籍
入门图形学：图形学原理（一）
热门推荐
羊羊的博客
04-17 2万+
        前面我们闲聊谈到作为一个准备长期坚持在研发道路上的程序员，怎么样才能保证自己所学的知识属于持久长存的，而不至于在新老交替的时候淘汰掉。那么什么知识属于保质期长久的呢？其中就谈到了理论，也就是也就是原理，或者说事物的本质。图形学也是遵循其原理衍生而来的，从这里开始我们就来学习理解图形学原理。        这里先说些历史事件，也就是图形学起源。在1950年，第一台图形（阴极射线管CR...
什么是图形学
xiaxiazls的博客
11-25 459
介绍什么是计算机图形学
图形学基础概念(画布/位图/像素等)
Aaron.无剑
09-19 606
看过那些书，走过那些路，依然过不好这一生；用过很多框架，依然成不了好的架构师。本系列主要是介绍如果只给你一个点，让你实现一个3D的实现的过程以及会涉及到那些图形学知识。
计算机图形学实验全.doc
最新发布
12-03
计算机图形学实验全 实验1的核心是学习和实践两种经典的直线绘制算法——DDA（Digital Differential Analyzer）和Bresenham算法。这两种算法都是在计算机图形学中用于生成平滑直线的基本方法，尤其是在低分辨率的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值