在OpenGL上用中点算法和Bresenham算法，使得输入两个圆的圆心坐标和半径长，就能分别用这两种算法生成圆。

好的，我可以给你一个基本的思路。

首先，我们需要在OpenGL中初始化一些基本的参数，例如窗口大小、背景颜色等。然后，在渲染循环中，我们可以通过鼠标或键盘输入获取两个圆的圆心坐标和半径长。接下来，我们需要利用中点算法和Bresenham算法分别生成这两个圆。

对于中点算法，我们可以按照以下步骤进行：

1. 定义两个变量x和y，分别初始化为0和r；
2. 计算决策参数d = 1.25 - r；
3. 在每个八分之一圆弧上，重复以下步骤：
- 如果d < 0，则选择点(x+1, y)作为下一个像素点，并更新d = d + 2x + 3；
- 如果d >= 0，则选择点(x+1, y-1)作为下一个像素点，并更新d = d + 2x - 2y + 5；
4. 重复以上步骤，直到x >= y。

对于Bresenham算法，我们可以按照以下步骤进行：

1. 定义两个变量x和y，分别初始化为0和r；
2. 定义一个决策参数p = 3 - 2r；
3. 在每个八分之一圆弧上，重复以下步骤：
- 如果p < 0，则选择点(x+1, y)作为下一个像素点，并更新p = p + 4x + 6；
- 如果p >= 0，则选择点(x+1, y-1)作为下一个像素点，并更新p = p + 4x - 4y + 10；
4. 重复以上步骤，直到x >= y。

在每个算法中，我们需要将像素点的坐标转换为OpenGL中的坐标系，然后用OpenGL的API来绘制像素点。具体实现可以参考OpenGL的教程和API文档。

希望这个思路能对你有所帮助！

相关问题

用python 在空白图像上绘制一个圆，要求其参数为圆心坐标为 （249,249），其半径为150像素，利用中点圆画法及Bresenham两种画法绘制。两种算法分别两个函数，在调用某 —个函数时可用相应算法进行绘制圆。

好的，这是一个比较简单的Python图像处理问题。下面是使用中点圆画法以及Bresenham算法绘制圆的代码实现。

中点圆画法：

from PIL import Image, ImageDraw

def midpoint_circle(image, center, radius, color):
    x0, y0 = center
    x = radius
    y = 0
    p = (5 - radius*4)//4

    draw = ImageDraw.Draw(image)

    while (x >= y):
        draw.point((x + x0, y + y0), fill=color)
        draw.point((-x + x0, y + y0), fill=color)
        draw.point((x + x0, -y + y0), fill=color)
        draw.point((-x + x0, -y + y0), fill=color)
        draw.point((y + x0, x + y0), fill=color)
        draw.point((-y + x0, x + y0), fill=color)
        draw.point((y + x0, -x + y0), fill=color)
        draw.point((-y + x0, -x + y0), fill=color)

        y += 1
        if (p < 0):
            p += 2 * y + 1
        else:
            x -= 1
            p += 2 * (y - x) + 1

    return image

image = Image.new('RGB', (500, 500), 'white')
center = (249, 249)
radius = 150
color = 'red'
image = midpoint_circle(image, center, radius, color)
image.show()

Bresenham算法：

from PIL import Image, ImageDraw

def bresenham_circle(image, center, radius, color):
    x0, y0 = center
    x = 0
    y = radius
    p = 3 - 2 * radius

    draw = ImageDraw.Draw(image)

    while (x <= y):
        draw.point((x + x0, y + y0), fill=color)
        draw.point((y + x0, x + y0), fill=color)
        draw.point((-x + x0, y + y0), fill=color)
        draw.point((-y + x0, x + y0), fill=color)
        draw.point((x + x0, -y + y0), fill=color)
        draw.point((y + x0, -x + y0), fill=color)
        draw.point((-x + x0, -y + y0), fill=color)
        draw.point((-y + x0, -x + y0), fill=color)

        if (p < 0):
            p += 4 * x + 6
        else:
            p += 4 * (x - y) + 10
            y -= 1

        x += 1

    return image

image = Image.new('RGB', (500, 500), 'white')
center = (249, 249)
radius = 150
color = 'red'
image = bresenham_circle(image, center, radius, color)
image.show()

这两个函数分别使用了中点圆画法和Bresenham算法，在调用某个函数时即可绘制对应的圆。你可以根据需要选择相应的算法，将代码复制到你的Python环境中进行运行测试即可。

在OpenGL上用Bresenham算法画圆

Bresenham算法是一种快速绘制圆的算法，它基于对称性和递归思想，可以高效地计算出圆上的所有点。

在OpenGL中，我们可以使用glPointSize函数设置点的大小，然后使用glBegin(GL_POINTS)和glEnd()函数包含绘制的所有点。下面是使用Bresenham算法绘制圆的示例代码：

#include <GL/glut.h> // 包含 glut 库
#include <math.h>

void display() {
    glClear(GL_COLOR_BUFFER_BIT); // 清空屏幕

    int r = 100; // 圆的半径
    int x = 0, y = r; // 圆心为(0, 0)

    int d = 3 - 2 * r; // 初始化决策参数

    glBegin(GL_POINTS); // 开始绘制点

    while (x <= y) {
        glVertex2f(x, y); // 绘制圆上的点
        glVertex2f(-x, y);
        glVertex2f(x, -y);
        glVertex2f(-x, -y);
        glVertex2f(y, x);
        glVertex2f(-y, x);
        glVertex2f(y, -x);
        glVertex2f(-y, -x);

        if (d < 0) {
            d += 4 * x + 6;
        } else {
            d += 4 * (x - y) + 10;
            y--;
        }

        x++;
    }

    glEnd(); // 结束绘制点

    glFlush(); // 刷新屏幕
}

int main(int argc, char **argv) {
    glutInit(&argc, argv); // 初始化 GLUT 库
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); // 设置显示模式
    glutInitWindowSize(400, 400); // 设置窗口大小
    glutInitWindowPosition(100, 100); // 设置窗口位置
    glutCreateWindow("Bresenham Circle Algorithm"); // 创建窗口，窗口名称为 "Bresenham Circle Algorithm"
    glClearColor(0.0, 0.0, 0.0, 0.0); // 设置清屏颜色
    glMatrixMode(GL_PROJECTION); // 设置投影矩阵
    glLoadIdentity(); // 重置矩阵
    gluOrtho2D(-200, 200, -200, 200); // 设置坐标系范围
    glutDisplayFunc(display); // 注册回调函数
    glutMainLoop(); // 进入主循环
    return 0;
}

在这个示例中，我们使用了glVertex2f函数绘制点，它的参数是点的坐标。由于圆具有对称性，我们只需要计算出1/8个圆的上半部分，然后利用对称性复制即可得到完整的圆。决策参数d的计算采用了递归思想，可以高效地计算出圆上的所有点。