En esta página

Mandelbrot

El ejemplo de Mandelbrot muestra la programación multihilo con Qt. Ilustra cómo utilizar un hilo de trabajo para realizar cálculos intensivos sin bloquear el bucle de eventos del hilo principal.

Captura de pantalla del ejemplo de Mandelbrot

El cálculo intensivo en este caso es el conjunto de Mandelbrot, probablemente el fractal más famoso del mundo. Hoy en día, aunque existen programas sofisticados, como XaoS, que permiten ampliar el conjunto de Mandelbrot en tiempo real, el algoritmo estándar de Mandelbrot es lo suficientemente lento como para nuestros propósitos.

En la práctica, el enfoque aquí descrito es aplicable a una amplia gama de problemas, incluyendo la E/S de red síncrona y el acceso a bases de datos, en los que la interfaz de usuario debe seguir respondiendo mientras se lleva a cabo alguna operación pesada. El ejemplo «Blocking Fortune Client» muestra el mismo principio en acción en un cliente TCP.

La aplicación de Mandelbrot permite ampliar y desplazarse utilizando el ratón o el teclado. Para evitar que se bloquee el bucle de eventos del hilo principal (y, en consecuencia, la interfaz de usuario de la aplicación), colocamos todo el cálculo del fractal en un hilo de trabajo independiente. El hilo emite una señal cuando termina de renderizar el fractal.

Mientras el hilo de trabajo vuelve a calcular el fractal para reflejar la nueva posición del factor de zoom, el hilo principal simplemente escala el mapa de píxeles renderizado anteriormente para ofrecer una respuesta inmediata. El resultado no tiene tan buen aspecto como el que finalmente ofrece el hilo de trabajo, pero al menos hace que la aplicación sea más receptiva. La secuencia de capturas de pantalla que aparece a continuación muestra la imagen original, la imagen escalada y la imagen renderizada de nuevo.

Imagen original de MandelbrotAjustado durante el zoomSe ha vuelto a generar tras el zoom

Del mismo modo, cuando el usuario se desplaza, el mapa de píxeles anterior se desplaza inmediatamente, revelando áreas sin pintar más allá del borde del mapa de píxeles, mientras que la imagen la renderiza el hilo de trabajo.

Posición originalCon un borde ondulado y una zona sin pintarSe vuelve a cargar tras desplazarse por la página

La aplicación consta de dos clases:

  • RenderThread es una subclase de ` QThread ` que representa el conjunto de Mandelbrot.
  • MandelbrotWidget es una subclase de ` QWidget ` que muestra el conjunto de Mandelbrot en pantalla y permite al usuario ampliar y desplazarse.

Si aún no estás familiarizado con el soporte de subprocesos de Qt, te recomendamos que empieces por leer la descripción general sobre «Multihilo en Qt ».

Definición de la clase RenderThread

Empezaremos con la definición de la clase ` RenderThread `:

class RenderThread : public QThread
{
    Q_OBJECT

public:
    RenderThread(QObject *parent = nullptr);
    ~RenderThread();

    void render(double centerX, double centerY, double scaleFactor, QSize resultSize,
                double devicePixelRatio);

    static void setNumPasses(int n) { numPasses = n; }

    static QString infoKey() { return QStringLiteral("info"); }

signals:
    void renderedImage(const QImage &image, double scaleFactor);

protected:
    void run() override;

private:
    static uint rgbFromWaveLength(double wave);

    QMutex mutex;
    QWaitCondition condition;
    double centerX;
    double centerY;
    double scaleFactor;
    double devicePixelRatio;
    QSize resultSize;
    static int numPasses;
    bool restart = false;
    bool abort = false;

    static constexpr int ColormapSize = 512;
    uint colormap[ColormapSize];
};

La clase hereda de ` QThread `, lo que le permite ejecutarse en un hilo independiente. Aparte del constructor y el destructor, ` render() ` es la única función pública. Cada vez que el hilo termina de renderizar una imagen, emite la señal ` renderedImage() `.

La función protegida ` run() ` se reimplementa a partir de ` QThread`. Se invoca automáticamente al iniciarse el hilo.

En la sección ` private `, tenemos un ` QMutex`, un ` QWaitCondition` y algunos otros miembros de datos. El mutex protege al resto de miembros de datos.

Implementación de la clase RenderThread

RenderThread::RenderThread(QObject *parent)
    : QThread(parent)
{
    for (int i = 0; i < ColormapSize; ++i)
        colormap[i] = rgbFromWaveLength(380.0 + (i * 400.0 / ColormapSize));
}

En el constructor, inicializamos las variables « restart » y « abort » con el valor « false ». Estas variables controlan el flujo de la función « run() ».

También inicializamos la matriz colormap, que contiene una serie de colores RGB.

RenderThread::~RenderThread()
{
    mutex.lock();
    abort = true;
    condition.wakeOne();
    mutex.unlock();

    wait();
}

El destructor se puede invocar en cualquier momento mientras el hilo esté activo. Establecemos abort en true para indicar a run() que deje de ejecutarse lo antes posible. También invocamos QWaitCondition::wakeOne() para despertar el hilo si está inactivo. (Como veremos al revisar run(), el hilo se pone en estado de inactividad cuando no tiene nada que hacer).

Lo importante que hay que tener en cuenta aquí es que run() se ejecuta en su propio hilo (el hilo de trabajo), mientras que el constructor y el destructor de RenderThread (así como la función render() ) son invocados por el hilo que creó el hilo de trabajo. Por lo tanto, necesitamos un mutex para proteger los accesos a las variables abort y condition, a las que run() podría acceder en cualquier momento.

Al final del destructor, llamamos a ` QThread::wait()` para esperar a que ` run() ` haya finalizado antes de que se invoque el destructor de la clase base.

void RenderThread::render(double centerX, double centerY, double scaleFactor,
                          QSize resultSize, double devicePixelRatio)
{
    QMutexLocker locker(&mutex);

    this->centerX = centerX;
    this->centerY = centerY;
    this->scaleFactor = scaleFactor;
    this->devicePixelRatio = devicePixelRatio;
    this->resultSize = resultSize;

    if (!isRunning()) {
        start(LowPriority);
    } else {
        restart = true;
        condition.wakeOne();
    }
}

La función render() es llamada por MandelbrotWidget siempre que necesita generar una nueva imagen del conjunto de Mandelbrot. Los parámetros centerX, centerY y scaleFactor especifican la parte del fractal que se va a renderizar; resultSize especifica el tamaño del archivo resultante QImage.

La función almacena los parámetros en variables miembro. Si el hilo aún no se está ejecutando, lo inicia; de lo contrario, establece restart en true (indicando a run() que detenga cualquier cálculo pendiente y vuelva a empezar con los nuevos parámetros) y activa el hilo, que podría estar inactivo.

void RenderThread::run()
{
    QElapsedTimer timer;
    forever {
        mutex.lock();
        const double devicePixelRatio = this->devicePixelRatio;
        const QSize resultSize = this->resultSize * devicePixelRatio;
        const double requestedScaleFactor = this->scaleFactor;
        const double scaleFactor = requestedScaleFactor / devicePixelRatio;
        const double centerX = this->centerX;
        const double centerY = this->centerY;
        mutex.unlock();

run() Es una función bastante extensa, así que la dividiremos en partes.

El cuerpo de la función es un bucle infinito que comienza almacenando los parámetros de renderizado en variables locales. Como es habitual, protegemos los accesos a las variables de miembro utilizando el mutex de la clase. Almacenar las variables de miembro en variables locales nos permite minimizar la cantidad de código que debe protegerse mediante un mutex. Esto garantiza que el hilo principal nunca tenga que bloquearse durante demasiado tiempo cuando necesite acceder a las variables de miembro de ` RenderThread` (por ejemplo, en ` render()`).

La palabra clave forever es una pseudoplaza clave de Qt.

        const int halfWidth = resultSize.width() / 2;
        const int halfHeight = resultSize.height() / 2;
        QImage image(resultSize, QImage::Format_RGB32);
        image.setDevicePixelRatio(devicePixelRatio);

        int pass = 0;
        while (pass < numPasses) {
            const int MaxIterations = (1 << (2 * pass + 6)) + 32;
            constexpr int Limit = 4;
            bool allBlack = true;

            timer.start();

            for (int y = -halfHeight; y < halfHeight; ++y) {
                if (restart)
                    break;
                if (abort)
                    return;

                auto scanLine =
                        reinterpret_cast<uint *>(image.scanLine(y + halfHeight));
                const double ay = centerY + (y * scaleFactor);

                for (int x = -halfWidth; x < halfWidth; ++x) {
                    const double ax = centerX + (x * scaleFactor);
                    double a1 = ax;
                    double b1 = ay;
                    int numIterations = 0;

                    do {
                        ++numIterations;
                        const double a2 = (a1 * a1) - (b1 * b1) + ax;
                        const 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) {
                    QString message;
                    QTextStream str(&message);
                    str << " Pass " << (pass + 1) << '/' << numPasses
                        << ", max iterations: " << MaxIterations << ", time: ";
                    const auto elapsed = timer.elapsed();
                    if (elapsed > 2000)
                        str << (elapsed / 1000) << 's';
                    else
                        str << elapsed << "ms";
                    image.setText(infoKey(), message);

                    emit renderedImage(image, requestedScaleFactor);
                }
                ++pass;
            }
        }

A continuación viene el núcleo del algoritmo. En lugar de intentar crear una imagen perfecta del conjunto de Mandelbrot, realizamos múltiples pasadas y generamos aproximaciones cada vez más precisas (y más costosas desde el punto de vista computacional) del fractal.

Creamos un mapa de píxeles de alta resolución aplicando la relación de píxeles del dispositivo al tamaño de destino (véase Drawing High Resolution Versions of Pixmaps and Images).

Si dentro del bucle detectamos que restart se ha establecido en true (mediante render()), salimos del bucle inmediatamente, de modo que el control vuelve rápidamente al principio del bucle exterior (el bucle forever ) y recuperamos los nuevos parámetros de renderizado. Del mismo modo, si detectamos que abort se ha establecido en true (por el destructor de RenderThread ), salimos de la función inmediatamente, lo que termina el hilo.

El algoritmo principal queda fuera del alcance de este tutorial.

        mutex.lock();
        if (!restart)
            condition.wait(&mutex);
        restart = false;
        mutex.unlock();
    }
}

Una vez finalizadas todas las iteraciones, llamamos a QWaitCondition::wait() para poner el hilo en espera, a menos que restart sea true. No tiene sentido mantener un hilo de trabajo en bucle indefinidamente mientras no haya nada que hacer.

uint RenderThread::rgbFromWaveLength(double wave)
{
    double r = 0;
    double g = 0;
    double b = 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));
}

La función ` rgbFromWaveLength() ` es una función auxiliar que convierte una longitud de onda en un valor RGB compatible con los objetos ` QImage` de 32 bits. Se invoca desde el constructor para inicializar la matriz ` colormap ` con colores agradables.

Definición de la clase MandelbrotWidget

La clase ` MandelbrotWidget ` utiliza ` RenderThread ` para dibujar el conjunto de Mandelbrot en pantalla. A continuación se muestra la definición de la clase:

class MandelbrotWidget : public QWidget
{
    Q_DECLARE_TR_FUNCTIONS(MandelbrotWidget)

public:
    MandelbrotWidget(QWidget *parent = nullptr);

protected:
    QSize sizeHint() const override { return {1024, 768}; };
    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;
#ifndef QT_NO_GESTURES
    bool event(QEvent *event) override;
#endif

private:
    void updatePixmap(const QImage &image, double scaleFactor);
    void zoom(double zoomFactor);
    void scroll(int deltaX, int deltaY);
#ifndef QT_NO_GESTURES
    bool gestureEvent(QGestureEvent *event);
#endif

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

El widget reimplementa muchos controladores de eventos de QWidget. Además, cuenta con una ranura updatePixmap() que conectaremos a la señal renderedImage() del hilo de trabajo para actualizar la visualización cada vez que recibamos nuevos datos del hilo.

Entre las variables privadas, tenemos thread de tipo RenderThread y pixmap, que contiene la última imagen renderizada.

Implementación de la clase MandelbrotWidget

constexpr double DefaultCenterX = -0.637011;
constexpr double DefaultCenterY = -0.0395159;
constexpr double DefaultScale = 0.00403897;

constexpr double ZoomInFactor = 0.8;
constexpr double ZoomOutFactor = 1 / ZoomInFactor;
constexpr int ScrollStep = 20;

La implementación comienza con unas cuantas constantes que necesitaremos más adelante.

MandelbrotWidget::MandelbrotWidget(QWidget *parent) :
    QWidget(parent),
    centerX(DefaultCenterX),
    centerY(DefaultCenterY),
    pixmapScale(DefaultScale),
    curScale(DefaultScale)
{
    help = tr("Zoom with mouse wheel, +/- keys or pinch.  Scroll with arrow keys or by dragging.");
    connect(&thread, &RenderThread::renderedImage,
            this, &MandelbrotWidget::updatePixmap);

    setWindowTitle(tr("Mandelbrot"));
#if QT_CONFIG(cursor)
    setCursor(Qt::CrossCursor);
#endif
}

La parte interesante del constructor es la llamada a ` QObject::connect()`.

Aunque parece una conexión estándar de señal-slot entre dos QObject, dado que la señal se emite en un hilo diferente al que reside el receptor, la conexión es, en realidad, un queued connection. Estas conexiones son asíncronas (es decir, no bloqueantes), lo que significa que el slot se llamará en algún momento después de la instrucción emit. Es más, el slot se invocará en el hilo en el que reside el receptor. En este caso, la señal se emite en el hilo de trabajo, y el slot se ejecuta en el hilo de la interfaz gráfica de usuario cuando el control vuelve al bucle de eventos.

Con las conexiones en cola, Qt debe almacenar una copia de los argumentos que se pasaron a la señal para poder pasárselos al slot más adelante. Qt sabe cómo crear copias de muchos tipos de C++ y Qt, por lo que no se necesita ninguna acción adicional para QImage. Si se utilizara un tipo personalizado, sería necesario llamar a la función de plantilla qRegisterMetaType() antes de que el tipo pudiera utilizarse como parámetro en las conexiones en cola.

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|Qt::TextWordWrap,
                         tr("Rendering initial image, please wait..."));
        return;
    }

En paintEvent(), comenzamos rellenando el fondo con negro. Si aún no tenemos nada que dibujar (pixmap es nulo), mostramos un mensaje en el widget pidiendo al usuario que tenga paciencia y salimos de la función inmediatamente.

    if (qFuzzyCompare(curScale, pixmapScale)) {
        painter.drawPixmap(pixmapOffset, pixmap);
    } else {
        const auto previewPixmap = qFuzzyCompare(pixmap.devicePixelRatio(), qreal(1))
            ? pixmap
            : pixmap.scaled(pixmap.deviceIndependentSize().toSize(), Qt::KeepAspectRatio,
                            Qt::SmoothTransformation);
        const double scaleFactor = pixmapScale / curScale;
        const int newWidth = int(previewPixmap.width() * scaleFactor);
        const int newHeight = int(previewPixmap.height() * scaleFactor);
        const int newX = pixmapOffset.x() + (previewPixmap.width() - newWidth) / 2;
        const int newY = pixmapOffset.y() + (previewPixmap.height() - newHeight) / 2;

        painter.save();
        painter.translate(newX, newY);
        painter.scale(scaleFactor, scaleFactor);

        QRectF exposed = painter.transform().inverted().mapRect(rect());
        exposed = exposed.adjusted(-1, -1, 1, 1);
        painter.drawPixmap(exposed, previewPixmap, exposed);
        painter.restore();
    }

Si el mapa de píxeles tiene el factor de escala adecuado, lo dibujamos directamente sobre el widget.

De lo contrario, creamos un mapa de píxeles de vista previa que se mostrará hasta que finalice el cálculo y trasladamos el sistema de coordenadas en consecuencia.

Dado que vamos a aplicar transformaciones al pintor y a utilizar una sobrecarga de ` QPainter::drawPixmap()` que, en ese caso, no admite mapas de píxeles de alta resolución, creamos un mapa de píxeles con una relación de píxeles del dispositivo igual a 1.

Al realizar un mapeo inverso del rectángulo del widget utilizando la matriz de pintura escalada, también nos aseguramos de que solo se dibujen las áreas expuestas del mapa de píxeles. Las llamadas a QPainter::save() y QPainter::restore() garantizan que cualquier dibujo que se realice posteriormente utilice el sistema de coordenadas estándar.

    const QFontMetrics metrics = painter.fontMetrics();
    if (!info.isEmpty()){
        const int infoWidth = metrics.horizontalAdvance(info);
        const int infoHeight = (infoWidth/width() + 1) * (metrics.height() + 5);

        painter.setPen(Qt::NoPen);
        painter.setBrush(QColor(0, 0, 0, 127));
        painter.drawRect((width() - infoWidth) / 2 - 5, 0, infoWidth + 10, infoHeight);

        painter.setPen(Qt::white);
        painter.drawText(rect(), Qt::AlignHCenter|Qt::AlignTop|Qt::TextWordWrap, info);
    }

    const int helpWidth = metrics.horizontalAdvance(help);
    const int helpHeight = (helpWidth/width() + 1) * (metrics.height() + 5);

    painter.setPen(Qt::NoPen);
    painter.setBrush(QColor(0, 0, 0, 127));
    painter.drawRect((width() - helpWidth) / 2 - 5, height()-helpHeight, helpWidth + 10,
                     helpHeight);

    painter.setPen(Qt::white);
    painter.drawText(rect(), Qt::AlignHCenter|Qt::AlignBottom|Qt::TextWordWrap, help);

}

Al final del controlador de eventos de pintura, dibujamos una cadena de texto y un rectángulo semitransparente sobre el fractal.

void MandelbrotWidget::resizeEvent(QResizeEvent * /* event */)
{
    thread.render(centerX, centerY, curScale, size(), devicePixelRatio());
}

Cada vez que el usuario cambia el tamaño del widget, llamamos a render() para empezar a generar una nueva imagen, con los mismos parámetros centerX, centerY y curScale, pero con el nuevo tamaño del widget.

Ten en cuenta que nos basamos en que Qt llame automáticamente a resizeEvent() cuando se muestra el widget por primera vez para generar la imagen inicial.

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;
    case Qt::Key_Q:
        close();
        break;
    default:
        QWidget::keyPressEvent(event);
    }
}

El controlador de eventos de pulsación de teclas proporciona varios atajos de teclado para facilitar el uso a los usuarios que no dispongan de ratón. Las funciones ` zoom() ` y ` scroll() ` se tratarán más adelante.

void MandelbrotWidget::wheelEvent(QWheelEvent *event)
{
    const int numDegrees = event->angleDelta().y() / 8;
    const double numSteps = numDegrees / double(15);
    zoom(pow(ZoomInFactor, numSteps));
}

El controlador de eventos de la rueda se ha reimplementado para que la rueda del ratón controle el nivel de zoom. QWheelEvent::angleDelta() devuelve el ángulo de movimiento de la rueda del ratón, en octavos de grado. En la mayoría de los ratones, un paso de la rueda corresponde a 15 grados. Averiguamos cuántos pasos del ratón tenemos y determinamos el factor de zoom resultante. Por ejemplo, si tenemos dos pasos de rueda en dirección positiva (es decir, +30 grados), el factor de zoom pasa a ser ZoomInFactor elevado al cuadrado, es decir, 0,8 * 0,8 = 0,64.

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

El zoom por pellizco se ha implementado con QGesture, tal y como se describe en «Gestos en widgets y vista gráfica».

#ifndef QT_NO_GESTURES
bool MandelbrotWidget::gestureEvent(QGestureEvent *event)
{
    if (auto *pinch = static_cast<QPinchGesture *>(event->gesture(Qt::PinchGesture))) {
        if (pinch->changeFlags().testFlag(QPinchGesture::ScaleFactorChanged))
            zoom(1.0 / pinch->scaleFactor());
        return true;
    }
    return false;
}

bool MandelbrotWidget::event(QEvent *event)
{
    if (event->type() == QEvent::Gesture)
        return gestureEvent(static_cast<QGestureEvent*>(event));
    return QWidget::event(event);
}
#endif

Cuando el usuario pulsa el botón izquierdo del ratón, almacenamos la posición del puntero del ratón en ` lastDragPos`.

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

Cuando el usuario mueve el puntero del ratón mientras mantiene pulsado el botón izquierdo, ajustamos ` pixmapOffset ` para dibujar el mapa de píxeles en una posición desplazada y llamamos a ` QWidget::update()` para forzar un redibujado.

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

        const auto pixmapSize = pixmap.deviceIndependentSize().toSize();
        const int deltaX = (width() - pixmapSize.width()) / 2 - pixmapOffset.x();
        const int deltaY = (height() - pixmapSize.height()) / 2 - pixmapOffset.y();
        scroll(deltaX, deltaY);
    }
}

Cuando se suelta el botón izquierdo del ratón, actualizamos ` pixmapOffset ` igual que hicimos al mover el ratón y restablecemos ` lastDragPos ` a su valor por defecto. A continuación, llamamos a ` scroll() ` para renderizar una nueva imagen para la nueva posición. (Ajustar ` pixmapOffset ` no es suficiente porque las áreas que quedan al descubierto al arrastrar el mapa de píxeles se dibujan en negro.)

void MandelbrotWidget::updatePixmap(const QImage &image, double scaleFactor)
{
    if (!lastDragPos.isNull())
        return;

    info = image.text(RenderThread::infoKey());

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

La cola de eventos « updatePixmap() » se activa cuando el hilo de trabajo ha terminado de renderizar una imagen. Empezamos comprobando si hay un arrastre en curso y, en ese caso, no hacemos nada. En condiciones normales, almacenamos la imagen en ` pixmap ` y reinicializamos algunos de los demás miembros. Al final, llamamos a ` QWidget::update()` para actualizar la pantalla.

Llegados a este punto, quizá te preguntes por qué utilizamos un ` QImage ` para el parámetro y un ` QPixmap ` para el miembro de datos. ¿Por qué no nos ceñimos a un solo tipo? La razón es que QImage es la única clase que admite la manipulación directa de píxeles, algo que necesitamos en el hilo de trabajo. Por otro lado, antes de que una imagen pueda dibujarse en pantalla, debe convertirse en un mapa de píxeles. Es mejor realizar la conversión de una vez por todas aquí, en lugar de hacerlo en paintEvent().

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

En zoom(), volvemos a calcular curScale. A continuación, llamamos a QWidget::update() para dibujar un mapa de píxeles escalado y le pedimos al hilo de trabajo que renderice una nueva imagen correspondiente al nuevo valor de curScale.

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

scroll() es similar a zoom(), salvo que los parámetros afectados son centerX y centerY.

La función main()

El carácter multihilo de la aplicación no afecta a su función main(), que es tan sencilla como de costumbre:

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    QCommandLineParser parser;
    parser.setApplicationDescription(u"Ejemplo de Mandelbrot en Qt"_s);
    parser.addHelpOption();
    parser.addVersionOption();
    QCommandLineOption passesOption(u"passes"_s, u"Número de pasadas (1-8)"_s, u"passes"_s);
    parser.addOption(passesOption);
    parser.process(app);

   if (parser.isSet(passesOption)) {
        const auto passesStr = parser.value(passesOption);
       bool ok;
        const int passes = passesStr.toInt(&ok);
        if (!ok|| passes < 1|| passes > 8) {
            qWarning() << "Invalid value:" << passesStr;
           return-1;
        }
        RenderThread::setNumPasses(passes);
    }

    MandelbrotWidget widget;
    widget.grabGesture(Qt::PinchGesture);
    widget.show();
    return app.exec();
}

Proyecto de ejemplo en code.qt.io

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.