quantumtalbotplotwidget.cpp

Go to the documentation of this file.

/**
 * @file quantumtalbotplotwidget.cpp
 * @brief Implements the quantumtalbotplotwidget visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/quantumtalbotplotwidget.cpp. This file is part of Quantum Phenomena Explorer (QPE),
 * maintained by Officina Turini. See LICENSE_IT.txt / LICENSE.txt for the
 * QPE freeware source-available terms and THIRD_PARTY_NOTICES.txt for
 * third-party components.
 */
 
#include "quantumtalbotplotwidget.h"
 
#include <QImage>
#include <QPaintEvent>
#include <QPainter>
#include <QPainterPath>
 
#include <algorithm>
#include <cmath>
 
namespace {
 
/**
 * @brief Draws frame.
 * @param painter The painter value used by the operation.
 * @param rect The rect value used by the operation.
 */
void drawFrame(QPainter &painter, const QRectF &rect)
{
    painter.setPen(QPen(QColor(72, 80, 90), 1.0));
    painter.drawRect(rect);
}
 
/**
 * @brief Performs carpet colour.
 * @param intensity The intensity value used by the operation.
 */
QRgb carpetColour(double intensity)
{
    const double v = std::max(0.0, std::min(1.0, intensity));
    const int r = static_cast<int>(255.0 * std::pow(v, 1.55));
    const int g = static_cast<int>(255.0 * std::pow(v, 0.72));
    const int b = static_cast<int>(255.0 * std::min(1.0, 0.18 + 1.25 * std::pow(v, 0.90)));
    return qRgb(r, g, b);
}
 
} // namespace
 
QuantumTalbotPlotWidget::QuantumTalbotPlotWidget(QWidget *parent)
    : QWidget(parent)
{
    setMinimumHeight(360);
    setAutoFillBackground(false);
}
 
void QuantumTalbotPlotWidget::setData(const qpe::QuantumTalbotHistory2D &history,
                                      double mass,
                                      double hbar)
{
    history_ = &history;
    mass_ = mass;
    hbar_ = hbar;
    update();
}
 
void QuantumTalbotPlotWidget::clear()
{
    history_ = nullptr;
    update();
}
 
QSize QuantumTalbotPlotWidget::minimumSizeHint() const
{
    return QSize(600, 380);
}
 
void QuantumTalbotPlotWidget::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);
 
    QPainter painter(this);
    painter.setRenderHint(QPainter::Antialiasing, true);
    painter.setRenderHint(QPainter::TextAntialiasing, true);
    painter.fillRect(rect(), QColor(14, 17, 22));
 
    const double left = 64.0;
    const double right = 24.0;
    const double top = 30.0;
    const double bottom = 38.0;
    const double gap = 36.0;
    const double available = std::max(100.0, height() - top - bottom - gap);
    const double carpetHeight = available * 0.68;
    const QRectF carpetRect(left, top,
                            std::max(30.0, width() - left - right), carpetHeight);
    const QRectF correlationRect(left, carpetRect.bottom() + gap,
                                 carpetRect.width(), available - carpetHeight);
 
    drawFrame(painter, carpetRect);
    drawFrame(painter, correlationRect);
 
    painter.setPen(QColor(214, 220, 228));
    painter.drawText(QRectF(carpetRect.left(), 4.0, carpetRect.width(), 20.0),
                     Qt::AlignCenter,
                     QStringLiteral("Talbot carpet: transverse x-marginal versus time"));
    painter.drawText(QRectF(correlationRect.left(), carpetRect.bottom() + 8.0,
                            correlationRect.width(), 20.0), Qt::AlignCenter,
                     QStringLiteral("Self-image correlation: original / half-period shifted"));
 
    if (history_ == nullptr || history_->empty() || !history_->hasReference() ||
        history_->gridWidth() < 2u || !(history_->dx() > 0.0f)) {
        painter.setPen(QColor(220, 228, 238));
        painter.drawText(carpetRect, Qt::AlignCenter,
                         QStringLiteral("Run the Quantum Talbot Self-Imaging preset"));
        painter.drawText(correlationRect, Qt::AlignCenter,
                         QStringLiteral("The initial transverse comb builds its own x-time carpet"));
        return;
    }
 
    const std::vector<qpe::QuantumTalbotSample2D> &samples = history_->samples();
    const std::size_t columns = history_->gridWidth();
    const int rows = static_cast<int>(samples.size());
 
    if (columns > 0u && rows > 0) {
        QImage image(static_cast<int>(columns), rows, QImage::Format_RGB32);
        for (int row = 0; row < rows; ++row) {
            const std::vector<float> &marginal = samples[static_cast<std::size_t>(row)].marginalX;
            double rowMax = 0.0;
            for (std::size_t x = 0u; x < std::min(columns, marginal.size()); ++x) {
                rowMax = std::max(rowMax, static_cast<double>(marginal[x]));
            }
            rowMax = std::max(rowMax, 1.0e-30);
            for (std::size_t x = 0u; x < columns; ++x) {
                const double value = x < marginal.size()
                    ? static_cast<double>(marginal[x]) / rowMax : 0.0;
                image.setPixel(static_cast<int>(x), row,
                               carpetColour(std::sqrt(std::max(0.0, value))));
            }
        }
        painter.setRenderHint(QPainter::SmoothPixmapTransform, false);
        painter.drawImage(carpetRect, image, QRectF(image.rect()));
        painter.setRenderHint(QPainter::Antialiasing, true);
    }
 
    const double tMin = samples.front().time;
    const double tMax = samples.back().time;
    const double timeSpan = std::max(1.0e-12, tMax - tMin);
    const double tTalbot = qpe::QuantumTalbot2D::talbotTime(
        history_->config().period, mass_, hbar_);
 
    const auto mapTimeX = [correlationRect, tMin, timeSpan](double t) {
        return correlationRect.left() + (t - tMin) / timeSpan * correlationRect.width();
    };
    const auto mapCorrelationY = [correlationRect](double v) {
        const double clamped = std::max(0.0, std::min(1.0, v));
        return correlationRect.bottom() - clamped * correlationRect.height();
    };
    const auto mapTimeY = [carpetRect, tMin, timeSpan](double t) {
        return carpetRect.top() + (t - tMin) / timeSpan * carpetRect.height();
    };
 
    painter.setPen(QPen(QColor(72, 80, 90), 1.0));
    for (int i = 1; i < 4; ++i) {
        const double y = correlationRect.top() + i * correlationRect.height() / 4.0;
        painter.drawLine(QPointF(correlationRect.left(), y),
                         QPointF(correlationRect.right(), y));
    }
 
    if (tTalbot > 0.0) {
        for (int n = 1; n <= 12; ++n) {
            const double t = 0.25 * static_cast<double>(n) * tTalbot;
            if (t < tMin || t > tMax) continue;
            const bool full = (n % 4) == 0;
            const bool half = (n % 2) == 0 && !full;
            const QColor guide = full ? QColor(245, 225, 120)
                                : (half ? QColor(220, 120, 245) : QColor(120, 145, 165));
            painter.setPen(QPen(guide, full ? 1.5 : 1.0, Qt::DashLine));
            painter.drawLine(QPointF(mapTimeX(t), correlationRect.top()),
                             QPointF(mapTimeX(t), correlationRect.bottom()));
            painter.drawLine(QPointF(carpetRect.left(), mapTimeY(t)),
                             QPointF(carpetRect.right(), mapTimeY(t)));
        }
    }
 
    QPainterPath directPath;
    QPainterPath shiftedPath;
    bool started = false;
    for (const qpe::QuantumTalbotSample2D &sample : samples) {
        const QPointF direct(mapTimeX(sample.time), mapCorrelationY(sample.directCorrelation));
        const QPointF shifted(mapTimeX(sample.time), mapCorrelationY(sample.halfShiftCorrelation));
        if (!started) {
            directPath.moveTo(direct);
            shiftedPath.moveTo(shifted);
            started = true;
        } else {
            directPath.lineTo(direct);
            shiftedPath.lineTo(shifted);
        }
    }
 
    painter.setPen(QPen(QColor(80, 220, 255), 2.1));
    painter.drawPath(directPath);
    painter.setPen(QPen(QColor(235, 115, 255), 1.9));
    painter.drawPath(shiftedPath);
 
    painter.setPen(QColor(215, 224, 234));
    painter.drawText(QRectF(4.0, correlationRect.top() - 8.0, 54.0, 18.0),
                     Qt::AlignRight | Qt::AlignVCenter, QStringLiteral("1.0"));
    painter.drawText(QRectF(4.0, correlationRect.bottom() - 10.0, 54.0, 18.0),
                     Qt::AlignRight | Qt::AlignVCenter, QStringLiteral("0.0"));
 
    const double physicalWidth = static_cast<double>(history_->gridWidth()) * history_->dx();
    painter.drawText(QRectF(carpetRect.left(), carpetRect.bottom() + 2.0, 120.0, 20.0),
                     Qt::AlignLeft,
                     QStringLiteral("x = %1").arg(-0.5 * physicalWidth, 0, 'f', 2));
    painter.drawText(QRectF(carpetRect.right() - 120.0, carpetRect.bottom() + 2.0, 120.0, 20.0),
                     Qt::AlignRight,
                     QStringLiteral("x = %1").arg(0.5 * physicalWidth, 0, 'f', 2));
    painter.drawText(QRectF(correlationRect.left(), correlationRect.bottom() + 6.0, 90.0, 20.0),
                     Qt::AlignLeft, QString::number(tMin, 'f', 1));
    painter.drawText(QRectF(correlationRect.right() - 90.0, correlationRect.bottom() + 6.0,
                            90.0, 20.0), Qt::AlignRight, QString::number(tMax, 'f', 1));
    painter.drawText(QRectF(correlationRect.left(), correlationRect.bottom() + 4.0,
                            correlationRect.width(), 24.0), Qt::AlignCenter,
                     QStringLiteral("simulation time"));
 
    const double legendY = carpetRect.bottom() + 2.0;
    painter.setPen(QColor(80, 220, 255));
    painter.drawText(QRectF(carpetRect.left() + 140.0, legendY, 170.0, 20.0), Qt::AlignLeft,
                     QStringLiteral("cyan: original image"));
    painter.setPen(QColor(235, 115, 255));
    painter.drawText(QRectF(carpetRect.left() + 310.0, legendY, 230.0, 20.0), Qt::AlignLeft,
                     QStringLiteral("magenta: shifted by a/2"));
}