transformation.hpp

Go to the documentation of this file.

#pragma once
 
#include "core/rational.hpp"

 
#include <array>
#include <cmath>
#include <concepts>
#include <type_traits>
 
namespace pgl {

template <class Number>
struct Transformation {
    using NumberType = Number;

    constexpr Transformation() = default;

    constexpr Transformation(Number a, Number b, Number c, Number d,
                              Number tx = Number{}, Number ty = Number{})
        : m_{{{a, b, tx}, {c, d, ty}}} {}

    template <class OtherNumber>
    constexpr Transformation(const Transformation<OtherNumber>& other)
        : m_{{
              {static_cast<Number>(other.a()), static_cast<Number>(other.b()), static_cast<Number>(other.tx())},
              {static_cast<Number>(other.c()), static_cast<Number>(other.d()), static_cast<Number>(other.ty())},
          }} {}

    static constexpr Transformation identity() {
        return Transformation();
    }

    static constexpr Transformation translation(Number dx, Number dy) {
        return Transformation(Number{1}, Number{}, Number{}, Number{1}, dx, dy);
    }

    static constexpr Transformation scaling(Number sx, Number sy) {
        return Transformation(sx, Number{}, Number{}, sy);
    }

    static constexpr Transformation scaling(Number s) {
        return scaling(s, s);
    }

    static constexpr Transformation rotation90(int k = 1) {
        switch (((k % 4) + 4) % 4) {
            case 1:  return Transformation(Number{}, -Number{1}, Number{1}, Number{});
            case 2:  return Transformation(-Number{1}, Number{}, Number{}, -Number{1});
            case 3:  return Transformation(Number{}, Number{1}, -Number{1}, Number{});
            default: return identity();
        }
    }

    static constexpr Transformation shearX(Number k) {
        return Transformation(Number{1}, k, Number{}, Number{1});
    }

    static constexpr Transformation shearY(Number k) {
        return Transformation(Number{1}, Number{}, k, Number{1});
    }

    static constexpr Transformation reflectionX() {
        return Transformation(Number{1}, Number{}, Number{}, -Number{1});
    }

    static constexpr Transformation reflectionY() {
        return Transformation(-Number{1}, Number{}, Number{}, Number{1});
    }

    template <std::floating_point ResultNumber = double>
    static Transformation<ResultNumber> rotation(ResultNumber radians) {
        const ResultNumber cosine = std::cos(radians);
        const ResultNumber sine = std::sin(radians);
        return Transformation<ResultNumber>(cosine, -sine, sine, cosine);
    }

    constexpr Number a() const { return m_[0][0]; }
    constexpr Number b() const { return m_[0][1]; }
    constexpr Number c() const { return m_[1][0]; }
    constexpr Number d() const { return m_[1][1]; }
    constexpr Number tx() const { return m_[0][2]; }
    constexpr Number ty() const { return m_[1][2]; }

    constexpr auto determinant() const {
        return a() * d() - b() * c();
    }

    constexpr bool isInvertible() const {
        return determinant() != decltype(determinant()){};
    }

    template <class ResultNumber = division_result_t<NumberType>>
    constexpr Transformation<ResultNumber> inverse() const {
        const ResultNumber det = static_cast<ResultNumber>(determinant());
        const ResultNumber ra = static_cast<ResultNumber>(a());
        const ResultNumber rb = static_cast<ResultNumber>(b());
        const ResultNumber rc = static_cast<ResultNumber>(c());
        const ResultNumber rd = static_cast<ResultNumber>(d());
        const ResultNumber rtx = static_cast<ResultNumber>(tx());
        const ResultNumber rty = static_cast<ResultNumber>(ty());
        return Transformation<ResultNumber>(
            rd / det, -rb / det,
            -rc / det, ra / det,
            (rb * rty - rd * rtx) / det,
            (rc * rtx - ra * rty) / det);
    }

    template <class OtherNumber>
    constexpr auto operator*(const Transformation<OtherNumber>& other) const {
        using ResultNumber = std::common_type_t<Number, OtherNumber>;
        return Transformation<ResultNumber>(
            a() * other.a() + b() * other.c(),
            a() * other.b() + b() * other.d(),
            c() * other.a() + d() * other.c(),
            c() * other.b() + d() * other.d(),
            a() * other.tx() + b() * other.ty() + tx(),
            c() * other.tx() + d() * other.ty() + ty());
    }

    constexpr bool operator==(const Transformation&) const = default;
 
  private:
    std::array<std::array<Number, 3>, 2> m_{{{Number{1}, Number{}, Number{}}, {Number{}, Number{1}, Number{}}}};
};

template <class Number, class ShapeT>
    requires (detail::shapeRank<ShapeT> >= 0 && !RectangleConcept<ShapeT> && !DiskConcept<ShapeT>)
[[nodiscard]] constexpr auto operator*(const Transformation<Number>& transformation, const ShapeT& shape);

template <class Number, ShapeConcept ShapeT>
[[nodiscard]] constexpr auto operator*(const Transformation<Number>& transformation, const ShapeT& shape);
 
}  // namespace pgl