quantummoshinskyplotwidget.cpp

Go to the documentation of this file.

/**
 * @file quantummoshinskyplotwidget.cpp
 * @brief Implements the quantummoshinskyplotwidget visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/quantummoshinskyplotwidget.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 "quantummoshinskyplotwidget.h"
 
#include <QPainter>
#include <QPaintEvent>
#include <QFontMetrics>
#include <QPainterPath>
 
#include <algorithm>
#include <cmath>
 
namespace {
 
/**
 * @brief Performs heat color.
 * @param value Value to assign or evaluate.
 */
QColor heatColor(double value)
{
    const double v = std::max(0.0, std::min(1.0, value));
    // Dark blue -> cyan -> warm white.  The non-linear map keeps weak Fresnel
    // ripples visible without changing any numerical data.
    if (v < 0.55) {
        const double u = v / 0.55;
        return QColor(static_cast<int>(8 + 22 * u),
                      static_cast<int>(18 + 155 * u),
                      static_cast<int>(38 + 190 * u));
    }
    const double u = (v - 0.55) / 0.45;
    return QColor(static_cast<int>(30 + 225 * u),
                  static_cast<int>(173 + 82 * u),
                  static_cast<int>(228 + 27 * u));
}
 
} // namespace
 
QuantumMoshinskyPlotWidget::QuantumMoshinskyPlotWidget(QWidget *parent)
    : QWidget(parent)
{
    setAutoFillBackground(false);
}
 
void QuantumMoshinskyPlotWidget::setData(const qpe::QuantumMoshinskyHistory2D &history)
{
    history_ = &history;
    update();
}
 
void QuantumMoshinskyPlotWidget::clear()
{
    history_ = nullptr;
    update();
}
 
QSize QuantumMoshinskyPlotWidget::minimumSizeHint() const
{
    return QSize(640, 420);
}
 
void QuantumMoshinskyPlotWidget::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);
    QPainter p(this);
    p.setRenderHint(QPainter::Antialiasing, true);
    p.fillRect(rect(), QColor(11, 16, 22));
 
    p.setPen(QColor(220, 232, 241));
    QFont title = font();
    title.setBold(true);
    p.setFont(title);
    p.drawText(QRect(12, 8, width() - 24, 24), Qt::AlignLeft | Qt::AlignVCenter,
               QStringLiteral("Moshinsky shutter — diffraction in time"));
 
    if (!history_ || !history_->configured() || history_->empty()) {
        p.setFont(font());
        p.setPen(QColor(150, 166, 180));
        p.drawText(QRect(20, 52, width() - 40, height() - 72),
                   Qt::AlignCenter | Qt::TextWordWrap,
                   QStringLiteral("Load Moshinsky Shutter / Diffraction in Time and press Play"));
        return;
    }
 
    const std::vector<qpe::QuantumMoshinskySample2D> &samples = history_->samples();
    const qpe::QuantumMoshinsky2DConfig &config = history_->config();
    const qpe::QuantumMoshinskyGeometry2D &geometry = history_->geometry();
    const int left = 62;
    const int right = 18;
    const int top = 40;
    const int gap = 34;
    const int traceH = std::max(120, height() / 3);
    const int heatBottom = height() - traceH - gap;
    QRect heat(left, top, std::max(10, width() - left - right), std::max(80, heatBottom - top));
    QRect trace(left, heat.bottom() + gap, heat.width(), height() - (heat.bottom() + gap) - 28);
 
    p.setPen(QColor(60, 76, 90));
    p.setBrush(QColor(6, 11, 16));
    p.drawRect(heat);
    p.drawRect(trace);
 
    double maxMarginal = 0.0;
    double maxSignal = 0.0;
    for (const qpe::QuantumMoshinskySample2D &s : samples) {
        maxSignal = std::max(maxSignal, s.detectorSignal);
        for (float v : s.marginalX) maxMarginal = std::max(maxMarginal, static_cast<double>(v));
    }
    maxMarginal = std::max(maxMarginal, 1.0e-12);
    maxSignal = std::max(maxSignal, 1.0e-12);
 
    const std::size_t nx = history_->gridWidth();
    if (nx > 0u) {
        for (std::size_t si = 0; si < samples.size(); ++si) {
            const qpe::QuantumMoshinskySample2D &s = samples[si];
            const int y0 = heat.top() + static_cast<int>(
                (static_cast<double>(si) / static_cast<double>(samples.size())) * heat.height());
            const int y1 = heat.top() + static_cast<int>(
                (static_cast<double>(si + 1u) / static_cast<double>(samples.size())) * heat.height());
            const int hh = std::max(1, y1 - y0 + 1);
            for (std::size_t xi = 0; xi < nx && xi < s.marginalX.size(); ++xi) {
                const int x0 = heat.left() + static_cast<int>(
                    (static_cast<double>(xi) / static_cast<double>(nx)) * heat.width());
                const int x1 = heat.left() + static_cast<int>(
                    (static_cast<double>(xi + 1u) / static_cast<double>(nx)) * heat.width());
                const int ww = std::max(1, x1 - x0 + 1);
                const double intensity = std::sqrt(
                    std::max(0.0, static_cast<double>(s.marginalX[xi])) / maxMarginal);
                p.fillRect(QRect(x0, y0, ww, hh), heatColor(intensity));
            }
        }
    }
 
    const double xMin = history_->xCoordinate(0u);
    const double xMax = history_->xCoordinate(nx > 0u ? nx - 1u : 0u);
    const auto mapX = [&](double x) {
        const double u = (x - xMin) / std::max(1.0e-12, xMax - xMin);
        return heat.left() + u * heat.width();
    };
    const double tMax = std::max(config.analysisEndTime, samples.back().time);
    const auto mapTHeat = [&](double t) {
        return heat.top() + (t / std::max(1.0e-12, tMax)) * heat.height();
    };
 
    p.setPen(QPen(QColor(255, 198, 73), 1.3, Qt::DashLine));
    p.drawLine(QPointF(mapX(geometry.shutterX), heat.top()),
               QPointF(mapX(geometry.shutterX), heat.bottom()));
    p.setPen(QPen(QColor(255, 110, 110), 1.3, Qt::DashLine));
    p.drawLine(QPointF(mapX(config.detectorX), heat.top()),
               QPointF(mapX(config.detectorX), heat.bottom()));
    p.setPen(QPen(QColor(240, 240, 240, 140), 1.0, Qt::DashLine));
    p.drawLine(QPointF(heat.left(), mapTHeat(config.openTime)),
               QPointF(heat.right(), mapTHeat(config.openTime)));
 
    p.setFont(font());
    p.setPen(QColor(180, 197, 210));
    p.drawText(QRect(4, heat.top(), left - 10, 20), Qt::AlignRight | Qt::AlignVCenter,
               QStringLiteral("t=0"));
    p.drawText(QRect(4, heat.bottom() - 20, left - 10, 20), Qt::AlignRight | Qt::AlignVCenter,
               QStringLiteral("%1").arg(tMax, 0, 'f', 2));
    p.drawText(QRect(heat.left(), heat.bottom() + 4, heat.width(), 20), Qt::AlignCenter,
               QStringLiteral("x   |   gold=shutter   red=detector"));
 
    const auto mapTraceX = [&](double t) {
        return trace.left() + (t / std::max(1.0e-12, tMax)) * trace.width();
    };
    const auto mapTraceY = [&](double v) {
        return trace.bottom() - (v / maxSignal) * trace.height();
    };
 
    QPainterPath path;
    for (std::size_t i = 0; i < samples.size(); ++i) {
        const QPointF pt(mapTraceX(samples[i].time), mapTraceY(samples[i].detectorSignal));
        if (i == 0u) path.moveTo(pt); else path.lineTo(pt);
    }
    p.setPen(QPen(QColor(98, 220, 255), 2.0));
    p.drawPath(path);
 
    p.setPen(QPen(QColor(240, 240, 240, 110), 1.0, Qt::DashLine));
    p.drawLine(QPointF(mapTraceX(config.openTime), trace.top()),
               QPointF(mapTraceX(config.openTime), trace.bottom()));
 
    p.setPen(QColor(180, 197, 210));
    p.drawText(QRect(4, trace.top(), left - 10, 20), Qt::AlignRight | Qt::AlignVCenter,
               QStringLiteral("Imax"));
    p.drawText(QRect(trace.left(), trace.bottom() + 4, trace.width(), 20), Qt::AlignCenter,
               QStringLiteral("time  —  detector line density I(xd,t)"));
 
    const qpe::QuantumMoshinskySample2D &last = samples.back();
    p.setPen(QColor(225, 235, 242));
    p.drawText(QRect(trace.left() + 8, trace.top() + 6, trace.width() - 16, 20),
               Qt::AlignLeft | Qt::AlignVCenter,
               QStringLiteral("samples=%1  t=%2  I_det=%3  P(x>shutter)=%4")
                   .arg(static_cast<qulonglong>(samples.size()))
                   .arg(last.time, 0, 'f', 3)
                   .arg(last.detectorSignal, 0, 'g', 5)
                   .arg(last.frontProbability, 0, 'f', 4));
}