wavefunctionimagerenderer.cpp

Go to the documentation of this file.

/**
 * @file wavefunctionimagerenderer.cpp
 * @brief Implements the wavefunctionimagerenderer visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/wavefunctionimagerenderer.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 "wavefunctionimagerenderer.h"
 
#include "core/math/complexfield2d.h"
#include "graphics/renderer/probabilityimagerenderer.h"
 
#include <QColor>
 
#include <algorithm>
#include <cmath>
#include <stdexcept>
 
namespace qpe {
namespace {
 
constexpr double kPi = 3.1415926535897932384626433832795;
 
/**
 * @brief Performs to byte.
 * @param v The v value used by the operation.
 */
int toByte(double v) noexcept
{
    v = std::max(0.0, std::min(1.0, v));
    return static_cast<int>(std::lround(v * 255.0));
}
 
/**
 * @brief Applies gamma.
 * @param normalizedValue The normalized value value used by the operation.
 * @param gamma The gamma value used by the operation.
 */
double applyGamma(double normalizedValue, double gamma) noexcept
{
    return std::pow(std::max(0.0, std::min(1.0, normalizedValue)), gamma);
}
 
/**
 * @brief Performs signed color.
 * @param value Value to assign or evaluate.
 * @param peakAbs The peak abs value used by the operation.
 * @param gamma The gamma value used by the operation.
 */
QRgb signedColor(double value, double peakAbs, double gamma) noexcept
{
    if (!(peakAbs > 0.0)) {
        return qRgb(0, 0, 0);
    }
 
    const double magnitude = applyGamma(std::abs(value) / peakAbs, gamma);
    const int c = toByte(magnitude);
 
    if (value > 0.0) {
        return qRgb(c, 0, 0);       // positive -> red
    }
    if (value < 0.0) {
        return qRgb(0, 0, c);       // negative -> blue
    }
    return qRgb(0, 0, 0);
}
 
/**
 * @brief Performs phase color.
 * @param v The v value used by the operation.
 * @param peakAmplitude The peak amplitude value used by the operation.
 * @param gamma The gamma value used by the operation.
 */
QRgb phaseColor(const ComplexField2D::Value &v,
                double peakAmplitude,
                double gamma) noexcept
{
    const double re = static_cast<double>(v.real());
    const double im = static_cast<double>(v.imag());
    const double amplitude = std::hypot(re, im);
 
    if (!(peakAmplitude > 0.0) || !(amplitude > 0.0)) {
        return qRgb(0, 0, 0);
    }
 
    // Hue carries phase; brightness is only an amplitude mask so that phase is
    // not shown in regions where the wavefunction is effectively absent.
    double hue = (std::atan2(im, re) + kPi) / (2.0 * kPi);
    hue += 0.5; // phase 0 -> red, positive phase rotates through the hue wheel
    hue -= std::floor(hue);
 
    const double value = applyGamma(amplitude / peakAmplitude, gamma);
    return QColor::fromHsvF(hue, 1.0, value).rgb();
}
 
/**
 * @brief Validates options.
 * @param options The options value used by the operation.
 */
void validateOptions(const WaveFunctionRenderOptions &options)
{
    if (!(options.gamma > 0.0f) || !std::isfinite(static_cast<double>(options.gamma))) {
        throw std::invalid_argument("WaveFunctionImageRenderer: gamma must be finite and positive");
    }
}
 
} // namespace
 
double WaveFunctionImageRenderer::peakAmplitude(const ComplexField2D &field) noexcept
{
    double peak = 0.0;
    for (std::size_t i = 0; i < field.size(); ++i) {
        const auto &v = field.data()[i];
        peak = std::max(peak,
                        std::hypot(static_cast<double>(v.real()),
                                   static_cast<double>(v.imag())));
    }
    return peak;
}
 
double WaveFunctionImageRenderer::peakAbsReal(const ComplexField2D &field) noexcept
{
    double peak = 0.0;
    for (std::size_t i = 0; i < field.size(); ++i) {
        peak = std::max(peak, std::abs(static_cast<double>(field.data()[i].real())));
    }
    return peak;
}
 
double WaveFunctionImageRenderer::peakAbsImaginary(const ComplexField2D &field) noexcept
{
    double peak = 0.0;
    for (std::size_t i = 0; i < field.size(); ++i) {
        peak = std::max(peak, std::abs(static_cast<double>(field.data()[i].imag())));
    }
    return peak;
}
 
QImage WaveFunctionImageRenderer::render(const ComplexField2D &field,
                                         WaveFunctionView view,
                                         const WaveFunctionRenderOptions &options)
{
    if (field.empty()) {
        return QImage();
    }
 
    validateOptions(options);
 
    if (view == WaveFunctionView::Probability) {
        ProbabilityRenderOptions probabilityOptions;
        probabilityOptions.normalizeToPeak = true;
        probabilityOptions.gamma = options.gamma;
        return ProbabilityImageRenderer::render(field, probabilityOptions);
    }
 
    const double peakAmp = peakAmplitude(field);
    const double peakReal = peakAbsReal(field);
    const double peakImag = peakAbsImaginary(field);
    const double gamma = static_cast<double>(options.gamma);
 
    QImage image(static_cast<int>(field.width()),
                 static_cast<int>(field.height()),
                 QImage::Format_RGB32);
 
    for (std::size_t y = 0; y < field.height(); ++y) {
        const int imageY = static_cast<int>(field.height() - 1u - y);
        QRgb *scanLine = reinterpret_cast<QRgb *>(image.scanLine(imageY));
 
        for (std::size_t x = 0; x < field.width(); ++x) {
            const auto &v = field(x, y);
 
            switch (view) {
            case WaveFunctionView::Phase:
                scanLine[x] = phaseColor(v, peakAmp, gamma);
                break;
            case WaveFunctionView::Real:
                scanLine[x] = signedColor(static_cast<double>(v.real()), peakReal, gamma);
                break;
            case WaveFunctionView::Imaginary:
                scanLine[x] = signedColor(static_cast<double>(v.imag()), peakImag, gamma);
                break;
            case WaveFunctionView::Probability:
                // Handled above.
                scanLine[x] = qRgb(0, 0, 0);
                break;
            }
        }
    }
 
    return image;
}
 
} // namespace qpe