quantumbilliardplotwidget.cpp

Go to the documentation of this file.

/**
 * @file quantumbilliardplotwidget.cpp
 * @brief Implements the quantumbilliardplotwidget visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/quantumbilliardplotwidget.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 "quantumbilliardplotwidget.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 density colour.
 * @param intensity The intensity value used by the operation.
 */
QRgb densityColour(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.7));
    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.12 + 1.25 * std::pow(v, 0.9)));
    return qRgb(r, g, b);
}
 
} // namespace
 
QuantumBilliardPlotWidget::QuantumBilliardPlotWidget(QWidget *parent)
    : QWidget(parent)
{
    setMinimumHeight(360);
    setAutoFillBackground(false);
}
 
void QuantumBilliardPlotWidget::setData(const qpe::QuantumBilliardHistory2D &history,
                                        const qpe::QuantumBilliardGeometry2D &geometry)
{
    history_ = &history;
    geometry_ = geometry;
    update();
}
 
void QuantumBilliardPlotWidget::clear()
{
    history_ = nullptr;
    geometry_ = qpe::QuantumBilliardGeometry2D();
    update();
}
 
QSize QuantumBilliardPlotWidget::minimumSizeHint() const
{
    return QSize(600, 380);
}
 
void QuantumBilliardPlotWidget::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 marginLeft = 62.0;
    const double marginRight = 24.0;
    const double top = 30.0;
    const double bottom = 38.0;
    const double gap = 36.0;
    const double available = std::max(120.0, height() - top - bottom - gap);
    const double mapHeight = available * 0.63;
    const QRectF mapRect(marginLeft, top,
                         std::max(40.0, width() - marginLeft - marginRight), mapHeight);
    const QRectF curveRect(marginLeft, mapRect.bottom() + gap,
                           mapRect.width(), available - mapHeight);
 
    drawFrame(painter, mapRect);
    drawFrame(painter, curveRect);
 
    painter.setPen(QColor(214, 220, 228));
    painter.drawText(QRectF(mapRect.left(), 4.0, mapRect.width(), 20.0), Qt::AlignCenter,
                     QStringLiteral("Time-averaged probability density inside the billiard"));
    painter.drawText(QRectF(curveRect.left(), mapRect.bottom() + 8.0,
                            curveRect.width(), 20.0), Qt::AlignCenter,
                     QStringLiteral("Spatial filling / recurrence / scatterer encounter"));
 
    if (!geometry_.valid || history_ == nullptr || history_->empty() ||
        history_->gridWidth() < 2u || history_->gridHeight() < 2u) {
        painter.setPen(QColor(220, 228, 238));
        painter.drawText(mapRect, Qt::AlignCenter,
                         QStringLiteral("Run a Quantum Billiard preset to accumulate the occupation map"));
        painter.drawText(curveRect, Qt::AlignCenter,
                         QStringLiteral("Four box walls are required; Sinai adds one circular scatterer"));
        return;
    }
 
    const std::vector<float> &mean = history_->meanProbabilityDensity();
    const std::size_t gw = history_->gridWidth();
    const std::size_t gh = history_->gridHeight();
    const double dx = history_->dx();
    const double dy = history_->dy();
    const double x0 = geometry_.centerX - 0.5 * geometry_.innerWidth;
    const double x1 = geometry_.centerX + 0.5 * geometry_.innerWidth;
    const double y0 = geometry_.centerY - 0.5 * geometry_.innerHeight;
    const double y1 = geometry_.centerY + 0.5 * geometry_.innerHeight;
    const double gxCentre = 0.5 * static_cast<double>(gw - 1u);
    const double gyCentre = 0.5 * static_cast<double>(gh - 1u);
    int ix0 = static_cast<int>(std::ceil(x0 / dx + gxCentre));
    int ix1 = static_cast<int>(std::floor(x1 / dx + gxCentre));
    int iy0 = static_cast<int>(std::ceil(y0 / dy + gyCentre));
    int iy1 = static_cast<int>(std::floor(y1 / dy + gyCentre));
    ix0 = std::max(0, std::min(ix0, static_cast<int>(gw) - 1));
    ix1 = std::max(ix0, std::min(ix1, static_cast<int>(gw) - 1));
    iy0 = std::max(0, std::min(iy0, static_cast<int>(gh) - 1));
    iy1 = std::max(iy0, std::min(iy1, static_cast<int>(gh) - 1));
 
    const int columns = ix1 - ix0 + 1;
    const int rows = iy1 - iy0 + 1;
    double maxDensity = 0.0;
    for (int y = iy0; y <= iy1; ++y) {
        for (int x = ix0; x <= ix1; ++x) {
            const std::size_t index = static_cast<std::size_t>(y) * gw + static_cast<std::size_t>(x);
            if (index < mean.size()) maxDensity = std::max(maxDensity, static_cast<double>(mean[index]));
        }
    }
    maxDensity = std::max(maxDensity, 1.0e-30);
 
    if (columns > 0 && rows > 0 && mean.size() == gw * gh) {
        QImage image(columns, rows, QImage::Format_RGB32);
        for (int yy = 0; yy < rows; ++yy) {
            const int gy = iy1 - yy; // physical +Y upward in the display
            for (int xx = 0; xx < columns; ++xx) {
                const int gx = ix0 + xx;
                const std::size_t index = static_cast<std::size_t>(gy) * gw + static_cast<std::size_t>(gx);
                const double normalized = static_cast<double>(mean[index]) / maxDensity;
                image.setPixel(xx, yy, densityColour(std::sqrt(std::max(0.0, normalized))));
            }
        }
        painter.setRenderHint(QPainter::SmoothPixmapTransform, false);
        painter.drawImage(mapRect, image, QRectF(image.rect()));
        painter.setRenderHint(QPainter::Antialiasing, true);
    }
 
    if (geometry_.hasObstacle) {
        const double cx = mapRect.left() +
            (geometry_.obstacleCenterX - x0) / std::max(1.0e-12, x1 - x0) * mapRect.width();
        const double cy = mapRect.bottom() -
            (geometry_.obstacleCenterY - y0) / std::max(1.0e-12, y1 - y0) * mapRect.height();
        const double rx = geometry_.obstacleRadius / (x1 - x0) * mapRect.width();
        const double ry = geometry_.obstacleRadius / (y1 - y0) * mapRect.height();
        painter.setBrush(QColor(15, 18, 22, 230));
        painter.setPen(QPen(QColor(235, 238, 242), 1.3));
        painter.drawEllipse(QPointF(cx, cy), rx, ry);
        painter.setBrush(Qt::NoBrush);
    }
 
    const std::vector<qpe::QuantumBilliardSample2D> &samples = history_->samples();
    const double tMin = samples.front().time;
    const double tMax = samples.back().time;
    const double span = std::max(1.0e-12, tMax - tMin);
    const auto mapX = [curveRect, tMin, span](double t) {
        return curveRect.left() + (t - tMin) / span * curveRect.width();
    };
    const auto mapY = [curveRect](double v) {
        const double clamped = std::max(0.0, std::min(1.0, v));
        return curveRect.bottom() - clamped * curveRect.height();
    };
 
    painter.setPen(QPen(QColor(72, 80, 90), 1.0));
    for (int i = 1; i < 4; ++i) {
        const double y = curveRect.top() + i * curveRect.height() / 4.0;
        painter.drawLine(QPointF(curveRect.left(), y), QPointF(curveRect.right(), y));
    }
 
    QPainterPath occupiedPath;
    QPainterPath fidelityPath;
    QPainterPath obstaclePath;
    bool started = false;
    for (const qpe::QuantumBilliardSample2D &sample : samples) {
        const double x = mapX(sample.time);
        const QPointF pOccupied(x, mapY(sample.occupiedFraction));
        const QPointF pFidelity(x, mapY(sample.fidelity));
        const QPointF pObstacle(x, mapY(std::min(1.0, 4.0 * sample.obstacleShellProbability)));
        if (!started) {
            occupiedPath.moveTo(pOccupied);
            fidelityPath.moveTo(pFidelity);
            obstaclePath.moveTo(pObstacle);
            started = true;
        } else {
            occupiedPath.lineTo(pOccupied);
            fidelityPath.lineTo(pFidelity);
            obstaclePath.lineTo(pObstacle);
        }
    }
 
    painter.setPen(QPen(QColor(80, 220, 255), 2.2));
    painter.drawPath(occupiedPath);
    painter.setPen(QPen(QColor(255, 205, 92), 1.7));
    painter.drawPath(fidelityPath);
    if (geometry_.hasObstacle) {
        painter.setPen(QPen(QColor(255, 112, 160), 1.5));
        painter.drawPath(obstaclePath);
    }
 
    painter.setPen(QColor(215, 224, 234));
    painter.drawText(QRectF(5.0, curveRect.top() - 9.0, 50.0, 18.0),
                     Qt::AlignRight | Qt::AlignVCenter, QStringLiteral("1.0"));
    painter.drawText(QRectF(5.0, curveRect.bottom() - 10.0, 50.0, 18.0),
                     Qt::AlignRight | Qt::AlignVCenter, QStringLiteral("0.0"));
    painter.drawText(QRectF(curveRect.left(), curveRect.bottom() + 5.0, 90.0, 20.0),
                     Qt::AlignLeft, QString::number(tMin, 'f', 1));
    painter.drawText(QRectF(curveRect.right() - 90.0, curveRect.bottom() + 5.0, 90.0, 20.0),
                     Qt::AlignRight, QString::number(tMax, 'f', 1));
    painter.drawText(QRectF(curveRect.left(), curveRect.bottom() + 4.0,
                            curveRect.width(), 24.0), Qt::AlignCenter,
                     QStringLiteral("simulation time"));
 
    const double legendY = mapRect.bottom() + 7.0;
    painter.setPen(QColor(80, 220, 255));
    painter.drawText(QRectF(mapRect.left(), legendY, 160.0, 20.0), Qt::AlignLeft,
                     QStringLiteral("cyan: occupied fraction"));
    painter.setPen(QColor(255, 205, 92));
    painter.drawText(QRectF(mapRect.left() + 165.0, legendY, 150.0, 20.0), Qt::AlignLeft,
                     QStringLiteral("yellow: fidelity"));
    if (geometry_.hasObstacle) {
        painter.setPen(QColor(255, 112, 160));
        painter.drawText(QRectF(mapRect.left() + 315.0, legendY, 240.0, 20.0), Qt::AlignLeft,
                         QStringLiteral("pink: 4x obstacle-shell probability"));
    }
}