异步绘制Mandelbrot分形

示例说明

Mandelbrot示例演示了使用Qt进行多线程编程。它展示了如何使用工作线程执行大量计算而不阻塞主线程的事件循环。Mandelbrot应用程序支持使用鼠标或键盘进行缩放和滚动。为了避免冻结主线程的事件循环(应用程序的用户界面)，我们将所有分形计算放在单独的工作线程中。该线程在绘制分形完成时发出信号。

在工作线程重新计算分形以反映新的缩放因子位置的时候，主线程简单地缩放先前呈现的像素映射以提供即时反馈。结果看起来不如工作线程最终提供的结果好，但至少它使应用程序更有响应性。下面的屏幕截图序列显示原始图像、缩放图像和重新绘制的图像。

类似地，当用户滚动时，会立即滚动上一个像素映射，当时会显示像素映射边缘之外的未绘制区域，图像则再由工作线程来呈现。

代码解析

RenderThread类定义

   class RenderThread : public QThread
    {
        Q_OBJECT
    
    public:
        RenderThread(QObject *parent = 0);
        ~RenderThread();
    
        void render(double centerX, double centerY, double scaleFactor, QSize resultSize);
    
    signals:
        void renderedImage(const QImage &image, double scaleFactor);
    
    protected:
        void run() override;
    
    private:
        uint rgbFromWaveLength(double wave);
    
        QMutex mutex;
        QWaitCondition condition;
        double centerX;
        double centerY;
        double scaleFactor;
        QSize resultSize;
        bool restart;
        bool abort;
    
        enum { ColormapSize = 512 };
        uint colormap[ColormapSize];
    };

该类继承QThread，从而获得在单独线程中运行的能力。除了构造函数和析构函数之外，render()是唯一的公共函数。每当线程完成呈现图像时，它就会发出renderedImage()信号。
函数从QThread重新实现受保护的run()函数。当线程启动时，会自动调用它。
在私有部分中，我们有一个QMutex、一个QWaitCondu和一些其他的数据成员。互斥保护其他数据成员。

RenderThread类实现

    #include <QtWidgets>
    #include <cmath>    
    //在构造函数中，我们将restart和abort变量初始化为false。这些变量控制run()函数的流。
    //还初始化了包含一系列RGB颜色的colormap数组。
    RenderThread::RenderThread(QObject *parent)
        : QThread(parent)
    {
        restart = false;
        abort = false;
    
        for (int i = 0; i < ColormapSize; ++i)
            colormap[i] = rgbFromWaveLength(380.0 + (i * 400.0 / ColormapSize));
    }
    
    //当线程处于活动状态时，可以随时调用析构函数。我们将ABORT设置为true，以告诉run()尽快停止运行。
    //调用QWaitCondu：wakeOne()来唤醒线程(如果线程处于休眠状态)。(将在查看run()时看到，当线程没有什么事做时，线程就会进入休眠状态。)
    //这里要注意的是，run()是在它自己的线程(工作线程)中执行的，而RenderThread构造函数和析构函数(以及Render()函数)则由创建工作线程的线程调用。
    //因此，我们需要一个互斥来保护对中止和条件变量的访问，这些变量可以在任何时候被run()访问。
    //在析构函数的末尾，我们调用QThread：WAIT()，直到run()退出，然后调用基类析构函数。
    RenderThread::~RenderThread()
    {
        mutex.lock();
        abort = true;
        condition.wakeOne();
        mutex.unlock();
    
        wait();
    }
    
    //每当需要生成Mandelbrot集的新图形时，它都会调用Render()函数。
    //CentX、CentY和ScaleFactor参数指定要呈现的分形部分；ResultSize指定生成的QImage的大小。
    //如果线程尚未运行，则启动它；否则，它将重新启动设置为true(告诉run()停止任何未完成的计算，并使用新的参数重新启动)，并唤醒可能处于休眠状态的线程。
    void RenderThread::render(double centerX, double centerY, double scaleFactor,
                              QSize resultSize)
    {
        QMutexLocker locker(&mutex);
    
        this->centerX = centerX;
        this->centerY = centerY;
        this->scaleFactor = scaleFactor;
        this->resultSize = resultSize;
    
        if (!isRunning()) {
            start(LowPriority);
        } else {
            restart = true;
            condition.wakeOne();
        }
    }

    //函数体是一个无限循环
    //使用类的互斥对象保护对成员变量的访问
    //将成员变量存储在局部变量中可以使需要受互斥保护的代码的数量最小化。这确保主线程在需要访问RenderThread的成员变量(例如Render())时不会阻塞太久。
    void RenderThread::run()
    {
        forever {
            mutex.lock();
            QSize resultSize = this->resultSize;
            double scaleFactor = this->scaleFactor;
            double centerX = this->centerX;
            double centerY = this->centerY;
            mutex.unlock();
    
            //算法的核心， 核心算法超出了本教程的范围不做研究
            int halfWidth = resultSize.width() / 2;
            int halfHeight = resultSize.height() / 2;
            QImage image(resultSize, QImage::Format_RGB32);
            const int NumPasses = 8;
            int pass = 0;
            while (pass < NumPasses) {
                const int MaxIterations = (1 << (2 * pass + 6)) + 32;
                const int Limit = 4;
                bool allBlack = true;
    
                for (int y = -halfHeight; y < halfHeight; ++y) {
                    if (restart)
                        break;
                    if (abort)
                        return;
    
                    uint *scanLine =
                            reinterpret_cast<uint *>(image.scanLine(y + halfHeight));
                    double ay = centerY + (y * scaleFactor);
    
                    for (int x = -halfWidth; x < halfWidth; ++x) {
                        double ax = centerX + (x * scaleFactor);
                        double a1 = ax;
                        double b1 = ay;
                        int numIterations = 0;
    
                        do {
                            ++numIterations;
                            double a2 = (a1 * a1) - (b1 * b1) + ax;
                            double b2 = (2 * a1 * b1) + ay;
                            if ((a2 * a2) + (b2 * b2) > Limit)
                                break;
    
                            ++numIterations;
                            a1 = (a2 * a2) - (b2 * b2) + ax;
                            b1 = (2 * a2 * b2) + ay;
                            if ((a1 * a1) + (b1 * b1) > Limit)
                                break;
                        } while (numIterations < MaxIterations);
    
                        if (numIterations < MaxIterations) {
                            *scanLine++ = colormap[numIterations % ColormapSize];
                            allBlack = false;
                        } else {
                            *scanLine++ = qRgb(0, 0, 0);
                        }
                    }
                }
    
                if (allBlack && pass == 0) {
                    pass = 4;
                } else {
                    if (!restart)
                        emit renderedImage(image, scaleFactor);
                    ++pass;
                }
            }
    
            //完成了所有的迭代，我们就调用QWaitCondition::wait()，通过调用使线程进入休眠状态，除非重restart为true。
            //在没有事情可做的情况下，让工作线程无限期地循环是没有用的。
            mutex.lock();
            if (!restart)
                condition.wait(&mutex);
            restart = false;
            mutex.unlock();
        }
    }
   
    //rgbFromWaveLength()函数是一个辅助函数，它将波长转换为与32位QImage兼容的RGB值。
    //它是从构造函数中调用来初始化颜色图数组的。
    uint RenderThread::rgbFromWaveLength(double wave)
    {
        double r = 0.0;
        double g = 0.0;
        double b = 0.0;
    
        if (wave >= 380.0 && wave <= 440.0) {
            r = -1.0 * (wave - 440.0) / (440.0 - 380.0);
            b = 1.0;
        } else if (wave >= 440.0 && wave <= 490.0) {
            g = (wave - 440.0) / (490.0 - 440.0);
            b = 1.0;
        } else if (wave >= 490.0 && wave <= 510.0) {
            g = 1.0;
            b = -1.0 * (wave - 510.0) / (510.0 - 490.0);
        } else if (wave >= 510.0 && wave <= 580.0) {
            r = (wave - 510.0) / (580.0 - 510.0);
            g = 1.0;
        } else if (wave >= 580.0 && wave <= 645.0) {
            r = 1.0;
            g = -1.0 * (wave - 645.0) / (645.0 - 580.0);
        } else if (wave >= 645.0 && wave <= 780.0) {
            r = 1.0;
        }
    
        double s = 1.0;
        if (wave > 700.0)
            s = 0.3 + 0.7 * (780.0 - wave) / (780.0 - 700.0);
        else if (wave <  420.0)
            s = 0.3 + 0.7 * (wave - 380.0) / (420.0 - 380.0);
    
        r = std::pow(r * s, 0.8);
        g = std::pow(g * s, 0.8);
        b = std::pow(b * s, 0.8);
        return qRgb(int(r * 255), int(g * 255), int(b * 255));
    }

MandelbrotWidget 类定义

class MandelbrotWidget : public QWidget
{
    Q_OBJECT

public:
    MandelbrotWidget(QWidget *parent = 0);

protected:
    void paintEvent(QPaintEvent *event) override;
    void resizeEvent(QResizeEvent *event) override;
    void keyPressEvent(QKeyEvent *event) override;
#if QT_CONFIG(wheelevent)
    void wheelEvent(QWheelEvent *event) override;
#endif
    void mousePressEvent(QMouseEvent *event) override;
    void mouseMoveEvent(QMouseEvent *event) override;
    void mouseReleaseEvent(QMouseEvent *event) override;

private slots:
    void updatePixmap(const QImage &image, double scaleFactor);
    void zoom(double zoomFactor);

private:
    void scroll(int deltaX, int deltaY);

    RenderThread thread;
    QPixmap pixmap;
    QPoint pixmapOffset;
    QPoint lastDragPos;
    double centerX;
    double centerY;
    double pixmapScale;
    double curScale;
};

从QWidget继承重新实现了许多事件处理函数。此外，它还有一个updatePixmap()槽，我们将连接到工作线程的renderedImage()信号，以便每当从线程接收到新数据时更新显示。

MandelbrotWidget 类实现

#include <QPainter>
#include <QKeyEvent>

#include <math.h>

#include "mandelbrotwidget.h"



const double DefaultCenterX = -0.637011f;
const double DefaultCenterY = -0.0395159f;
const double DefaultScale = 0.00403897f;

const double ZoomInFactor = 0.8f;
const double ZoomOutFactor = 1 / ZoomInFactor;
const int ScrollStep = 20;

MandelbrotWidget::MandelbrotWidget(QWidget *parent)
    : QWidget(parent)
{
    centerX = DefaultCenterX;
    centerY = DefaultCenterY;
    pixmapScale = DefaultScale;
    curScale = DefaultScale;

    connect(&thread, SIGNAL(renderedImage(QImage,double)), this, SLOT(updatePixmap(QImage,double)));

    setWindowTitle(tr("Mandelbrot"));
#ifndef QT_NO_CURSOR
    setCursor(Qt::CrossCursor);
#endif
    resize(550, 400);

}

//首先用黑色填充背景。如果我们还没有什么可绘制的(pixmap为NULL)
//我们会在widget上打印一条消息，要求用户耐心等待并立即从函数返回。
//如果pixmap具有正确的缩放因子，则将pixmap直接绘制到widget上。
//否则，在绘制pixmap之前，我们对坐标系统进行缩放和转换。
//通过使用scaled painter matrix反向映射小部件的矩形，确保只绘制像素映射的暴露区域。
//对QPainter：Save()和QPainter：restore()的调用确保以后执行的任何绘制都使用标准坐标系
//在画图事件处理程序的末尾，我们在分形的顶部画一个文本字符串和一个半透明的矩形。
void MandelbrotWidget::paintEvent(QPaintEvent * /* event */)
{
    QPainter painter(this);
    painter.fillRect(rect(), Qt::black);


    if (pixmap.isNull()) {
        painter.setPen(Qt::white);
        painter.drawText(rect(), Qt::AlignCenter, tr("Rendering initial image, please wait..."));
    }

    if (curScale == pixmapScale) {
        painter.drawPixmap(pixmapOffset, pixmap);
    } else {
        double scaleFactor = pixmapScale / curScale;
        int newWidth = int(pixmap.width() * scaleFactor);
        int newHeight = int(pixmap.height() * scaleFactor);
        int newX = pixmapOffset.x() + (pixmap.width() - newWidth) / 2;
        int newY = pixmapOffset.y() + (pixmap.height() - newHeight) / 2;

        painter.save();
        painter.translate(newX, newY);
        painter.scale(scaleFactor, scaleFactor);
        QRectF exposed = painter.matrix().inverted().mapRect(rect()).adjusted(-1, -1, 1, 1);
        painter.drawPixmap(exposed, pixmap, exposed);
        painter.restore();
    }

    QString text = tr("Use mouse wheel or the '+' and '-' keys to zoom. "
                      "Press and hold left mouse button to scroll.");
    QFontMetrics metrics = painter.fontMetrics();
    int textWidth = metrics.width(text);

    painter.setPen(Qt::NoPen);
    painter.setBrush(QColor(0, 0, 0, 127));
    painter.drawRect((width() - textWidth) / 2 - 5, 0, textWidth + 10, metrics.lineSpacing() + 5);
    painter.setPen(Qt::white);
    painter.drawText((width() - textWidth) / 2, metrics.leading() + metrics.ascent(), text);
}


//每当用户调整小部件的大小时，我们就调用Render()来生成一个新的映像
//具有相同的centX、centY和curScale参数，但是具有新的widget大小。
void MandelbrotWidget::resizeEvent(QResizeEvent * /* event */)
{
    thread.render(centerX, centerY, curScale, size());
}

void MandelbrotWidget::keyPressEvent(QKeyEvent *event)
{
    switch (event->key()) {
    case Qt::Key_Plus:
        zoom(ZoomInFactor);
        break;
    case Qt::Key_Minus:
        zoom(ZoomOutFactor);
        break;
    case Qt::Key_Left:
        scroll(-ScrollStep, 0);
        break;
    case Qt::Key_Right:
        scroll(+ScrollStep, 0);
        break;
    case Qt::Key_Down:
        scroll(0, -ScrollStep);
        break;
    case Qt::Key_Up:
        scroll(0, +ScrollStep);
        break;
    default:
        QWidget::keyPressEvent(event);
    }
}

#ifndef QT_NO_WHEELEVENT
void MandelbrotWidget::wheelEvent(QWheelEvent *event)
{
    int numDegrees = event->delta() / 8;
    double numSteps = numDegrees / 15.0f;
    zoom(pow(ZoomInFactor, numSteps));
}
#endif

void MandelbrotWidget::mousePressEvent(QMouseEvent *event)
{
    if (event->button() == Qt::LeftButton)
        lastDragPos = event->pos();
}

void MandelbrotWidget::mouseMoveEvent(QMouseEvent *event)
{
    if (event->buttons() & Qt::LeftButton) {
        pixmapOffset += event->pos() - lastDragPos;
        lastDragPos = event->pos();
        update();
    }
}

void MandelbrotWidget::mouseReleaseEvent(QMouseEvent *event)
{
    if (event->button() == Qt::LeftButton) {
        pixmapOffset += event->pos() - lastDragPos;
        lastDragPos = QPoint();

        int deltaX = (width() - pixmap.width()) / 2 - pixmapOffset.x();
        int deltaY = (height() - pixmap.height()) / 2 - pixmapOffset.y();
        scroll(deltaX, deltaY);
    }
}
//当工作线程完成图像呈现时，会调用updatePixmap()槽。
//首先检查拖动是否有效，在这种情况下什么也不做,直接return。
//在正常情况下，将图像存储在像素映射中，并重新初始化其他一些成员。
//最后，我们调用QWidget：update()刷新显示。
void MandelbrotWidget::updatePixmap(const QImage &image, double scaleFactor)
{
    if (!lastDragPos.isNull())
        return;

    pixmap = QPixmap::fromImage(image);
    pixmapOffset = QPoint();
    lastDragPos = QPoint();
    pixmapScale = scaleFactor;
    update();
}

void MandelbrotWidget::zoom(double zoomFactor)
{
    curScale *= zoomFactor;
    update();
    thread.render(centerX, centerY, curScale, size());
}

void MandelbrotWidget::scroll(int deltaX, int deltaY)
{
    centerX += deltaX * curScale;
    centerY += deltaY * curScale;
    update();
    thread.render(centerX, centerY, curScale, size());
}

使用方式

#include "mandelbrotwidget.h"

#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    MandelbrotWidget widget;
    widget.show();
    return app.exec();
}

运行效果