1

我直接从opengl教科书中复制了这个椭圆代码：

void ellipseMidpoint (int xCenter, int yCenter, int Rx, int Ry)
{
  int Rx2 = Rx * Rx;
  int Ry2 = Ry * Ry;
  int twoRx2 = 2 * Rx2;
  int twoRy2 = 2 * Ry2;
  int p;
  int x = 0;
  int y = Ry;
  int px = 0;
  int py = twoRx2 * y;

//initial points in both quadrants
ellipsePlotPoints (xCenter, yCenter, x, y);

//Region 1
p = round (Ry2 - (Rx2 * Ry) + (0.25 * Rx2));
while (px < py) {
    x++;
    px += twoRy2;
    if (p < 0)
        p += Ry2 + px;
    else {
        y--;
        py -= twoRx2;
        p += Ry2 + px - py;
    }
    ellipsePlotPoints (xCenter, yCenter, x, y);
}

//Region 2
p = round (Ry2 * (x+0.5) * (x+0.5) + Rx2 * (y-1) * (y-1) - Rx2 * Ry2);
while (y > 0) {
    y--;
    py -= twoRx2;
    if (p > 0)
        p += Rx2 - py;
    else {
        x++;
        px += twoRy2;
        p += Rx2 - py + px;
    }
    ellipsePlotPoints (xCenter, yCenter, x, y);
 }
}

void ellipsePlotPoints (int xCenter, int yCenter, int x, int y)
{
    setPixel (xCenter + x, yCenter + y);
    setPixel (xCenter - x, yCenter + y);
    setPixel (xCenter + x, yCenter - y);
    setPixel (xCenter - x, yCenter - y);
}

void setPixel (GLint xPos, GLint yPos)
{
    glBegin (GL_POINTS);
    glVertex2i(xPos, yPos);
    glEnd();
}

较小的椭圆似乎很好，但较大的椭圆是尖的，末端有点平。

任何想法为什么？

这是当前的屏幕截图：

这是一张图片

4

1 回答 1

0

我认为你遇到了溢出。我玩过你的代码。虽然我从未从您的图片中看到完全相同的“柠檬”型形状，但在大尺寸时肯定会分崩离析，这是由于int代码中使用的变量范围溢出造成的。

例如，看一下第一个作业：

int py = twoRx2 * y;

如果您替换，则变为：

int py = 2 * Rx * Rx * Ry;

如果对Rx和分别使用 1000 的值Ry，则为 2,000,000,000。这非常接近 32-bit 范围的 2^31 - 1 顶部int。

如果您想将此算法用于更大的尺寸，您可以使用 64 位整数变量。根据您的系统，类型将是long或long long。或者更稳健，int64_t包括<stdint.h>.

现在，如果你只想用 OpenGL 画一个省略号，还有更好的方法。如果您需要逐像素绘制曲线，则代码中使用的 Bresenham 类型算法是理想的选择。但是 OpenGL 是一个更高级别的 API，它知道如何渲染比像素更复杂的图元。对于曲线，您通常会使用一组连接的线段来逼近曲线。然后，OpenGL 将负责将这些线段转换为像素。

绘制省略号的最简单方法是直接应用参数表示。phi角度介于 0 和 PI 之间，并使用代码中的命名，省略号上的点为：

x = xCenter + Rx * cos(phi)
y = yCenter + Ry * sin(phi)

您可以使用满足您的精度要求的增量，phi代码看起来会生成一个近似于DIV_COUNT点的省略号，如下所示：

float angInc = 2.0f * m_PI / (float)DIV_COUNT;
float ang = 0.0f;
glBegin(GL_LINE_LOOP);
for (int iDiv = 0; iDiv < DIV_COUNT; ++iDiv) {
    ang += angInc;
    float x = xCenter + Rx * cos(ang);
    float y = yCenter + Ry * sin(ang);
    glVertex2f(x, y);
glEnd();

如果您关心效率，您可以避免计算每个点的三角函数，并应用增量旋转来计算前一个点的每个点：

float angInc = 2.0f * M_PI / (float)DIV_COUNT;
float cosInc = cos(angInc);
float sinInc = sin(angInc);
float cosAng = 1.0f;
float sinAng = 0.0f
glBegin(GL_LINE_LOOP);
for (int iDiv = 0; iDiv < DIV_COUNT; ++iDiv) {
    float newCosAng = cosInc * cosAng - sinInc * sinAng;
    sinAng = sinInc * cosAng + cosInc * sinAng;
    cosAng = newCosAng;
    float x = xCenter + Rx * cosAng;
    float y = yCenter + Ry * sinAng;
    glVertex2f(x, y);
glEnd();

这段代码当然只是为了说明数学，让你开始。实际上，您应该使用当前的 OpenGL 渲染方法，其中包括顶点缓冲区等。

于 2014-06-20T05:45:24.883 回答