计算机图形学实验（一） Bresenham画直线和中点画圆法画圆

末蓝、 2022-02-09 20:39 495阅读 0赞

图形学的第一个实验，

因为老师课上的讲解原因，所以这里将一个边长为1的正方形块作为一个像素，放大后可以看出来。

先上代码，画线的：

  1. void drawLine(node * mnode)
  2. {
  3.     glClearColor(0.0f, 0.0f, 0.0f,0.0f);//绘图颜色为黑色   
  4.     glClear(GL_COLOR_BUFFER_BIT); 
  5.     glColor3f(1.0, 1.0, 1.0);
  6.     glBegin(GL_LINES);
  7.     //glViewport(0, 0, 400, 400);
  8.     for (int i = 0; i < 400; i++)
  9.     {
  10.         glVertex2i(i, 0);
  11.         glVertex2i(i, 400);
  12.     }
  13.     for (int i = 0; i < 400; i++)
  14.     {
  15.         glVertex2i(0, i);
  16.         glVertex2i(400,i);
  17.     }
  18.     glEnd();
  19.     //glClear(GL_COLOR_BUFFER_BIT);   //清空颜色缓冲池
  20.     glColor3f(1.0, 0.0, 0.0);
  21.     //glBegin(GL_POINTS);   
  22.     //glViewport(0, 0, 400, 400);
  23.     int x, y, dx, dy, e;
  24.     int x1 = mnode[0].x, y1 = mnode[0].y, x2 = mnode[1].x, y2 =mnode[1].y;  
  25.     dx = x2 - x1;
  26.     dy = y2 - y1;
  27.     e = -dx;
  28.     x = x1;
  29.     y = y1;
  30.     for (int i = 0; i <= dx; i++)
  31.     {
  32.         //glVertex2i(x, y);
  33.         glRectf(x,y, x+1, y+1);  //绘制矩形
  35.         x++;
  36.         e = e + 2 * dy;
  37.         if (e >= 0)
  38.         {
  39.             y++;
  40.             e = e - 2 * dx;
  41.         }
  42.     }
  43.     //glEnd();     
  44.     glFlush();
  45. }

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MjQ3NTQ0_size_16_color_FFFFFF_t_70

放大后的图像

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MjQ3NTQ0_size_16_color_FFFFFF_t_70 1

然后是画圆的代码：

  1. void drawCircle()
  2. {
  3.     glClearColor(0.0f, 0.0f, 0.0f, 0.0f);//绘图颜色为黑色   
  4.     glClear(GL_COLOR_BUFFER_BIT);
  5.     glColor3f(1.0, 1.0, 1.0);
  6.     //glBegin(GL_POINTS);
  7.     glBegin(GL_LINES);
  8.     glViewport(0, 0, 400, 400);
  9.     for (int i = 0; i < 400; i++)
  10.     {
  11.         glVertex2i(i, 0);
  12.         glVertex2i(i, 400);
  13.     }
  14.     for (int i = 0; i < 400; i++)
  15.     {
  16.         glVertex2i(0, i);
  17.         glVertex2i(400, i);
  18.     }
  19.     glEnd();
  20.     //glViewport(0, 0, 400, 400);
  21.     glColor3f(1.0, 0.0, 0.0);
  22.     int x, y;
  23.     float d;
  24.     int r = 100;
  25.     x = 0, y = r;
  26.     d = 1.25 - r;
  27.     //glVertex2i(x+r,y+r);
  28.     //glVertex2i(y+r, x+r);
  29.     //glVertex2i(-x+r, y+r);
  30.     //glVertex2i(y+r, -x+r);
  31.     //glVertex2i(x+r, -y+r);
  32.     //glVertex2i(-y+r, x+r);
  33.     //glVertex2i(-x+r, -y+r);
  34.     //glVertex2i(-y+r, -x+r);
  35.     glRectf(x+r, y+r, x +r+1, y+r+1);  //绘制矩形
  36.     glRectf(y+r, x+r, y+r+ 1, x+r+1);  //绘制矩形    
  37.     glRectf(-x+r, y+r, -x+r+1, y +r+ 1);  //绘制矩形    
  38.     glRectf(y+r, -x+r, y+r+ 1, -x+r+ 1);  //绘制矩形    
  39.     glRectf(x+r, -y+r, x+r+ 1, -y+r+ 1);  //绘制矩形    
  40.     glRectf(-y+r, x+r, -y+r + 1, x+r+ 1);  //绘制矩形    
  41.     glRectf(-x+r, -y+r, -x+r + 1, -y+r + 1);  //绘制矩形    
  42.     glRectf(-y+r, -x+r, -y+r + 1, -x+r + 1);  //绘制矩形
  43.     while (x <= y)
  44.     {
  45.         if (d <= 0)
  46.         {
  47.             d += 2 * x + 3;
  48.         }
  49.         else
  50.         {
  51.             d += 2 * (x - y) + 5; 
  52.             y--;
  53.         }
  54.         x++;
  55.         //cout<< x <<" "<<y<< endl;
  56.         /*glVertex2i(x + r, y + r);
  57.         glVertex2i(y + r, x + r);
  58.         glVertex2i(-x + r, y + r);
  59.         glVertex2i(y + r, -x + r);
  60.         glVertex2i(x + r, -y + r);
  61.         glVertex2i(-y + r, x + r);
  62.         glVertex2i(-x + r, -y + r);
  63.         glVertex2i(-y + r, -x + r);*/
  64.         glRectf(x + r, y + r, x + r + 1, y + r + 1);  //绘制矩形
  65.         glRectf(y + r, x + r, y + r + 1, x + r + 1);  //绘制矩形    
  66.         glRectf(-x + r, y + r, -x + r + 1, y + r + 1);  //绘制矩形    
  67.         glRectf(y + r, -x + r, y + r + 1, -x + r + 1);  //绘制矩形    
  68.         glRectf(x + r, -y + r, x + r + 1, -y + r + 1);  //绘制矩形    
  69.         glRectf(-y + r, x + r, -y + r + 1, x + r + 1);  //绘制矩形    
  70.         glRectf(-x + r, -y + r, -x + r + 1, -y + r + 1);  //绘制矩形    
  71.         glRectf(-y + r, -x + r, -y + r + 1, -x + r + 1);  //绘制矩形
  72.     }
  73.     //glEnd();
  74.     glFlush();
  75. }

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MjQ3NTQ0_size_16_color_FFFFFF_t_70 2

放大后的代码：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MjQ3NTQ0_size_16_color_FFFFFF_t_70 3

实现原理：

过各行各列像素中心构造一组网格线，按直线从起点到终点的顺序计算直线与各垂直网格线的交点，然后确定该列像素中与此交点最近的像素。该算法的巧妙之处在于采用增量计算，使得对于每一列，只要检查一个误差项的符号，就可以确定该列的所求的像素。

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MjQ3NTQ0_size_16_color_FFFFFF_t_70 4

简单来说就是如果在中点及以下则取y,中点以上则取y+1。

中点画圆法：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MjQ3NTQ0_size_16_color_FFFFFF_t_70 5

完整的代码：

  1. // ConsoleApplication2.cpp: 定义控制台应用程序的入口点。
  2. //
  3. #include "stdafx.h"
  4. #include<gl/GLUT.H>
  5. #include<cmath>
  6. #include<iostream>
  7. #include "node.h"
  8. using namespace std;
  9. node Line[2] = { node(0.0,0.0),node(0.0,0.0) };
  10. int nodeNumber = 0;
  11. bool finish = false;//已经画完
  12. void Initial(void)//初始化函数 
  13. {
  14.     glClearColor(1.0f, 1.0f, 1.0f, 1.0f);//白色背景，前3个是RGB，最后是Alpha值，用来控制透明，1.0表示完全不透明
  15.     glMatrixMode(GL_MODELVIEW);//OpenGL按照三维方式来处理图像，所以需要一个投影变换将三维图形投影到显示器的二维空间中
  16.     glLoadIdentity();
  17.     gluOrtho2D(0.0, 400, 0.0, 400.0);//指定使用正投影将一个x坐标在0~200，y坐标0~150范围内的矩形坐标区域投影到显示器窗口
  19. }
  20. void drawLine(node * mnode)
  21. {
  22.     glClearColor(0.0f, 0.0f, 0.0f,0.0f);//绘图颜色为黑色   
  23.     glClear(GL_COLOR_BUFFER_BIT); 
  24.     glColor3f(1.0, 1.0, 1.0);
  25.     glBegin(GL_LINES);
  26.     //glViewport(0, 0, 400, 400);
  27.     for (int i = 0; i < 400; i++)
  28.     {
  29.         glVertex2i(i, 0);
  30.         glVertex2i(i, 400);
  31.     }
  32.     for (int i = 0; i < 400; i++)
  33.     {
  34.         glVertex2i(0, i);
  35.         glVertex2i(400,i);
  36.     }
  37.     glEnd();
  38.     //glClear(GL_COLOR_BUFFER_BIT);   //清空颜色缓冲池
  39.     glColor3f(1.0, 0.0, 0.0);
  40.     //glBegin(GL_POINTS);   
  41.     //glViewport(0, 0, 400, 400);
  42.     int x, y, dx, dy, e;
  43.     int x1 = mnode[0].x, y1 = mnode[0].y, x2 = mnode[1].x, y2 =mnode[1].y;  
  44.     dx = x2 - x1;
  45.     dy = y2 - y1;
  46.     e = -dx;
  47.     x = x1;
  48.     y = y1;
  49.     for (int i = 0; i <= dx; i++)
  50.     {
  51.         //glVertex2i(x, y);
  52.         glRectf(x,y, x+1, y+1);  //绘制矩形
  54.         x++;
  55.         e = e + 2 * dy;
  56.         if (e >= 0)
  57.         {
  58.             y++;
  59.             e = e - 2 * dx;
  60.         }
  61.     }
  62.     //glEnd();     
  63.     glFlush();
  64. }
  65. void drawLine1()
  66. {
  67.     glClearColor(0.0f, 0.0f, 0.0f, 0.0f);//绘图颜色为黑色   
  68.     glClear(GL_COLOR_BUFFER_BIT);
  69.     glColor3f(1.0, 1.0, 1.0);
  70.     glBegin(GL_LINES);
  71.     //glViewport(0, 0, 400, 400);
  72.     for (int i = 0; i < 400; i++)
  73.     {
  74.         glVertex2i(i, 0);
  75.         glVertex2i(i, 400);
  76.     }
  77.     for (int i = 0; i < 400; i++)
  78.     {
  79.         glVertex2i(0, i);
  80.         glVertex2i(400, i);
  81.     }
  82.     glEnd();
  83.     //glClear(GL_COLOR_BUFFER_BIT);   //清空颜色缓冲池
  84.     glColor3f(1.0, 0.0, 0.0);
  85.     //glBegin(GL_POINTS);   
  86.     //glViewport(0, 0, 400, 400);
  87.     int x, y, dx, dy, e;
  88.     int x1 = 0, y1 = 8, x2 = 50, y2 = 100;
  89.     dx = x2 - x1;
  90.     dy = y2 - y1;
  91.     e = -dx;
  92.     x = x1;
  93.     y = y1;
  94.     for (int i = 0; i <= dx; i++)
  95.     {
  96.         //glVertex2i(x, y);
  97.         glRectf(x, y, x + 1, y + 1);  //绘制矩形
  99.         x++;
  100.         e = e + 2 * dy;
  101.         if (e >= 0)
  102.         {
  103.             y++;
  104.             e = e - 2 * dx;
  105.         }
  106.     }
  107.     //glEnd();     
  108.     glFlush();
  109. }
  110. void drawLine()
  111. {
  112.     if (finish)
  113.     {
  114.         drawLine(&Line[0]);
  115.         finish = false;
  116.     }
  117. }
  118. void drawCircle()
  119. {
  120.     glClearColor(0.0f, 0.0f, 0.0f, 0.0f);//绘图颜色为黑色   
  121.     glClear(GL_COLOR_BUFFER_BIT);
  122.     glColor3f(1.0, 1.0, 1.0);
  123.     //glBegin(GL_POINTS);
  124.     glBegin(GL_LINES);
  125.     glViewport(0, 0, 400, 400);
  126.     for (int i = 0; i < 400; i++)
  127.     {
  128.         glVertex2i(i, 0);
  129.         glVertex2i(i, 400);
  130.     }
  131.     for (int i = 0; i < 400; i++)
  132.     {
  133.         glVertex2i(0, i);
  134.         glVertex2i(400, i);
  135.     }
  136.     glEnd();
  137.     //glViewport(0, 0, 400, 400);
  138.     glColor3f(1.0, 0.0, 0.0);
  139.     int x, y;
  140.     float d;
  141.     int r = 100;
  142.     x = 0, y = r;
  143.     d = 1.25 - r;
  144.     //glVertex2i(x+r,y+r);
  145.     //glVertex2i(y+r, x+r);
  146.     //glVertex2i(-x+r, y+r);
  147.     //glVertex2i(y+r, -x+r);
  148.     //glVertex2i(x+r, -y+r);
  149.     //glVertex2i(-y+r, x+r);
  150.     //glVertex2i(-x+r, -y+r);
  151.     //glVertex2i(-y+r, -x+r);
  152.     glRectf(x+r, y+r, x +r+1, y+r+1);  //绘制矩形
  153.     glRectf(y+r, x+r, y+r+ 1, x+r+1);  //绘制矩形    
  154.     glRectf(-x+r, y+r, -x+r+1, y +r+ 1);  //绘制矩形    
  155.     glRectf(y+r, -x+r, y+r+ 1, -x+r+ 1);  //绘制矩形    
  156.     glRectf(x+r, -y+r, x+r+ 1, -y+r+ 1);  //绘制矩形    
  157.     glRectf(-y+r, x+r, -y+r + 1, x+r+ 1);  //绘制矩形    
  158.     glRectf(-x+r, -y+r, -x+r + 1, -y+r + 1);  //绘制矩形    
  159.     glRectf(-y+r, -x+r, -y+r + 1, -x+r + 1);  //绘制矩形
  160.     while (x <= y)
  161.     {
  162.         if (d <= 0)
  163.         {
  164.             d += 2 * x + 3;
  165.         }
  166.         else
  167.         {
  168.             d += 2 * (x - y) + 5; 
  169.             y--;
  170.         }
  171.         x++;
  172.         //cout<< x <<" "<<y<< endl;
  173.         /*glVertex2i(x + r, y + r);
  174.         glVertex2i(y + r, x + r);
  175.         glVertex2i(-x + r, y + r);
  176.         glVertex2i(y + r, -x + r);
  177.         glVertex2i(x + r, -y + r);
  178.         glVertex2i(-y + r, x + r);
  179.         glVertex2i(-x + r, -y + r);
  180.         glVertex2i(-y + r, -x + r);*/
  181.         glRectf(x + r, y + r, x + r + 1, y + r + 1);  //绘制矩形
  182.         glRectf(y + r, x + r, y + r + 1, x + r + 1);  //绘制矩形    
  183.         glRectf(-x + r, y + r, -x + r + 1, y + r + 1);  //绘制矩形    
  184.         glRectf(y + r, -x + r, y + r + 1, -x + r + 1);  //绘制矩形    
  185.         glRectf(x + r, -y + r, x + r + 1, -y + r + 1);  //绘制矩形    
  186.         glRectf(-y + r, x + r, -y + r + 1, x + r + 1);  //绘制矩形    
  187.         glRectf(-x + r, -y + r, -x + r + 1, -y + r + 1);  //绘制矩形    
  188.         glRectf(-y + r, -x + r, -y + r + 1, -x + r + 1);  //绘制矩形
  189.     }
  190.     //glEnd();
  191.     glFlush();
  192. }
  193. void mouseClick(int btn, int state, int x, int y)
  194. {
  195.     if (btn == GLUT_LEFT_BUTTON && state == GLUT_DOWN)//点击左键
  196.     {
  197.         y = 400 - y;
  198.         node temp(x, y);
  199.         if (nodeNumber<2)
  200.         {
  201.           Line[nodeNumber] = temp;
  202.           nodeNumber++;
  203.           glColor3f(1.0, 0.0, 0.0);
  204.          // glViewport(0, 0, 400, 400);
  205.           glBegin(GL_POINTS);
  206.           glVertex2d(x, y);
  207.           glEnd();
  208.           glFlush();
  209.         }
  211.     }
  212.     if (btn == GLUT_RIGHT_BUTTON && state == GLUT_DOWN)//点击右键
  213.     {
  214.         //drawLine(&Line[0]);
  215.         finish = true;
  216.         nodeNumber = 0;
  217.     }
  218. }
  219. int main(int argc, char * argv[])//这是使用glut库函数进行窗口管理
  220. {
  221.     glutInit(&argc, argv);//使用glut库需要进行初始化
  222.     glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);//设定窗口显示模式，颜色模型和缓存，这里是RGB颜色模型和单缓存
  223.     glutInitWindowPosition(100, 100);//设定窗口的初始位置，屏幕左上角为原点，单位为像素
  224.     glutInitWindowSize(400, 400);//设定窗口的大小
  225.     glutCreateWindow("直线");//创建一个窗口，参数是窗口标题名 
  226.     Initial();
  227.     glutDisplayFunc(&drawLine1);//将myDisplay指定为当前窗口的显示内容函数*/
  228.     //glutMouseFunc(mouseClick);
  229.     glutCreateWindow("圆");//创建一个窗口，参数是窗口标题名 
  230.     Initial(); 
  231.     glutDisplayFunc(&drawCircle);//将myDisplay指定为当前窗口的显示内容函数                             
  232.     glutMainLoop();//使窗口框架运行起来，使显示回调函数开始工作
  233.     return 0;
  234. }

还有一个头文件：

  1. #pragma once
  2. #pragma once
  3. struct node//点结构 
  4. {
  5.     double x;
  6.     double y;
  7.     node()
  8.     {
  9.         x = 0.0;
  10.         y = 0.0;
  11.     }
  12.     ~node() {}
  13.     node(double xx, double yy)
  14.     {
  15.         x = xx;
  16.         y = yy;
  17.     }
  18.     /*node & operator=(const node& a)
  19.    {
  20.         node m;
  21.         m.x = a.x;
  22.         m.y = a.y;
  23.         return m;
  24.     }*/
  25. };
  27. struct side//边结构
  28. {
  29.     node a;
  30.     node b;
  31.     side(node aa, node bb)
  32.     {
  33.         a.x = aa.x;
  34.         a.y = aa.y;
  35.         b.y = bb.y;
  36.         b.x = bb.x;
  37.     }
  38.     side(int n)
  39.     {
  40.         a.x = 0;
  41.         a.y = 0;
  42.         b.x = 0;
  43.         b.y = 0;
  44.     }
  45.     side()
  46.     {
  47.         a.x = 0;
  48.         a.y = 0;
  49.         b.x = 0;
  50.         b.y = 0;
  51.     }
  52. };

发表评论

表情：
评论列表 （有 0 条评论，495人围观）

还没有评论，来说两句吧...

相关阅读