transform.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstdint>
#include <stdexcept>
 
#include "fractions.hpp"
#include "pg_object.hpp"
 
namespace fun {
 
    class Transform {
      public:
        using Mat3x3 = std::array<std::array<Fraction, 3>, 3>;
 
        constexpr explicit Transform(Mat3x3 matrix) : matrix_{std::move(matrix)} {}
 
        // ---- factory methods ------------------------------------------------
 
        static constexpr auto identity() -> Transform {
            const Fraction Z{0, 1}, O{1, 1};
            return Transform{Mat3x3{{{{O, Z, Z}}, {{Z, O, Z}}, {{Z, Z, O}}}}};
        }
 
        static constexpr auto translation(std::int64_t tx, std::int64_t ty) -> Transform {
            const Fraction Z{0, 1}, O{1, 1};
            return Transform{
                Mat3x3{{{{O, Z, Fraction{tx, 1}}}, {{Z, O, Fraction{ty, 1}}}, {{Z, Z, O}}}}};
        }
 
        static constexpr auto rotation(const Fraction& angle_cos, const Fraction& angle_sin)
            -> Transform {
            const Fraction Z{0, 1};
            return Transform{Mat3x3{{{{angle_cos, -angle_sin, Z}},
                                     {{angle_sin, angle_cos, Z}},
                                     {{Z, Z, Fraction{1, 1}}}}}};
        }
 
        static constexpr auto scaling(const Fraction& sx, const Fraction& sy) -> Transform {
            const Fraction Z{0, 1};
            return Transform{Mat3x3{{{{sx, Z, Z}}, {{Z, sy, Z}}, {{Z, Z, Fraction{1, 1}}}}}};
        }
 
        static constexpr auto shear(const Fraction& shx, const Fraction& shy) -> Transform {
            const Fraction Z{0, 1}, O{1, 1};
            return Transform{Mat3x3{{{{O, shx, Z}}, {{shy, O, Z}}, {{Z, Z, O}}}}};
        }
 
        // ---- operations -----------------------------------------------------
 
        constexpr auto compose(const Transform& other) const -> Transform {
            Mat3x3 result{};
            for (int i = 0; i < 3; ++i) {
                for (int j = 0; j < 3; ++j) {
                    Fraction sum{0, 1};
                    for (int k = 0; k < 3; ++k) {
                        sum = sum + matrix_[i][k] * other.matrix_[k][j];
                    }
                    result[i][j] = sum;
                }
            }
            return Transform{result};
        }
 
        constexpr auto apply_point(const PgPoint& point) const -> PgPoint {
            const Fraction x{point.coord[0], 1};
            const Fraction y{point.coord[1], 1};
            const Fraction z{point.coord[2], 1};
 
            const auto& m = matrix_;
            const auto xn = m[0][0] * x + m[0][1] * y + m[0][2] * z;
            const auto yn = m[1][0] * x + m[1][1] * y + m[1][2] * z;
            const auto zn = m[2][0] * x + m[2][1] * y + m[2][2] * z;
 
            return PgPoint{
                {xn.numer() / xn.denom(), yn.numer() / yn.denom(), zn.numer() / zn.denom()}};
        }
 
        constexpr auto apply_line(const PgLine& line) const -> PgLine {
            const auto inv = inverse();
            const Fraction x{line.coord[0], 1};
            const Fraction y{line.coord[1], 1};
            const Fraction z{line.coord[2], 1};
 
            const auto& m = inv.matrix_;
            const auto xn = m[0][0] * x + m[1][0] * y + m[2][0] * z;
            const auto yn = m[0][1] * x + m[1][1] * y + m[2][1] * z;
            const auto zn = m[0][2] * x + m[1][2] * y + m[2][2] * z;
 
            return PgLine{
                {xn.numer() / xn.denom(), yn.numer() / yn.denom(), zn.numer() / zn.denom()}};
        }
 
        constexpr auto inverse() const -> Transform {
            const auto& m = matrix_;
            const auto& a = m[0][0];
            const auto& b = m[0][1];
            const auto& c = m[0][2];
            const auto& d = m[1][0];
            const auto& e = m[1][1];
            const auto& f = m[1][2];
            const auto& g = m[2][0];
            const auto& h = m[2][1];
            const auto& i_ = m[2][2];
 
            const auto det = a * (e * i_ - f * h) - b * (d * i_ - f * g) + c * (d * h - e * g);
            if (det == Fraction{0, 1}) {
                throw std::domain_error{"Cannot invert singular transformation matrix"};
            }
            const auto inv_det = Fraction{1, 1} / det;
 
            return Transform {
                Mat3x3{{{
                    {inv_det * (e * i_ - f * h), inv_det * (c * h - b * i_),
                     inv_det * (b * f - c * e)},
                    {inv_det * (f * g - d * i_), inv_det * (a * i_ - c * g),
                     inv_det * (c * d - a * f)},
                    {inv_det * (d * h - e * g), inv_det * (b * g - a * h),
                     inv_det * (a * e - b * d)},
                }}};
            }
 
            constexpr auto matrix() const -> const Mat3x3& { return matrix_; }
 
            constexpr auto operator==(const Transform& other) const->bool {
                return matrix_ == other.matrix_;
            }
 
            constexpr auto operator!=(const Transform& other) const->bool {
                return !(*this == other);
            }
 
          private:
            Mat3x3 matrix_;
        };
 
        // ---- convenience free functions -----------------------------------------
 
        inline constexpr auto rotate_point(const PgPoint& point, const Fraction& angle_cos,
                                           const Fraction& angle_sin) -> PgPoint {
            return Transform::rotation(angle_cos, angle_sin).apply_point(point);
        }
 
        inline constexpr auto translate_point(const PgPoint& point, std::int64_t tx,
                                              std::int64_t ty) -> PgPoint {
            return Transform::translation(tx, ty).apply_point(point);
        }
 
        inline constexpr auto scale_point(const PgPoint& point, const Fraction& sx,
                                          const Fraction& sy) -> PgPoint {
            return Transform::scaling(sx, sy).apply_point(point);
        }
 
    }  // namespace fun