Coordinates.h

Go to the documentation of this file.

#pragma once

 
#include <limits>
#include <numbers>
 
#include <EmrysFilter/Core/Macros.h>
#include <EmrysFilter/Spaces/Space.h>
 
namespace Emrys
{
 
namespace internal
{

template <int Dimension, int MaxDimension>
class LeafExtent
{
public:

    [[nodiscard]] static constexpr Eigen::Index
    valueDimension()
    {
        return Dimension;
    }

    friend bool
    operator==(LeafExtent const &, LeafExtent const &) = default;
};

template <int MaxDimension>
class LeafExtent<Eigen::Dynamic, MaxDimension>
{
public:

    [[nodiscard]] Eigen::Index
    valueDimension() const
    {
        return m_size;
    }

    void
    resize(Eigen::Index n)
    {
        EMRYS_FILTER_ASSERT(
            n >= 0 && (MaxDimension == Eigen::Dynamic || n <= MaxDimension) && "the dimension does not fit the space"
        );
        m_size = n;
    }

    friend bool
    operator==(LeafExtent const &, LeafExtent const &) = default;
 
private:
 
    Eigen::Index m_size = 0;  
};
 
}  // namespace internal

template <int Dimension_ = 1, int MaxDimension_ = Dimension_>
struct Linear : internal::LeafExtent<Dimension_, MaxDimension_>
{
    static_assert(Dimension_ == Eigen::Dynamic || Dimension_ >= 0);
    static_assert(Dimension_ == Eigen::Dynamic || MaxDimension_ == Dimension_, "a fixed size is its own maximum");
    static constexpr int FixedValueDimension =
        Dimension_ == Eigen::Dynamic ? 0 : Dimension_;  
    static constexpr int ValueDimensionStep =
        Dimension_ == Eigen::Dynamic ? 1 : 0;                
    static constexpr int MaxValueDimension = MaxDimension_;  
 
    Linear() = default;

    explicit Linear(Eigen::Index n)
        requires(Dimension_ == Eigen::Dynamic)
    {
        this->resize(n);
    }

    [[nodiscard]] Linear
    difference() const
    {
        return *this;
    }

    friend bool
    operator==(Linear const &, Linear const &) = default;
};

struct PeriodicInterval
{
    double lower = std::numeric_limits<double>::quiet_NaN();  
    double upper = std::numeric_limits<double>::quiet_NaN();  
};

template <PeriodicInterval Interval, int Dimension_ = 1, int MaxDimension_ = Dimension_>
class Periodic : public internal::LeafExtent<Dimension_, MaxDimension_>
{
public:
 
    static_assert(Dimension_ == Eigen::Dynamic || Dimension_ >= 1);
    static_assert(Dimension_ == Eigen::Dynamic || MaxDimension_ == Dimension_, "a fixed size is its own maximum");
    static_assert(Interval.lower == Interval.lower, "the lower end must be given");
    static_assert(Interval.upper == Interval.upper, "the upper end must be given");
    static_assert(Interval.lower < Interval.upper, "the upper end must be above the lower");
 
    static_assert(
        Interval.upper - Interval.lower < std::numeric_limits<double>::infinity(),
        "the period must be finite"
    );
 
    static constexpr int FixedValueDimension =
        Dimension_ == Eigen::Dynamic ? 0 : Dimension_;  
    static constexpr int ValueDimensionStep =
        Dimension_ == Eigen::Dynamic ? 1 : 0;                
    static constexpr int MaxValueDimension = MaxDimension_;  
 
    Periodic() = default;

    explicit Periodic(Eigen::Index n)
        requires(Dimension_ == Eigen::Dynamic)
    {
        this->resize(n);
    }

    [[nodiscard]] static consteval double
    lower()
    {
        return Interval.lower;
    }

    [[nodiscard]] static consteval double
    upper()
    {
        return Interval.upper;
    }

    [[nodiscard]] static consteval double
    period()
    {
        return Interval.upper - Interval.lower;
    }

    template <typename Derived>
    void
    normalize(Eigen::MatrixBase<Derived> const & block) const
    {
        writable(block) = block.unaryExpr([](auto x) {
            return internal::wrapValue<lower(), period()>(x);
        });
    }

    [[nodiscard]] auto
    difference() const
    {
        using Difference =
            Periodic<PeriodicInterval{.lower = -period() / 2, .upper = period() / 2}, Dimension_, MaxDimension_>;
        if constexpr (Dimension_ == Eigen::Dynamic)
        {
            return Difference{this->valueDimension()};
        }
        else
        {
            return Difference{};
        }
    }

    friend bool
    operator==(Periodic const &, Periodic const &) = default;
};

template <int Dimension = 1, int MaxDimension = Dimension>
using RadiansPi =
    Periodic<PeriodicInterval{.lower = -std::numbers::pi, .upper = std::numbers::pi}, Dimension, MaxDimension>;

template <int Dimension = 1, int MaxDimension = Dimension>
using Radians2Pi = Periodic<PeriodicInterval{.lower = 0.0, .upper = 2 * std::numbers::pi}, Dimension, MaxDimension>;

template <int Dimension = 1, int MaxDimension = Dimension>
using Degrees180 = Periodic<PeriodicInterval{.lower = -180.0, .upper = 180.0}, Dimension, MaxDimension>;

template <int Dimension = 1, int MaxDimension = Dimension>
using Degrees360 = Periodic<PeriodicInterval{.lower = 0.0, .upper = 360.0}, Dimension, MaxDimension>;
 
}  // namespace Emrys