【OpenGL】计算机图形学实验二：基本图形的生成技术(直线、圆、椭圆生成算法)

最新推荐文章于 2025-03-11 14:21:17 发布
最新推荐文章于 2025-03-11 14:21:17 发布
阅读量7.3k 收藏 144
点赞数 12
分类专栏： 计算机图形学实验 文章标签： 其他
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52052747/article/details/125618107
版权
该博客围绕基本图形生成技术实验展开，目的是掌握直线、圆和椭圆的生成算法并用C++实现。介绍了实验设备，阐述用中点法、数值微分法、Bresenham法绘制直线，Bresenham法绘圆，中点法绘椭圆的原理，给出代码及运行结果，还比较了各算法差别。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

实验二：基本图形的生成技术

(直线、圆、椭圆生成算法)

1、实验目的和要求

熟悉并掌握基本图形，特别是直线、圆和椭圆的基本生成算法，并能够用C++上机实现。

2、实验设备

PC机、CodeBlocks\VS系列\OpenGL安装包

3、实验内容及原理

分别用中点法、数值微分法、Bresenham法绘制任意直线，用Bresenham绘制圆，用中点法绘制椭圆(选做)，并比较各种算法的差别。

实验原理(基本知识)

DDA数值微分算法：由于直线的一阶导数是连续的，且\Delta x和\Delta y是成比例的，因此可以通过在当前位置\left( x_i,y_i \right)分别加上两个小增量\varepsilon \varDelta x和\varepsilon \varDelta y（\varepsilon是无穷小的正数）来求出下一点\left( x_{i+1}, y_{i+1} \right)的x, y坐标。即有

\left\{ \begin{array}{c} x_{i+1}=x_i+\varepsilon \varDelta x\\ y_{i+1}=y_i+\varepsilon \varDelta y\\\end{array} \right.

中点Bresenham算法：每次在最大位移方向上走一步，而另一个方向是走步还是不走步取决于误差项的判别。

Bresenham法：基本原理同“中点Bresenham算法”。在中点Bresanham算法改进而来。只需要检查误差项e的符号即可确定某一列的像素。

4、实验源程序代码、运行结果

4.1 中点法绘制直线

4.1.1源程序代码

#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
#include <cmath>
#include <vector>
#include <iostream>

using namespace std;

void resize(GLsizei w, GLsizei h) {
    if (h == 0) {
        h = 1;
    }

    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    if (w <= h) {
        glOrtho(-200.0f, 200.0f, -200.0f, 200.f * h / w, 1.0f, -1.0f);
    } else {
        glOrtho(-200.0f, 200.0f * w / h, -200.0f, 200.0f, 1.0f, -1.0f);
    }

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

void drawPixel(int x, int y) {
    glBegin(GL_POINTS);
        glVertex2i(x, y);
    glEnd();
}

// MidBresenhamLine
void MidBresenhamLine(vector<int> p0, vector<int> p1) {
    int x0 = p0[0], y0 = p0[1],
        x1 = p1[0], y1 = p1[1];

    // 两种特殊情况: x0 == x1 || y0 == y1
    if (x0 == x1) {
        if (y0 > y1) {
            swap(y0, y1);
        }
        for (int i = y0; i <= y1; i++) {
            drawPixel(x0, i);
        }
        return ;
    } else if (y0 == y1) {
        if (x0 > x1) {
            swap(x0, x1);
        }
        for (int i = x0; i <= x1; i++) {
            drawPixel(i, y0);
        }
        return ;
    }

    int kRev = (y1 - y0) / (x1 - x0);
    bool isKGT1 = false;                                     // 1 : K is greater than 1
    bool isKNeg = (y1 - y0) * (x1 - x0) >= 0 ? false : true; // 1 : K is negative
    if (abs(kRev) >= 1) { // |k| > 1
        swap(x0, y0);
        swap(x1, y1);
        isKGT1 = true;
    }

    if (isKGT1) {
        if (isKNeg) {
            if (y0 < y1) {
                swap(y0, y1);
                swap(x0, x1);
            }
        } else {
            if (y0 > y1) {
                swap(y0, y1);
                swap(x0, x1);
            }
        }

    } else {
        if (x0 > x1) {
            swap(y0, y1);
            swap(x0, x1);
        }
    }

    int x = x0, y = y0;
    int dx = x1 - x0, dy = y1 - y0;
    
    int d = isKNeg ? -dx - 2 * dy : dx - 2 * dy;

    int incDLT0  = !isKNeg ? 2 * dx - 2 * dy : -2 * dy         ; // d < 0
    int incDGTE0 = !isKNeg ? -2 * dy         : -2 * dy - 2 * dx; // d >= 0
    cout << incDGTE0 <<' ' << incDLT0 << endl;
    while (x <= x1) {
//        cout << d << endl;
        if (isKGT1) {
            drawPixel(y, x);
        } else {
            drawPixel(x, y);
        }

        x++;
        if (d < 0) {
            if (!isKNeg) {
                y++;
            }
            d += incDLT0;
        } else {
            if (isKNeg) {
                y--;
            }
            d += incDGTE0;
        }
    }
}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3d(1, 0, 0);

    vector<int> p0(2), p1(2);
    p0[0] = 0, p0[1] = 0;
    p1[0] = -50, p1[1] = 100;
    MidBresenhamLine(p1, p0);

    glutSwapBuffers();
}

int main(int argc, char *argv[]) {
    glutInit(&argc, argv);
    glutInitWindowSize(400, 400);
    glutInitWindowPosition(10, 10);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);

    glutCreateWindow("MidBresenhamLine");

    glutReshapeFunc(resize);
    glutDisplayFunc(display);

    // setRC
    glClearColor(1, 1, 1, 1);

    glutMainLoop();

    return 0;
}

4.1.2运行结果

4.2 数值微分法绘制直线

4.2.1源程序代码

#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
#include <cmath>
#include <vector>
#include <iostream>

using namespace std;

void resize(GLsizei w, GLsizei h) {
    if (h == 0) {
        h = 1; 
    }

    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    if (w <= h) {
        glOrtho(-200.0f, 200.0f, -200.0f, 200.f * h / w, 1.0f, -1.0f);
    } else {
        glOrtho(-200.0f, 200.0f * w / h, -200.0f, 200.0f, 1.0f, -1.0f);
    }

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

void drawPixel(int x, int y) {
    glBegin(GL_POINTS);
        glVertex2i(x, y);
    glEnd();
}

// DDALine
void DDALine(vector<int> p0, vector<int> p1) {
    // 两种特殊情况: x0 == x1 || y0 == y1
    if (p0[0] == p1[0]) {
        if (p0[1] > p1[1]) {
            swap(p0[1], p1[1]);
        }
        for (int i = p0[1]; i <= p1[1]; i++) {
            drawPixel(p0[0], i);
        }
        return ;
    } else if (p0[1] == p1[1]) {
        if (p0[0] > p1[0]) {
            swap(p0[0], p1[0]);
        }
        for (int i = p0[0]; i <= p1[0]; i++) {
            drawPixel(i, p0[1]);
        }
        return ;
    }

    int dx = p1[0] - p0[0],
        dy = p1[1] - p0[1];
    double epsilon = 1 / max(abs(dx), abs(dy));
    double xInc = dx * epsilon, // X方向的增量
           yInc = dy * epsilon; // Y方向的增量

    double currX = p0[0], currY = p0[1]; // 当前X, Y坐标的值
    for (int i = 0; i <= max(abs(dx), abs(dy)); i++) {
        drawPixel(int(currX + 0.5), int(currY +0.5));
        currX += xInc;
        currY += yInc;
    }

}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3d(1, 0, 0);

    vector<int> p0(2), p1(2);

    p0[0] = 10, p0[1] = 0;
    p1[0] = 100, p1[1] = 0;

    DDALine(p0, p1);

    glutSwapBuffers();
}

int main(int argc, char *argv[]) {
    glutInit(&argc, argv);
    glutInitWindowSize(400,400);
    glutInitWindowPosition(10,10);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);

    glutCreateWindow("DDALine");

    glutReshapeFunc(resize);
    glutDisplayFunc(display);

    // setRC
    glClearColor(1, 1, 1, 1);

    glutMainLoop();

    return 0;
}

4.2.2运行结果

4.3 Bresenham法绘制直线

4.3.1源程序代码

#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
#include <cmath>
#include <vector>
#include <iostream>

using namespace std;

void resize(GLsizei w, GLsizei h) {
    if (h == 0) {
        h = 1;
    }

    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    if (w <= h) {
        glOrtho(-200.0f, 200.0f, -200.0f, 200.f * h / w, 1.0f, -1.0f);
    } else {
        glOrtho(-200.0f, 200.0f * w / h, -200.0f, 200.0f, 1.0f, -1.0f);
    }

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

void drawPixel(int x, int y) {
    glBegin(GL_POINTS);
        glVertex2i(x, y);
    glEnd();
}

// BresenhamLine
void BresenhamLine(vector<int> p0, vector<int> p1) {
    int x0 = p0[0], y0 = p0[1],
        x1 = p1[0], y1 = p1[1];

    // 两种特殊情况: x0 == x1 || y0 == y1
    if (x0 == x1) {
        if (y0 > y1) {
            swap(y0, y1);
        }
        for (int i = y0; i <= y1; i++) {
            drawPixel(x0, i);
        }
        return ;
    } else if (y0 == y1) {
        if (x0 > x1) {
            swap(x0, x1);
        }
        for (int i = x0; i <= x1; i++) {
            drawPixel(i, y0);
        }
        return ;
    }

    int kRev = (y1 - y0) / (x1 - x0);

    bool isKGT1 = false; // 1 : K is greater than 1
    bool isKNeg = (y1 - y0) * (x1 - x0) >= 0 ? false : true; // 1 : K is negative
    if (abs(kRev) >= 1) { // |k| > 1
        swap(x0, y0);
        swap(x1, y1);
        isKGT1 = true;
    }

    if (isKGT1) {
        if (isKNeg) {
            if (y0 < y1) {
                swap(y0, y1);
                swap(x0, x1);
            }
        } else {
            if (y0 > y1) {
                swap(y0, y1);
                swap(x0, x1);
            }
        }

    } else {
        if (x0 > x1) {
            swap(y0, y1);
            swap(x0, x1);
        }
    }

    int x = x0, y = y0;
    int dx = x1 - x0, dy = y1 - y0;
    if (isKNeg) {
        dy = -dy;
    }

    int e = -dx;

    while (x <= x1) {
        if (isKGT1) {
            drawPixel(y, x);
        } else {
            drawPixel(x, y);
        }
        x++;
        e += 2 * dy;

        if (e > 0) {
            if (isKNeg) {
                y--;
            } else {
                y++;
            }
            e -= 2 * dx;
        }
    }


}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3d(1, 0, 0);

    vector<int> p0(2), p1(2);
    p0[0] = 0, p0[1] = 0;
    p1[0] = 100, p1[1] = -150;
    BresenhamLine(p1, p0);

    glutSwapBuffers();
}

int main(int argc, char *argv[]) {
    glutInit(&argc, argv);
    glutInitWindowSize(400, 400);
    glutInitWindowPosition(10, 10);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);

    glutCreateWindow("BresenhamLine");

    glutReshapeFunc(resize);
    glutDisplayFunc(display);

    // setRC
    glClearColor(1, 1, 1, 1);

    glutMainLoop();

    return 0;
}

4.3.2运行结果

4.4 Bresenham法绘制圆

4.4.1源程序代码

#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
#include <cmath>
#include <vector>
#include <iostream>

using namespace std;

void resize(GLsizei w, GLsizei h) {
    if (h == 0) {
        h = 1;
    }

    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    if (w <= h) {
        glOrtho(-200.0f, 200.0f, -200.0f, 200.f * h / w, 1.0f, -1.0f);
    } else {
        glOrtho(-200.0f, 200.0f * w / h, -200.0f, 200.0f, 1.0f, -1.0f);
    }

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

void drawPixels(int x, int y) {
    glBegin(GL_POINTS);
        glVertex2i(x, y);
        glVertex2i(y, x);
        glVertex2i(-x, y);
        glVertex2i(y, -x);
        glVertex2i(x, -y);
        glVertex2i(-y, x);
        glVertex2i(-x, -y);
        glVertex2i(-y, -x);
    glEnd();
}

// BresenhamCircle
void BresenhamCircle(int r) {
    int x = 0, y = r;
    int d = 1 - r; // 判别式
    while (x <= y) {
        drawPixels(x, y);
        if (d < 0) {
            d += 2 * x + 3;
        } else {
            d += 2 * (x - y) + 5;
            y--;
        }
        x++;
    }
}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3d(1, 0, 0);

    BresenhamCircle(100);

    glutSwapBuffers();
}

int main(int argc, char *argv[]) {
    glutInit(&argc, argv);
    glutInitWindowSize(400, 400);
    glutInitWindowPosition(10, 10);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);

    glutCreateWindow("BresenhamCircle");

    glutReshapeFunc(resize);
    glutDisplayFunc(display);

    // setRC
    glClearColor(1, 1, 1, 1);

    glutMainLoop();

    return 0;
}

4.4.2运行结果

4.5中点法绘制椭圆

4.5.1源程序代码

#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
#include <cmath>
#include <vector>
#include <iostream>

using namespace std;

void resize(GLsizei w, GLsizei h) {
    if (h == 0) {
        h = 1;
    }

    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    if (w <= h) {
        glOrtho(-200.0f, 200.0f, -200.0f, 200.f * h / w, 1.0f, -1.0f);
    } else {
        glOrtho(-200.0f, 200.0f * w / h, -200.0f, 200.0f, 1.0f, -1.0f);
    }

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

void drawPixels(int x, int y) {
    glBegin(GL_POINTS);
        glVertex2i(x, y);
        glVertex2i(-x, y);
        glVertex2i(x, -y);
        glVertex2i(-x, -y);
    glEnd();
}

// MidBresenhamEllipse
void MidBresenhamEllipse(int a, int b) {
    double d1 = b * b + a * a * (-b + 0.25);
    int x = 0, y = b;
    drawPixels(x, y);
    while (b * b * (x + 1) < a * a * (y - 0.5)) {
        if (d1 <= 0) {
            d1 += b * b * (2 * x + 3);
            x++;
        } else {
            d1 += b * b * (2 * x + 3) + a * a * (-2 * y + 2);
            x++;
            y--;
        }
        drawPixels(x, y);
    }

    double d2 = b * b * (x + 0.5) * (x + 0.5) + a * a * (y - 1) * (y - 1) - a * a * b * b;
    while (y > 0) {
        if (d2 <= 0) {
            d2 += b * b * (2 * x + 2) + a * a * (-2 * y + 3);
            x++;
            y--;
        } else {
            d2 += a * a * (-2 * y + 3);
            y--;
        }

        drawPixels(x, y);
    }
}

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3d(1, 0, 0);

    MidBresenhamEllipse(160, 80);

    glutSwapBuffers();
}

int main(int argc, char *argv[]) {
    glutInit(&argc, argv);
    glutInitWindowSize(400, 400);
    glutInitWindowPosition(10, 10);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);

    glutCreateWindow("MidBresenhamEllipse");

    glutReshapeFunc(resize);
    glutDisplayFunc(display);

    // setRC
    glClearColor(1, 1, 1, 1);

    glutMainLoop();

    return 0;
}

4.5.2运行结果

4.6各种算法的差别

4.6.1 DDA算法、中点Bresenham算法、Bresenham算法绘制的区别

DDA算法是一种增量算法，直观、容易实现。但是涉及浮点运算（currX, currY, xInc增量和yInc增量都是浮点类型），不利于硬件实现。

中点Bresenham算法的基本原理是每次在最大位移方向上走一步，另一个方向上走步还是不走步取决于误差项的判别。中点Bresenham算法在实现上比DDA算法更为复杂，但是增量可以通过整型实现，并且大部分运算都是加法和乘法，更加利于硬件实现，绘制效率也更高。该算法可以实现任意k值的直线段的绘制，《计算机图形学基础（第三版）》课本中给出了0≤k≤1时的实现代码，经过书本中的提示，我实现了其余情况的代码。

Bresenham算法是中点Bresenham算法的改进模式。其基本原理和中点Bresenham算法相同。它同样采用增量计算，对于每一列检查一个误差项的符号就可以确定该列的所求像素。

OpenGL实现改进的绘制圆、椭圆、直线算法
01-19
根据《一个椭圆生成算法_赵京东》《Bresenham直线生成算法的改进_贾银亮》《Bresenham画圆算法的改进_王志喜》三篇文献自己写的代码
【计算机图形学】实验2：橡皮筋技术及拾取操作
superiony的博客
12-10 1128
本文主要是介绍了计算机图形学实验2，即橡皮筋技术即拾取操作，属于计算机图形学实验专栏
计算机图形学中的基础图形绘制：直线、圆和椭圆算法详解
最新发布
weixin_42509888的博客
03-11 876
本文还有配套的精品资源，点击获取 简介：在计算机图形学中，绘制简单几何形状如直线、圆和椭圆是基础且关键的任务。本文深入解析了两种高效算法：DDA算法用于直线绘制，Bresenham算法用于高效绘制圆和椭圆。这些算法因其只涉及整数运算和有限的像素操作，在游戏开发、图像处理和界面设计等领域广泛应用，是实现高效图形绘制不可或缺的工具。通过学习这些算法，开发者能够优化程序性能，实现...
OpenGL 实现 椭圆画法
03-31
OpenGL 实现 椭圆画法
《计算机图形学》实验 2
qq_45823118的博客
12-22 1500
一、实验目的： 1） 熟悉 OpenGL 的环境搭建，并可以自行搭建环境； 2） 了解并熟悉 OpenGL 程序的设计框架和基本函数； 3） 能够根据学习教程自行设计程序，绘制同心圆； 4） 能够根据学习教程自行设计程序，绘制等边三角形； 二、实验内容 共有六道题目，其中第六题是加分题。请根据给定的实验结果样例，结合参考程序设计程序，实现样例的显示效果，把程序代码和实验截图拷贝到实验报告中。 题目 1： 设计程序实现“花卷”图样，颜色可以不同。 #include <GL/glut.h> #inc
计算机图形学实验二
weixin_34233618的博客
04-16 624
// 图形学实验一.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include"gl/glut.h" static GLsizei iMode =0; void Initial(void) { glClearColor(1.0f, 1.0f, 1.0f, 1.0f); glMatrixMode(GL_PROJ...
计算机图形学 实验二 三维模型读取与控制【OpenGL】
weixin_43757333的博客
12-05 8715
文章目录实验2.1 OpenGL的控制与交互方式一、 实验目的二、 理论背景三、 实验内容1. 创建基本工程项目2. 在子窗口中绘制图形3. 在子窗口中通过键盘事件更换椭圆形状颜色4. 在主窗口中添加菜单设置形状颜色5. 在主窗口中添加鼠标交互控制动画参考函数四、 示例和练习1. 实验结果2. 课堂练习实验2.1练习题完整代码：实验 2.2 OFF格式的模型显示一、 实验目的二、 理论背景OFF 格式文件深度测试三、 实验内容答案四、 参考函数五、完整代码 实验2.1 OpenGL的控制与交互方式 一、 实
【深圳大学计算机图形学】实验二 三维模型读取与控制
归忆_AC的博客
02-03 2811
一旦所有的顶点位置、颜色和面片信息都准备好，接着调用 storeFacesPoints() 函数，这个函数在内部会将每个面片的点和颜色信息存储在 points 和 colors 容器中。紧接着，定义了每个三角面片的顶点索引。2. 将每个三角面片的顶点坐标和颜色信息从相应的数据结构中提取出来，并将它们按照一定的顺序添加到 points 和 colors 这两个数据结构中。在这个循环中，将每个顶点的位置存储在 vertex_positions 容器中，并将相应的颜色存储在 vertex_colors 容器中。
计算机图形学实验-基于OpenGL实现椭圆 Bresenham 算法和橡皮筋交互技术
12-23
总的来说，这个实验旨在让你深入理解计算机图形学中的基本绘图算法和用户交互技术，并通过实际操作提高编程能力。完成这个实验后，你不仅能够掌握OpenGL和GLUT的基础，还能了解到如何利用Bresenham算法优化图形绘制...
图形学实验大礼包---直线 椭圆 圆 扫描算法 填充算法 用WebGL OpenGL
01-16
总的来说，这个图形学实验大礼包包含了一系列基础的图形学概念和技术，对于理解计算机图形学原理和实践有着重要的价值。无论是初学者还是有经验的开发者，都能从中受益，进一步提升自己的图形编程技能。
实验三代码-基本图形生成算法
04-13
在本实验中，我们将深入探讨计算机图形学的基本概念和实现，特别是关注“基本图形生成算法”。这个主题是软件开发，尤其是游戏开发、图形用户界面设计和可视化应用中的核心部分。通过学习这些算法，我们可以理解如何...
OpenGL画椭圆算法
04-16
OpenGL画椭圆算法
计算机图形学实验2.docx
01-02
通过Bresenham算法，画颜色渐变的线
山东大学计算机图形学实验二
06-08
实验二 题目：三维迷宫的创建及走迷宫过程中的交互功能的实现 【教学目标和要求】了解图形系统的性能, 掌握可交互的OpenGL应用程序的开发设计的方法,掌握系统处理鼠标和键盘事件的编程方法,掌握OpenGL应用程序的拾取机制,掌握并学会利用OpenGL开发场景漫游程序的编程方法,掌握并学会利用OpenGL纹理映射的方法。在实践开发过程中，培养科研的钻研能力和综合开发能力。 【实验要求】熟练运用OpenGL的相关函数和辅助函数，了解MD2三维模型的文件格式,熟悉并学会读取模型、加载到场景中的方法.
计算机图形学实验二 opengl
05-06
试设计一个室内三维环境, 并利用OPENGL展示它的三维效果。要求：（1）包含基本的实体元素：球、多面体、锥体、 柱体、曲面等；（2）有全局光照效果和纹理功能；（3）程序具有交互功能。
OpenGl下中点法画椭圆的实现
04-25
OpenGl下中点法画椭圆的实现，可以运行
【计算机图形学】实验一 直线生成算法实现（实验报告分析+截图+源码）
m0_55931547的博客
06-28 7336
DDA、中点Brensenham（所有情况都囊括了）、Brensenham（仅有0
【计算机图形学 】绘制椭圆 | OpenGL+鼠标交互
Rover95的博客
09-27 4434
文章目录前言1.辅助画椭圆算法2.椭圆的中点算法（两种）3.改变鼠标动作响应函数4. 完整代码5. 总结 前言 实现绘制椭圆的中点算法，并和鼠标进行交互。 具体原理略过，会贴上完整代码，可直接运行。 使用材料： vs2019,OpenGL的库（可以搜索如何用vs使用OpenGL的库，可以使用vs自带的插件或者其他方法，很方便） 要点： 1.设计画椭圆的算法。设置椭圆中心和长短半轴的全局变量，通过鼠标得到全局变量的值，再传入函数，进行椭圆的绘制。 2.改变鼠标点击和鼠标拖拽的响应事件。 最终效果： 用鼠标在界
SWJTU 西南交通大学 计算机图形学实验2
qq_73781710的博客
10-13 601
基本图元包括：直线，圆，矩形，曲线，多义线（多条直线构成的折线段，作为一个整体，当选择其中一段直线时可看成是选择了整个折线段）等。比如，当用户点击“直线绘制”按钮或菜单项时，可通过在屏幕中的图形绘制区第一次点击鼠标左键确定直线的起点，然后移动鼠标，在另一个位置点击鼠标左键确定直线终点，从而绘制出一条直线。主要包括：1）求交：求直线和直线，直线和圆，圆和圆之间的交点，并给出交点的坐标。绘制垂线和通过鼠标选择绘制的图元应该也不难。（4）以文件的形式保存绘制的图形，并可打开已保存的文件，正常显示出保存的图形。
计算机图形学实验源码：OpenGL图形绘制与变换技术
在计算机图形学实验源码中，所包含的知识点涵盖了计算机图形学和OpenGL编程的核心概念。本篇文章将详细介绍这些知识点，希望能够帮助理解计算机图形学的原理以及如何使用OpenGL库进行图形编程。 ### 计算机图形学...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值