quantumviewcamera2d.h

Go to the documentation of this file.

/**
 * @file quantumviewcamera2d.h
 * @brief Declares the quantumviewcamera2d visualization component used by QPE.
 * @ingroup qpe_graphics
 *
 * Source: @c graphics/renderer/quantumviewcamera2d.h. 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.
 */
 
#pragma once
 
#include <algorithm>
#include <cmath>
 
namespace qpe {
 
// Pure display-space camera used by QuantumGLView.
// It never modifies psi, V, the simulation grid, dt, or any observable.
/**
 * @brief Implements the Quantum View Camera2D component.
 *
 * The class provides one focused service within the QPE architecture and is documented here independently of the experiment-level Help.
 */
class QuantumViewCamera2D
{
public:
    /**
     * @brief Sets domain.
     * @param width The width value used by the operation.
     * @param width The width value used by the operation.
     */
    void setDomain(float width, float height)
    {
        const float safeWidth = std::max(0.0f, width);
        /**
         * @brief Carries out max.
         * @param f The f value used by the operation.
         * @param height The height value used by the operation.
         */
        const float safeHeight = std::max(0.0f, height);
        /**
         * @brief Carries out abs.
         * @param domainHeight_ The domain height value used by the operation.
         */
        const bool changed = std::abs(safeWidth - domainWidth_) > 1.0e-6f ||
                             std::abs(safeHeight - domainHeight_) > 1.0e-6f;
        domainWidth_ = safeWidth;
        domainHeight_ = safeHeight;
        if (changed) {
            /**
             * @brief Resets the component to its initial state.
             */
            reset();
        } else {
            /**
             * @brief Carries out clamp center.
             */
            clampCenter();
        }
    }
 
    /**
     * @brief Resets the component to its initial state.
     */
    void reset()
    {
        zoom_ = 1.0f;
        centerX_ = 0.0f;
        centerY_ = 0.0f;
    }
 
    /**
     * @brief Carries out zoom.
     */
    float zoom() const { return zoom_; }
    /**
     * @brief Carries out center x.
     */
    float centerX() const { return centerX_; }
    /**
     * @brief Carries out center y.
     */
    float centerY() const { return centerY_; }
    /**
     * @brief Carries out domain width.
     */
    float domainWidth() const { return domainWidth_; }
    /**
     * @brief Carries out domain height.
     */
    float domainHeight() const { return domainHeight_; }
    /**
     * @brief Carries out view width.
     */
    float viewWidth() const { return zoom_ > 0.0f ? domainWidth_ / zoom_ : domainWidth_; }
    /**
     * @brief Carries out view height.
     */
    float viewHeight() const { return zoom_ > 0.0f ? domainHeight_ / zoom_ : domainHeight_; }
    /**
     * @brief Carries out max zoom.
     */
    float maxZoom() const { return 32.0f; }
 
    /**
     * @brief Carries out max.
     * @param factor The factor value used by the operation.
     * @param u The u value used by the operation.
     * @param f The f value used by the operation.
     */
    bool zoomAtNormalized(float factor, double u, double v)
    {
        if (!(domainWidth_ > 0.0f) || !(domainHeight_ > 0.0f) || !(factor > 0.0f)) {
            return false;
        }
 
        /**
         * @brief Performs max.
         * @param u The u value used by the operation.
         */
        u = std::max(0.0, std::min(1.0, u));
        /**
         * @brief Carries out max.
         * @param v The v value used by the operation.
         */
        v = std::max(0.0, std::min(1.0, v));
 
        float anchorX = 0.0f;
        float anchorY = 0.0f;
        /**
         * @brief Carries out physical from normalized.
         * @param u The u value used by the operation.
         * @param v The v value used by the operation.
         * @param anchorX The anchor x value used by the operation.
         * @param anchorY The anchor y value used by the operation.
         */
        physicalFromNormalized(u, v, anchorX, anchorY);
 
        /**
         * @brief Carries out max.
         * @param f The f value used by the operation.
         * @param factor The factor value used by the operation.
         */
        const float newZoom = std::max(1.0f, std::min(maxZoom(), zoom_ * factor));
        if (std::abs(newZoom - zoom_) <= 1.0e-6f) {
            return false;
        }
 
        zoom_ = newZoom;
        /**
         * @brief Carries out view width.
         */
        centerX_ = anchorX - static_cast<float>(u - 0.5) * viewWidth();
        /**
         * @brief Carries out view height.
         */
        centerY_ = anchorY - static_cast<float>(v - 0.5) * viewHeight();
        /**
         * @brief Carries out clamp center.
         */
        clampCenter();
        return true;
    }
 
    /**
     * @brief Carries out clamp center.
     * @param dx The dx value used by the operation.
     * @param f The f value used by the operation.
     */
    void panPhysical(float dx, float dy)
    {
        if (!(domainWidth_ > 0.0f) || !(domainHeight_ > 0.0f)) {
            return;
        }
        centerX_ += dx;
        centerY_ += dy;
        /**
         * @brief Performs clamp center.
         */
        clampCenter();
    }
 
    /**
     * @brief Carries out physical from normalized.
     * @param u The u value used by the operation.
     * @param v The v value used by the operation.
     * @param x X coordinate/value.
     * @param viewWidth The view width value used by the operation.
     */
    void physicalFromNormalized(double u, double v, float &x, float &y) const
    {
        x = centerX_ + static_cast<float>(u - 0.5) * viewWidth();
        /**
         * @brief Performs view height.
         */
        y = centerY_ + static_cast<float>(v - 0.5) * viewHeight();
    }
 
    /**
     * @brief Returns normalized from physical.
     * @param x X coordinate/value.
     * @param y Y coordinate/value.
     * @param u The u value used by the operation.
     * @param viewWidth The view width value used by the operation.
     */
    void normalizedFromPhysical(float x, float y, double &u, double &v) const
    {
        const float vw = viewWidth();
        /**
         * @brief Performs view height.
         */
        const float vh = viewHeight();
        u = vw > 0.0f ? static_cast<double>((x - centerX_) / vw) + 0.5 : 0.5;
        v = vh > 0.0f ? static_cast<double>((y - centerY_) / vh) + 0.5 : 0.5;
    }
 
    /**
     * @brief Carries out texture scale x.
     */
    float textureScaleX() const
    {
        return zoom_ > 0.0f ? 1.0f / zoom_ : 1.0f;
    }
 
    /**
     * @brief Carries out texture scale y.
     */
    float textureScaleY() const
    {
        return zoom_ > 0.0f ? 1.0f / zoom_ : 1.0f;
    }
 
    /**
     * @brief Carries out max.
     * @param f The f value used by the operation.
     */
    float textureOffsetX() const
    {
        if (!(domainWidth_ > 0.0f)) {
            return 0.0f;
        }
        return 0.5f + centerX_ / domainWidth_ - 0.5f * textureScaleX();
    }
 
    /**
     * @brief Performs texture offset y.
     * @param f The f value used by the operation.
     */
    float textureOffsetY() const
    {
        if (!(domainHeight_ > 0.0f)) {
            return 0.0f;
        }
        return 0.5f + centerY_ / domainHeight_ - 0.5f * textureScaleY();
    }
 
private:
    /**
     * @brief Performs clamp center.
     * @param f The f value used by the operation.
     */
    void clampCenter()
    {
        if (!(domainWidth_ > 0.0f) || !(domainHeight_ > 0.0f)) {
            centerX_ = 0.0f;
            centerY_ = 0.0f;
            zoom_ = 1.0f;
            return;
        }
 
        /**
         * @brief Performs max.
         * @param f The f value used by the operation.
         * @param viewWidth The view width value used by the operation.
         */
        const float maxCenterX = std::max(0.0f, 0.5f * (domainWidth_ - viewWidth()));
        /**
         * @brief Carries out max.
         * @param f The f value used by the operation.
         * @param viewHeight The view height value used by the operation.
         */
        const float maxCenterY = std::max(0.0f, 0.5f * (domainHeight_ - viewHeight()));
        /**
         * @brief Carries out max.
         * @param maxCenterX The max center x value used by the operation.
         * @param centerX_ The center x value used by the operation.
         */
        centerX_ = std::max(-maxCenterX, std::min(maxCenterX, centerX_));
        /**
         * @brief Carries out max.
         * @param maxCenterY The max center y value used by the operation.
         * @param centerY_ The center y value used by the operation.
         */
        centerY_ = std::max(-maxCenterY, std::min(maxCenterY, centerY_));
    }
 
    float domainWidth_ = 0.0f;
    float domainHeight_ = 0.0f;
    float zoom_ = 1.0f;
    float centerX_ = 0.0f;
    float centerY_ = 0.0f;
};
 
} // namespace qpe