conic.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstdint>
#include <optional>
#include <variant>
#include <vector>
 
#include "fractions.hpp"
#include "pg_object.hpp"
 
namespace fun {
 
    enum class ConicType { Ellipse, Parabola, Hyperbola };
 
    class Conic {
      public:
        using Mat3x3 = std::array<std::array<Fraction, 3>, 3>;
 
        constexpr explicit Conic(Mat3x3 matrix) : matrix_{std::move(matrix)} {}
 
        static constexpr auto circle(std::int64_t center_x, std::int64_t center_y,
                                     std::int64_t radius_sq) -> Conic {
            const Fraction cx{center_x, 1};
            const Fraction cy{center_y, 1};
            const Fraction r2{radius_sq, 1};
            const Fraction zero{0, 1};
            const Fraction one{1, 1};
            return Conic{Mat3x3{{
                {{one, zero, -cx}},
                {{zero, one, -cy}},
                {{-cx, -cy, cx * cx + cy * cy - r2}},
            }}};
        }
 
        static constexpr auto unit_circle() -> Conic { return circle(0, 0, 1); }
 
        static constexpr auto parabola(const Fraction& a) -> Conic {
            const Fraction zero{0, 1};
            const Fraction half{1, 2};
            const auto na = -a;
            return Conic{Mat3x3{{
                {{na, zero, zero}},
                {{zero, zero, half}},
                {{zero, half, zero}},
            }}};
        }
 
        constexpr auto contains(const PgPoint& point) const -> bool {
            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 val = x * (m[0][0] * x + m[0][1] * y + m[0][2] * z)
                             + y * (m[1][0] * x + m[1][1] * y + m[1][2] * z)
                             + z * (m[2][0] * x + m[2][1] * y + m[2][2] * z);
            return val == Fraction{0, 1};
        }
 
        constexpr auto polar(const PgPoint& point) const -> PgLine {
            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 a = m[0][0] * x + m[0][1] * y + m[0][2] * z;
            const auto b = m[1][0] * x + m[1][1] * y + m[1][2] * z;
            const auto c = m[2][0] * x + m[2][1] * y + m[2][2] * z;
 
            return PgLine{{a.numer() / a.denom(), b.numer() / b.denom(), c.numer() / c.denom()}};
        }
 
        constexpr auto tangent(const PgPoint& point) const -> PgLine { return polar(point); }
 
        constexpr auto pole(const PgLine& line) const -> PgPoint {
            return PgPoint{{line.coord[0], line.coord[1], line.coord[2]}};
        }
 
        [[nodiscard]] auto intersect(const PgLine& line) const -> std::vector<PgPoint> {
            (void)line;
            return {};
        }
 
        constexpr auto discriminant() const -> Fraction {
            return matrix_[0][0] * matrix_[1][1] - matrix_[0][1] * matrix_[1][0];
        }
 
        constexpr auto conic_type() const -> ConicType {
            const auto d = discriminant();
            if (d > Fraction{0, 1}) return ConicType::Ellipse;
            if (d == Fraction{0, 1}) return ConicType::Parabola;
            return ConicType::Hyperbola;
        }
 
        constexpr auto matrix() const -> const Mat3x3& { return matrix_; }
 
        constexpr auto operator==(const Conic& other) const -> bool {
            return matrix_ == other.matrix_;
        }
 
      private:
        Mat3x3 matrix_;
    };
 
}  // namespace fun