精华内容
下载资源
问答
  • 计算机图形学实验

    2021-01-24 23:07:31
    大二学期的计算机图形学课程,内容包含扫描转换算法,裁剪算法,图形变换,三维图形投影和消隐,曲线和曲面;从完成情况来看虽算不上十分出色,但也花了很多时间和精力,代码必然存在一些冗余、不足和待改进之处,故...

    实验介绍

    大二学期的计算机图形学课程,内容包含扫描转换算法裁剪算法图形变换三维图形投影和消隐曲线和曲面;从完成情况来看虽算不上十分出色,但也花了很多时间和精力,代码必然存在一些冗余、不足和待改进之处,故公开和大家交流和参考

    软件环境

    • VC++ 6.0
    • easyX库

    实验内容

    实验一 —— 扫描转换算法

    (●’◡’●) 效果展示
    实验题1-1:绘制任意斜率的直线
    实验题1-3:用中点画圆法画圆
    实验题1-4:中点画圆法画椭圆
    实验题1-5:中点画圆法画圆弧
    实验题1-7:具有宽度的直线
    实验题1-8:具有宽度的圆和椭圆

    实验一中的代码并未进行优化,从截图可以看出,UI界面不够友好(毕竟刚学习这门课),操作起来比后面的实验更复杂


    实验二 —— 裁剪算法

    (●’◡’●) 效果展示
    实验题2-1:Cohen-Sutherland算法实现直线段裁剪
    实验题2-2:Liang-Barsky算法实现直线段裁剪
    实验题2-5:综合算法实现多边形裁剪(自创)

    多边形裁剪:该算法实现了对任意多边形的裁剪,程序中设置多边形的顶点为固定的9个。算法上的实现分为三步:

    • 第一,先画裁剪框内的线段:用直线段裁剪算法对多边形进行裁剪,最后留下在裁剪框内的线段
    • 第二,画裁剪框四个顶点旁的线。先判断裁剪框的四个顶点是否在多边形内,具体判断方法是:过该顶点一条射线与多边形的每条线段相交,如果交点有奇数个,则在多边形内,反之则在多边形外。如果顶点在多边形内,那么它邻接的在裁剪框边上的点与它之间一定有连线
    • 第三,画裁剪框四条边上与顶点无交点的线段。取出在多边形外的四边形顶点,从这一点开始,往邻接的两条边方向画,得到该边和多边形线段的交点,然后画第奇数个到下一个点上的线段,若有奇数个点,则略去最后一个。例如:假设左下角的点在多边形外,则从该点向上和向右画,当向上画时,假如有5个交点(y1,y2,y3,y4,y5),则画线段(y1,y2),(y3,y4),y5则省略

    实验三 —— 图形变换

    (●’◡’●) 效果展示
    实验题3-2:实现多步复合变换,并显示动画效果
    实验题3-3:任意直线的对称变换

    不足之处:各种二维变换在数学上理论上都能得到结果,但实现在程序里难免有舍入,会导致一些四边形放大倍数时,四边形的同一边可能有错位


    实验四 —— 三维图形投影和消隐

    (●’◡’●) 效果展示
    实验题4-4和4-5:完成图形绕某一坐标轴旋转(包括三视图和正等轴测图)

    为了完成正十二面体的旋转,作者查了很多资料,最终得以实现,是一件很有趣的事情,如下是源码中坐标对应的点,如有需要可以参考
    在这里插入图片描述

    不足之处:由于作者采用的消隐算法是外法线消隐算法,此算法只对凸多面体有效,这是该消隐算法的局限;且该消隐算法是按照每个面的边数都相等的多面体来具体实现的,于是对于由三角形和四边形等组成的混合型多面体无法在原有算法中实现,若有需要还得进一步修改


    实验五 —— 曲线和曲面

    (●’◡’●) 效果展示
    实验题5-2绘制Bezier曲线
    实验题5-4绘制B样条曲面

    存在问题:Bezier曲线的代码中对点采用递归方式计算,当增加一个点时,需要对之前已经计算过的低阶Bezier函数重新进行计算,使得空间消耗和时间消耗增加(当时并未进行优化)。所以当点越来越多时,程序运行速度会大大降低,甚至可能程序崩溃(当有10几个点时)


    实验源码

    • 下载方式一

    本实验部分内容可通过资源下载,包含Bezier曲线和B样条曲面正十二面体旋转——外法线消隐直线和多边形裁剪

    • 下载方式二

    通过GitHub免费下载完整源码,click here

    展开全文
  • 计算机图形学实验代码(全)
  • 计算机图形学实验 金刚石 上图是运行结果 二话不说直接上代码 #include <graphics.h> #include <conio.h> #include <math.h> #define x 300 #define y 300 #define r 250 #define rx 600 #...

    计算机图形学实验 金刚石

    运行结果
    上图是运行结果
    二话不说直接上代码

    #include  <graphics.h> 
    #include <conio.h>
    #include <math.h>
    #define x 300
    #define y 300
    #define r 250
    #define rx 600
    #define ry 600
    
    double Rad_to_deg  = 45.0 / atan(1.0);
    int n = 20;
    int jiaodu = 360/n;
    double hudu[20];
    
    void main( )
    {
    	initgraph(rx, ry);  //初始化绘图窗口
    	setbkcolor(WHITE);//白底
    	cleardevice(); //
    	setcolor(RED);//线
    	setlinestyle(PS_SOLID,2); //线的style
    	circle(x,y,r);/* 画一个圆形 */
    
    	for(int i=0;i<20;i++){
    		jiaodu = 360 /n *(i);
    		hudu[i]=(double)jiaodu/Rad_to_deg;
    	}
    
    	double dx=0,dy=0;//要改变的x和y
    	double tx[20],ty[20];//真正的x和y
    
    	for(int i=0;i<20;i++){//圆心坐标+改变的x,y就是 x和y
    		dx=r*cos(hudu[i]);
    		dy=r*sin(hudu[i]);
    		tx[i]=x+dx;
    		ty[i]=y+dy;
    		dx=0;
    		dy=0;
    	}
    
    	for(int i=0;i<20;i++){
    		for(int j=0;j<20;j++){
    			line(tx[i],ty[i],tx[j],ty[j]);
    		}
    	}
    
    	getch( );
    	closegraph ( );             /*关闭图形系统,返回文本方式  */
    }
    
    
    展开全文
  • 计算机图形学实验 源代码
  • 计算机图形学实验及课程设计,是太原工业学院孔令德教授编写的关于计算机图形学这门课程相关的18个实验及5个课程设计。案例由浅入深,具有很强的操作性和实际意义。 本资源给出实验的ppt课件以及实验项目的可执行...
  • 计算机图形学实验及课程设计,是太原工业学院孔令德教授编写的关于计算机图形学这门课程相关的18个实验及5个课程设计。案例由浅入深,具有很强的操作性和实际意义。
  • 本人自己亲自完成的七个计算机图形学实验之六,需要参考的就下吧,我只为赚取积分。
  • 计算机图形学实验一:直线的Bresenham算法和DDA算法实现 解救众多被计算机图形学实验所困扰的学生党们,本博客仅粘贴代码,直线的Bresenham算法和DDA算法的原理请自行百度或Google,网上从来不缺原理。 ps :本代码...

    计算机图形学实验一:直线的Bresenham算法和DDA算法实现

    解救众多被计算机图形学实验所困扰的学生党们,本博客仅粘贴代码,直线的Bresenham算法和DDA算法的原理请自行百度或Google,网上从来不缺原理。
    ps :本代码属于硬核坐标放大,改进版坐标放大的方法请看博主另一篇博客计算机图形学实验三:多边形填充算法之活性边表方法实现中的坐标放大方法,比这里面的放大方法好了不下100倍!只是博主做完实验一身轻松,就不想再倒回去折腾了,你们就自己动手改吧,不然就用我这个硬核坐标放大也是没有问题的,就是解释器爱稍微麻烦了一点。

    代码在此,参考为上,借鉴最佳

    #include "pch.h"
    #include <iostream>
    #include<GL/glut.h>
    #include<math.h>
    #include<Windows.h>
    
    const int WindowWidth = 800, WindowHeight = 800;
    //DDA算法
    void DDALine(int x0, int y0, int x1, int y1)
    {
    	int x01 = x0 * 20, y01 = y0 * 20, x11 = x1 * 20, y11 = y1 * 20;
    	int dx = x11 - x01, dy = y11 - y01;
    	if (dx != 0)
    	{
    		int k = dy * 20 / dx;
    		if ((k > 20)||(k<-20)) {
    			if (dy < 0) {
    				int tempx0 = x01, tempy0 = y01;
    				x01 = x11, y01 = y11;
    				x11 = tempx0, y11 = tempy0;
    			}
    			int x = x01;
    			k = dx * 20 / dy;
    			int tempx = 0;
    			glVertex2i(x01, y01);
    			for (int y = y01 + 20; y <= y11;)
    			{
    				x = x + k;
    				if (x < 0) {
    					if (x % 20 == -10)
    					{
    						tempx = x / 20;
    						glVertex2i(tempx * 20, y);
    					}
    					else
    						tempx = (x - 10) / 20;
    				}
    				else
    					tempx = (x + 10) / 20;
    				glVertex2i(tempx * 20, y);
    				y = y + 20;
    			}
    		}
    		else{
    			if (dx < 0) {
    				int tempx0 = x01, tempy0 = y01;
    				x01 = x11, y01 = y11;
    				x11 = tempx0, y11 = tempy0;
    			}
    			int y = y01;
    			int tempy = 0;
    			glVertex2i(x01, y01);
    			for (int x = x01 + 20; x <= x11;)
    			{
    				y = y + k;
    				if (y < 0) {
    					if (y % 20 == -10) {
    						tempy = y / 20;
    						glVertex2i(x, tempy * 20);
    					}
    					else
    						tempy = (y - 10) / 20;
    				}
    				else
    					tempy = (y + 10) / 20;
    				glVertex2i(x, tempy * 20);
    				x = x + 20;
    			}
    		}
    	}
    	else
    	{
    		if (dy < 0) {
    			int tempx0 = x01, tempy0 = y01;
    			x01 = x11, y01 = y11;
    			x11 = tempx0, y11 = tempy0;
    		}
    		for (int y = y01; y <= y11;) {
    			glVertex2i(x01, y);
    			y += 20;
    		}
    	}
    }
    
    //Bresenham算法实现
    void BresenhamLine(int x0, int y0, int x1, int y1) {
    	int x01 = x0 * 20, y01 = y0 * 20, x11 = x1 * 20, y11 = y1 * 20;
    	int dx = x11 - x01, dy = y11 - y01;
    	if (dx == 0) {
    		if (dy < 0) {
    			int tempx0 = x01, tempy0 = y01;
    			x01 = x11, y01 = y11;
    			x11 = tempx0, y11 = tempy0;
    		}
    		for (int y = y01; y <= y11;) {
    			glVertex2i(x01, y);
    			y += 20;
    		}
    	}
    	else {
    		if (((dy > dx) && (dx < 0) && (dy * dx > 0)) || ((dy < dx) && (dy > 0))) {  //0<k<1
    			int tempy = y01;
    			int e = -dx;
    			if (dx < 0) {
    				int tempx0 = x01, tempy0 = y01;
    				x01 = x11, y01 = y11;
    				x11 = tempx0, y11 = tempy0;
    				dx = x11 - x01, dy = y11 - y01;
    				e = -dx;
    				tempy = y01;
    			}
    			for (int x = x01; x <= x11;) {
    				if (e < 0) {
    					glVertex2i(x, tempy);
    					e = e + 2 * dy;
    					x = x + 20;
    				}
    				else
    				{
    					e = e - 2 * dx;
    					tempy = tempy + 20;
    					glVertex2i(x, tempy);
    					e = e + 2 * dy;
    					x = x + 20;
    				}
    			}
    		}
    		else if (((dy < dx) && (dx < 0)) || ((dy > dx) && (dx > 0))) {  //k>1
    			int tempx = x01;
    			int e = -dy;
    			if (dx < 0) {
    				int tempx0 = x01, tempy0 = y01;
    				x01 = x11, y01 = y11;
    				x11 = tempx0, y11 = tempy0;
    				dx = x11 - x01, dy = y11 - y01;
    				e = -dy;
    				tempx = x01;
    			}
    			for (int y = y01; y <= y11;) {
    				if (e < 0) {
    					glVertex2i(tempx, y);
    					e = e + 2 * dx;
    					y = y + 20;
    				}
    				else
    				{
    					e = e - 2 * dy;
    					tempx = tempx + 20;
    					glVertex2i(tempx, y);
    					e = e + 2 * dx;
    					y = y + 20;
    				}
    			}
    		}
    		else if (((dy + dx < 0) && (dx > 0)) || ((dy + dx > 0) && (dx < 0))) {  //k<-1
    			int tempx = x01;
    			int e = -dy;
    			if (dy < 0) {
    				int tempx0 = x01, tempy0 = y01;
    				x01 = x11, y01 = y11;
    				x11 = tempx0, y11 = tempy0;
    				dx = x11 - x01, dy = y11 - y01;
    				e = -dy;
    				tempx = x01;
    			}
    			for (int y = y01; y <= y11;) {
    				if (e < 0) {
    					glVertex2i(tempx, y);
    					e = e - 2 * dx;
    					y = y + 20;
    				}
    				else
    				{
    					e = e - 2 * dy;
    					tempx = tempx - 20;
    					glVertex2i(tempx, y);
    					e = e - 2 * dx;
    					y = y + 20;
    				}
    			}
    		}
    		else {     //-1 < k <0
    			int tempy = y01;
    			int e = -dx;
    			if (dx < 0) {
    				int tempx0 = x01, tempy0 = y01;
    				x01 = x11, y01 = y11;
    				x11 = tempx0, y11 = tempy0;
    				dx = x11 - x01, dy = y11 - y01;
    				e = -dx;
    				tempy = y01;
    			}
    			for (int x = x01; x <= x11;) {
    				if (e < 0) {
    					glVertex2i(x, tempy);
    					e = e - 2 * dy;
    					x = x + 20;
    				}
    				else
    				{
    					e = e - 2 * dx;
    					tempy = tempy - 20;
    					glVertex2i(x, tempy);
    					e = e - 2 * dy;
    					x = x + 20;
    				}
    			}
    		}
    	}
    }
    
    void resetSize(int w, int h)
    {
    	glutReshapeWindow(WindowWidth, WindowHeight);
    }
    
    void inIt()
    {
    	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    	glutInitWindowPosition(50, 50);
    	glutInitWindowSize(WindowWidth, WindowHeight);
    	glutCreateWindow("Line Demo");
    	gluOrtho2D(-WindowWidth / 2, WindowWidth / 2, -WindowHeight / 2, WindowHeight / 2);
    	glutReshapeFunc(resetSize);
    
    	glClear(GL_COLOR_BUFFER_BIT);
    	glColor3f(0.1, 0.1, 0.1);
    	glBegin(GL_POINTS);
    	for (int x = (-WindowWidth); x < WindowWidth; x++) {
    		for (int y = (-WindowHeight); y < WindowHeight; y += 20) {
    			glVertex2i(x, y);
    		}
    	}
    	for (int y = (-WindowHeight); y < WindowHeight; y++) {
    		for (int x = (-WindowWidth); x < WindowWidth; x += 20) {
    			glVertex2i(x, y);
    		}
    	}
    	glEnd();
    }
    
    void Draw()
    {
    	glBegin(GL_POINTS);
    	//set color as white
    	glColor3f(10, 10, 10);
    	glVertex2i(0, 0);
    	//DDALine(-10, -3, 5, 17); //k>1   ok
    	//DDALine(-10, -3, 10, 12);  //0<k<1    ok
    	//DDALine(-10, -3, 10, -18);  //-1<k<0   
    	//DDALine(-2, 4, 2, -2);    //k<-1   ok
    	//DDALine(-2, 2, 2, -2);    //k = 1 \ -1  ok
    	//DDALine(-2, 4, 2, 4);    //k = 0 \ none  ok
    	
    	//BresenhamLine(-10, -3, 5, 17);  //k>1   ok
    	//BresenhamLine(9, 2, -3, 10);  //0<k<1    ok
    	//BresenhamLine(-10, -3, 10, -18);  //-1<k<0   ok
    	//BresenhamLine(-2, 4, 2, -2);    //k<-1   ok
    	//BresenhamLine(-2, 2, 2, -2);    //k = 1 \ -1  ok
    	//BresenhamLine(-2, 4, -2, -4);    //k = 0 \ none  ok
    	glEnd();
    	glFlush();
    }
    
     int main(int argc, char** argv) {
    	 glutInit(&argc, argv);
    	 inIt();
    	 glutDisplayFunc(Draw);
    	 glutMainLoop();
    	 return 0;
    	
    }
    

    pch.h文件源码

    #ifndef PCH_H
    #define PCH_H
    
    // TODO: 添加要在此处预编译的标头
    
    #endif //PCH_H
    

    还是那句话,参考为上,借鉴更佳,共勉。

    展开全文
  • 计算机图形学实验一(二维图形绘制)

    千次阅读 2020-05-27 10:23:04
    计算机图形学实验一(二维图形绘制)一、实验内容 一、实验内容 (1)绘制金刚石图案 金刚石图案的成图规则是:把一个圆周等分成n份,然后每两点之间连线。当n取奇数时,该图案可一笔连续绘成,即用MoveTo函数确定一...

    一、实验内容

    (1)绘制金刚石图案
    金刚石图案的成图规则是:把一个圆周等分成n份,然后每两点之间连线。当n取奇数时,该图案可一笔连续绘成,即用MoveTo函数确定一个当前点,然后连续用LineTo函数连点成线。请设计连线规则并编程实现
    在这里插入图片描述
    (2)绘制魔术三角形
    绘制下图所示的魔术三角形图案 ,采用三种可明显区分的颜色填充。
    在这里插入图片描述
    (3)绘制递归圆
    应用递归的方法绘制如下所示的图案。
    在这里插入图片描述

    二、实验环境

    • 软硬件运行环境:Windows 10
    • 开发工具:visual studio 2017

    三、问题分析

    问题:(1)绘制金刚石图案

    1. 只有n为奇数时才能一笔画成。
    2. 主要解决n为奇数的问题,当n为奇数解决后偶数的自然可以画成。
    3. 主要进行跳跃连接,大致思想为从起始点开始每隔n/2-i(i从1到n/2)个点之间进行依次连接,每个小循环供连接n次,执行n/2个小循环
    4. 当n/2为n的因子时则需要使跳跃的点+1,这一条线是多画的。
      问题:(2)绘制魔术三角
    5. 先通过六个点确定一个填充图形,三个填充图形可组成一个魔术三角。
    6. 通过颜色填充和Sleep函数实现颜色逐渐变化的效果。
      问题:(3)绘制递归圆
    7. 主要通过递归函数的调用实现递归圆的绘制
    8. 递归圆主要在中心点的八个方向上画圆,需要先算出各个圆的位置。
    9. 再通过递归将每个圆作为新的圆心重新执行第二步。

    四、算法设计

    (1) 绘制金刚石图案
    在这里插入图片描述
    (2) 绘制魔术三角
    在这里插入图片描述
    (3) 绘制递归圆
    在这里插入图片描述

    五、源代码

    (1)绘制金刚石

    //nVertex:顶点数,radius:圆半径,millisecond:笔画之间的延迟时间
    void CDiamondView::DrawDiamond(int nVertex, int radius,int millisecond){
    	InvalidateRect(NULL);//强制清屏
    	UpdateWindow();
    	int n=nVertex; 
        int r=radius; 
    	POINT* pPOINT=new POINT[n];
    	double x0=600,y0=400; 
    	CDC *pDC = GetDC(); 
    	CRect rect(x0-r,y0-r,x0+r,y0+r);  
    	CPen newPen,*oldPen; 
    	newPen.CreatePen(PS_SOLID,1,RGB(0,124,252)); //连线用蓝色
    	oldPen = pDC->SelectObject(&newPen);
    	double t; 
    	t=6.28318/n; 
    	for(int i=0;i<n;i++) 
    	{ 
    		//算出每个点的坐标
    		pPOINT[i].x=r*cos(i*t)+x0;
    		pPOINT[i].y=r*sin(i*t)+y0; 
    	} 
    	int k = 0;//定义第一个点
    	pDC->MoveTo(pPOINT[k].x,pPOINT[k].y);//移到第一个点处 
    	 //画金刚石算法
    	int firstPoint=k;//记录初始点
    	for (int i =0; i < n / 2; i++) {
    		//每隔n/2-i个点开始跳跃,共跳跃n次
    		for (int j =0; j < n; j++) {
    			k = (k + n / 2 - i) % n;
    			pDC->LineTo(pPOINT[k].x, pPOINT[k].y);
    			Sleep(millisecond);//暂停一会
    			//判断是不是n的公约数,如果是则连线时连接的间隔点数加一
    			//因为只有n的公约数才会在没有跳跃n次时回到起点
    			if (k == firstPoint&j!=n) {
    				k = (k + n / 2 - i+1) % n;
    				pDC->LineTo(pPOINT[k].x, pPOINT[k].y);
    				firstPoint = k;
    			}
    		}
    	}
    }
    

    (2)绘制魔术三角

    //绘制魔术三角
    void CDiamondView::DrawTriangle()
    {
    	InvalidateRect(NULL);//强制清屏
    	UpdateWindow();
    	CDC *pDC = GetDC();
    	int second =1,time=60;
    	//根据坐标生成魔术三角图案
    	CBrush newBrush, *oldBrush;
    	CRgn Rgn1, Rgn2, Rgn3;
    	POINT  vertex1[6] = { {360,116}, {105,555},{512,555},{464,470},{258,470},{460,116} };
    	Rgn1.CreatePolygonRgn(vertex1, 6, WINDING);
    	POINT  vertex2[6] = { {460,116},{258,470},{362,470},{460,290},{666,644},{718,555} };
    	Rgn2.CreatePolygonRgn(vertex2, 6, ALTERNATE); 
    	POINT  vertex3[6] = { {105,555},{155,644},{666,645},{460,290},{410,380},{512,555} };
    	Rgn3.CreatePolygonRgn(vertex3, 6, ALTERNATE); 
    	while(time>0){
    		//第一个填充
    		newBrush.CreateSolidBrush(RGB(rand()%256,rand()%256,rand()%256)); //生成随机的颜色
    		pDC->FillRgn(&Rgn1,&newBrush);
    		Sleep(second*100);
    		//第二个填充
    		newBrush.CreateSolidBrush(RGB(rand()%256,rand()%256,rand()%256)); 
    		pDC->FillRgn(&Rgn2,&newBrush);
    		Sleep(second * 100);
    		//第三个填充
    		newBrush.CreateSolidBrush(RGB(rand()%256,rand()%256,rand()%256)); 
    		pDC->FillRgn(&Rgn3,&newBrush);
    		Sleep(second * 100);
    		time--;//直到time为0退出循环
    	}
    }
    

    (3)绘制递归圆

    //递归圆的递归函数
    void circle(int n,double r, double x0, double y0, CDC *pDC) {
    	const int q = 8;//周围圆的个数
    	double t = 6.28318 / q;
    	double x1[q], y1[q];
    	for (int i = 0 ; i<q; i++ )
    	{
    		x1[i] = 2 * r*cos(i*t) + x0; 
    		y1[i] = 2 * r*sin(i*t) + y0;
    		CPen newPen, *oldPen;
    		newPen.CreatePen(PS_SOLID, 1, RGB(30, 144, 255));
    		oldPen = pDC->SelectObject(&newPen);
    		CRect rect1( x1[i] - 0.3*r, y1[i] -0.3*r, x1[i] +0.3*r, y1[i] +0.3*r);
    		pDC->Ellipse(&rect1);
    	}
    	if (n == 1) {
    		return;
    	}
    	else {
    		for (int i = 0; i < q; i++)
    		{
    			circle(n-1, 0.3*r,x1[i],y1[i], pDC);
    		}
    	}
    }
    //绘制递归圆主函数
    //nDepth:递归深度
    void CDiamondView::DrawRecursionCircle(int nDepth)
    {
    	InvalidateRect(NULL);//强制清屏
    	UpdateWindow();
    	int x0= 400, y0= 400;//圆心
    	int r=100;//半径
    	const int q = 8;//周围圆的个数
    	int t = 6.28318 / q;
    	CDC *pDC = GetDC();
    	CPen newPen,*oldPen; 
    	newPen.CreatePen(PS_SOLID,1,RGB(30,144,255)); 
    	oldPen = pDC->SelectObject(&newPen); 
    	CRect rect(y0-r, y0-r, x0 +r, y0 + r);
    	pDC->Ellipse(&rect); 
    	if (nDepth == 0) {
    		return;
    	}
    	circle(nDepth, r, x0, y0, pDC);
    }
    
    

    六、程序运行结果

    (1) 绘制金刚石

    • ①n=21
      在这里插入图片描述
    • ②n=20
      在这里插入图片描述
      (2) 绘制魔术三角
      在这里插入图片描述
      (3) 绘制递归圆
      • ① 递归深度为4
        在这里插入图片描述
    展开全文
  • 本人自己亲自完成的七个计算机图形学实验之五,需要参考的就下吧,我只为赚取积分。
  • 计算机图形学实验代码(包括图形旋转、图形平移、图形缩放) 内含C++源代码和测试图片
  • 计算机图形学实验(平移,缩放,旋转),内有源代码,与可执行程序
  • 计算机图形学实验三:多边形填充算法之活性边表方法实现 解救众多被计算机图形学实验所困扰的学生党们,本博客仅粘贴代码,活性边表实现多边形填充的原理请自行百度或Google,网上从来不缺原理。 注意,本博客中的...
  • 山东大学计算机图形学实验1.1橡皮筋效果绘制OpenGL橡皮筋效果实现橡皮筋效果直线橡皮筋效果多边形运行截图小结 OpenGL橡皮筋效果实现 「实验题目」 设计一个二维卡通交互设计系统,实现直线,多边形绘制算法(橡皮筋...
  • 山东大学计算机图形学实验合集

    千次阅读 2019-11-17 18:44:05
    文章目录实验一 [方中有圆 圆中有方](https://blog.csdn.net/weixin_41894030/article/details/100598623)实验二 [Bresenham算法画直线](https://blog.csdn.net/weixin_41894030/article/details/100598840)实验三 ...
  • mfc扫描线种子填充算法----计算机图形学实验 最近刚刚学了计算机图形学,自己动手做了几个实验,下面介绍扫描线种子填充算法实现画一个老虎,代码有很多不够精简的地方。 具体算法推荐一篇文章(侵删,我在其基础上...
  • 实验报告一 实验项目 画颜色渐变的直线 实验内容 编写点着色命令,显示各自姓中偏旁 点击下载 实验报告二 实验项目 画颜色渐变的直线 实验内容 通过 Bresenham 算法,画颜色渐变的线 点击下载 实验报告三 实验项目 ...
  • 实验1 直线段的扫描转换 实验类型:设计性 实验类别:专业实验 实验目的 1. 通过实验,进一步理解直线段扫描转换的DDA算法、中点bresenham算法及bresenham算法的基本原理; 2. 掌握以上算法生成直线段的基本过程; 3...
  • 图形学实验中有着填充多边形的实验,在这里实现了一种相对简单的方法。 主要步骤: 从最下边往上边开始扫描,也就是y不断增加,求出与多边形的交点, 根据交点每两个点分为一组,并画出这两点之间的点,进行填充。...
  • 一、实验目的 掌握双缓冲绘图技术。 (2)掌握人机交互技术。 (3)掌握填充动态多边形的有效边表算法。 二、实验步骤 (1)在VS2017环境下创建MFC应用程序工程(单文档) (2)添加命令消息处理函数、双缓冲...
  • 实验目的 (1)掌握双线性光强插值模型。 二、实验步骤 (1)建立三维坐标系 Oxyz,原点位于屏幕客户区中心,x 轴水平向右为正, y 轴铅直向上为正,z 轴垂直于屏幕指向观察者。 (2)绘制体心和坐标系中心重合...
  • 实验原理 1.本次实验着重学习以下常用函数,在实验报告中的实验原理部分对下列函数进行参数介绍和用法介绍。 glLoadIdentity(); 变换矩阵: glRotatef(theta, vx, vy, vz) glTranslatef(dx, dy, dz) glScalef( sx, ...
  • 关于大四上学期的计算机图形学实验报告123——opengl建模、载入OBJ文件、纹理贴图、光照、交互。 实验123详细代码文件见: 计算机图形学实验123对应代码详见: 个人github ...
  • 一、实验目的 (1)掌握使用点表和面表构造立方体线框模型的方法。 (2)掌握视点求坐标的计算方法。 (3)掌握立方体线框模型二维透视投影图的绘制方法。 (4)掌握立方体线框模型二维透视投影图的旋转方法。 ...
  • 一、实验目的 (1)掌握任意斜率直线段的重点 Bresenham 扫描转换算法; (2)掌握 Cline 直线类的设计方法; (3)掌握状态栏编程方法。 二、实验步骤 (1)创建MFC应用程序 (2)定义CLine类 添加消息...
  • // 计算机图形学实验三.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include"stdio.h" #include"vector" #include"iostream" #include<gl/glut.h> using namespace std; const int...
  • 实验内容: 显示一个飞机:(飞机各顶点的坐标存放在数组中) (1)按比例缩小或放大.缩放比例由键盘输入,缩放的参考点由用户确定; (2)旋转.由键盘输入旋转角度和旋转中心; 第一个是比例变换 #include #include ...
  • //初始化图形窗口大小 line(0, y0, x0 * 2, y0); //坐标轴X line(x0, 0, x0, y0 * 2); //坐标轴Y Bresenham(x1, y1, x2, y2); //Bresenham画线算法 _getch(); //等待一个任意输入结束 closegraph(); /...
  • 计算机图形学实验————漫游三维迷宫

    千次阅读 热门讨论 2017-05-02 22:06:03
    (我们方向课的实验,发出来跟大家交流下) 设计一个OpenGL程序,创建一个三维迷宫,支持替身通过一定交互手段在迷宫中漫游。 基本功能包括:  1、 迷宫应当至少包含10 * 10 个Cell,不能过于简单,下图给出一...
  • 图形学的第一个实验, 因为老师课上的讲解原因,所以这里将一个边长为1的正方形块作为一个像素,放大后可以看出来。 先上代码,画线的: void drawLine(node * mnode) { glClearColor(0.0f, 0.0f, 0.0f,0.0f);/...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 42,421
精华内容 16,968
关键字:

计算机图形学实验