wavefunctionimagerenderer_tests.cpp

Go to the documentation of this file.

/**
 * @file wavefunctionimagerenderer_tests.cpp
 * @brief Implements regression and invariant tests for wavefunctionimagerenderer tests.
 * @ingroup qpe_tests
 *
 * Source: @c tests/wavefunctionimagerenderer_tests.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_tests.h"
 
#include "core/math/complexfield2d.h"
#include "graphics/renderer/wavefunctionimagerenderer.h"
 
#include <QColor>
 
#include <stdexcept>
 
namespace qpe {
namespace tests {
namespace {
 
/**
 * @brief Returns whether black.
 * @param c The c value used by the operation.
 */
bool isBlack(const QColor &c)
{
    return c.red() == 0 && c.green() == 0 && c.blue() == 0;
}
 
} // namespace
 
/**
 * @brief Runs wave function image renderer tests.
 * @param errorMessage The error message value used by the operation.
 */
bool runWaveFunctionImageRendererTests(std::string &errorMessage)
{
    try {
        ComplexField2D field(3, 1, 1.0f, 1.0f);
 
        // Real view: +1 -> red, 0 -> black, -1 -> blue.
        field(0, 0) = ComplexField2D::Value(1.0f, 0.0f);
        field(1, 0) = ComplexField2D::Value(0.0f, 0.0f);
        field(2, 0) = ComplexField2D::Value(-1.0f, 0.0f);
 
        QImage image = WaveFunctionImageRenderer::render(field, WaveFunctionView::Real);
        QColor c0(image.pixel(0, 0));
        QColor c1(image.pixel(1, 0));
        QColor c2(image.pixel(2, 0));
        if (!(c0.red() == 255 && c0.green() == 0 && c0.blue() == 0)) {
            errorMessage = "positive real value is not mapped to red";
            return false;
        }
        if (!isBlack(c1)) {
            errorMessage = "zero real value is not mapped to black";
            return false;
        }
        if (!(c2.red() == 0 && c2.green() == 0 && c2.blue() == 255)) {
            errorMessage = "negative real value is not mapped to blue";
            return false;
        }
 
        // Imaginary view follows the same signed convention.
        field(0, 0) = ComplexField2D::Value(0.0f, 1.0f);
        field(1, 0) = ComplexField2D::Value(0.0f, 0.0f);
        field(2, 0) = ComplexField2D::Value(0.0f, -1.0f);
        image = WaveFunctionImageRenderer::render(field, WaveFunctionView::Imaginary);
        c0 = QColor(image.pixel(0, 0));
        c2 = QColor(image.pixel(2, 0));
        if (!(c0.red() == 255 && c0.blue() == 0 && c2.red() == 0 && c2.blue() == 255)) {
            errorMessage = "imaginary signed color mapping is incorrect";
            return false;
        }
 
        // Phase must visibly distinguish 0 from +pi/2 and suppress zero amplitude.
        field(0, 0) = ComplexField2D::Value(1.0f, 0.0f);
        field(1, 0) = ComplexField2D::Value(0.0f, 1.0f);
        field(2, 0) = ComplexField2D::Value(0.0f, 0.0f);
        image = WaveFunctionImageRenderer::render(field, WaveFunctionView::Phase);
        c0 = QColor(image.pixel(0, 0));
        c1 = QColor(image.pixel(1, 0));
        c2 = QColor(image.pixel(2, 0));
        if (c0.rgb() == c1.rgb()) {
            errorMessage = "different phases produced the same display color";
            return false;
        }
        if (!isBlack(c2)) {
            errorMessage = "zero-amplitude phase pixel is not black";
            return false;
        }
 
        WaveFunctionRenderOptions invalid;
        invalid.gamma = 0.0f;
        bool threw = false;
        try {
            (void)WaveFunctionImageRenderer::render(field, WaveFunctionView::Phase, invalid);
        } catch (const std::invalid_argument &) {
            threw = true;
        }
        if (!threw) {
            errorMessage = "invalid gamma was not rejected";
            return false;
        }
 
        errorMessage.clear();
        return true;
    } catch (const std::exception &e) {
        errorMessage = e.what();
        return false;
    } catch (...) {
        errorMessage = "unknown exception";
        return false;
    }
}
 
} // namespace tests
} // namespace qpe