c++ - 在 OpenGl 中渲染 mandelbrot 集

Question

我必须渲染 mandelbrot 集，我想知道是否有人可以指出我的代码的一些缺陷 - 目前，输出窗口只显示黑屏。我认为我的 mandelbrot 数学是正确的，因为我使用相同的代码来输出 mandelbrot 的 .tga - 这与我用来输出像素的 OpenGl 方法有关吗？

完整代码:

#include <Windows.h>
#include <GL\glew.h>
#include <GL\freeglut.h>
#include <iostream>
#include <stdlib.h>
#include <chrono>
#include <cstdint>
#include <cstdlib>
#include <complex>
#include <fstream>
#include <thread>
#include <mutex>
#include <vector>
#include <Windows.h>

// Import things we need from the standard library
using std::chrono::duration_cast;
using std::chrono::milliseconds;
using std::complex;
using std::cout;
using std::endl;
using std::ofstream;
// ...other useful includes
using std::cout;
using std::endl;
using std::thread;
using std::mutex;
using std::lock;
using std::unique_lock;
using std::vector;

const int width = 600, height = 600; // window size
int windowID;

// The number of times to iterate before we assume that a point isn't in the
// Mandelbrot set.
// (You may need to turn this up if you zoom further into the set.)
const int MAX_ITERATIONS = 500;

bool fullScreen = false;
bool need_to_draw = true;

//****************************************

// Render the Mandelbrot set into the image array.
// The parameters specify the region on the complex plane to plot.
void compute_mandelbrot(double left, double right, double top, double bottom)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // clear the screen buffer
    glBegin(GL_POINTS); // start drawing in single pixel mode
    for (int y = 0; y < height; ++y)
    {
        for (int x = 0; x < width; ++x)
        {
            // Work out the point in the complex plane that
            // corresponds to this pixel in the output image.
            complex<double> c(left + (x * (right - left) / width),
                top + (y * (bottom - top) / height));

            // Start off z at (0, 0).
            complex<double> z(0.0, 0.0);

            // Iterate z = z^2 + c until z moves more than 2 units
            // away from (0, 0), or we've iterated too many times.
            int iterations = 0;
            while (abs(z) < 2.0 && iterations < MAX_ITERATIONS)
            {
                z = (z * z) + c;

                ++iterations;
            }

            if (iterations == MAX_ITERATIONS)
            {
                glColor3f(1.0, 0.0, 0.0); // Set color to draw mandelbrot
                // z didn't escape from the circle.
                // This point is in the Mandelbrot set.
                glVertex2i(x, y);
            }
            else
            {
                glColor3f(0.0, 0.0, 0.0); //Set pixel to black
                // z escaped within less than MAX_ITERATIONS
                // iterations. This point isn't in the set.
                glVertex2i(x, y);
            }
        }
    }
    glEnd();
    glutSwapBuffers();
    need_to_draw = false;
}

int main(int argc, char** argv) 
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    GLsizei windowX = (glutGet(GLUT_SCREEN_WIDTH) - width) / 2;
    GLsizei windowY = (glutGet(GLUT_SCREEN_HEIGHT) - height) / 2;
    glutInitWindowPosition(windowX, windowY);
    glutInitWindowSize(width, height);
    windowID = glutCreateWindow("Mandelbrot");

    if (need_to_draw)
    {
        compute_mandelbrot(-2.0, 1.0, 1.125, -1.125);
    }

    glShadeModel(GL_SMOOTH);
    glEnable(GL_DEPTH_TEST);
    glViewport(0, 0, (GLsizei)width, (GLsizei)height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glutMainLoop();

    return 0;
}

Answer 1

恒等GL_PROJECTION矩阵不会像您假设的那样为您提供1对1的单位到像素的映射，它是一个+/-(1,1,1)立方体.

使用glOrtho()得到你想要的矩阵:

glOrtho( 0, width, 0, height, -1, 1 );

一起:

#include <GL/glut.h>

#include <complex>
using std::complex;

// Render the Mandelbrot set into the image array.
// The parameters specify the region on the complex plane to plot.
void compute_mandelbrot( double left, double right, double top, double bottom )
{
    // The number of times to iterate before we assume that a point isn't in the
    // Mandelbrot set.
    // (You may need to turn this up if you zoom further into the set.)
    const int MAX_ITERATIONS = 500;

    const int width = glutGet( GLUT_WINDOW_WIDTH );
    const int height = glutGet( GLUT_WINDOW_HEIGHT );

    glBegin( GL_POINTS ); // start drawing in single pixel mode
    for( int y = 0; y < height; ++y )
    {
        for( int x = 0; x < width; ++x )
        {
            // Work out the point in the complex plane that
            // corresponds to this pixel in the output image.
            complex<double> c( left + ( x * ( right - left ) / width ),
                top + ( y * ( bottom - top ) / height ) );

            // Start off z at (0, 0).
            complex<double> z( 0.0, 0.0 );

            // Iterate z = z^2 + c until z moves more than 2 units
            // away from (0, 0), or we've iterated too many times.
            int iterations = 0;
            while( abs( z ) < 2.0 && iterations < MAX_ITERATIONS )
            {
                z = ( z * z ) + c;

                ++iterations;
            }

            if( iterations == MAX_ITERATIONS )
            {
                glColor3f( 1.0, 0.0, 0.0 ); // Set color to draw mandelbrot
                // z didn't escape from the circle.
                // This point is in the Mandelbrot set.
                glVertex2i( x, y );
            }
            else
            {
                glColor3f( 0.0, 0.0, 0.0 ); //Set pixel to black
                // z escaped within less than MAX_ITERATIONS
                // iterations. This point isn't in the set.
                glVertex2i( x, y );
            }
        }
    }
    glEnd();
}

void display()
{
    glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
    glClear( GL_COLOR_BUFFER_BIT );

    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    const int width = glutGet( GLUT_WINDOW_WIDTH );
    const int height = glutGet( GLUT_WINDOW_HEIGHT );
    glOrtho( 0, width, 0, height, -1, 1 );

    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();

    compute_mandelbrot( -2.0, 1.0, 1.125, -1.125 );
    glutSwapBuffers();
}

int main( int argc, char** argv )
{
    glutInit( &argc, argv );
    glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGBA );
    glutInitWindowSize( 300, 300 );
    glutCreateWindow( "Mandelbrot" );
    glutDisplayFunc( display );
    glutMainLoop();
    return 0;
}