ellipse.h

 
 
#pragma once
 
#include "geometry_common.h"
#include "shape_concepts.h"
 
namespace ghassanpl::geometry
{
    template <std::floating_point T>
    struct tellipse
    {
        glm::tvec2<T> center;
        glm::tvec2<T> radii;
 
        static tellipse inside_rect(trec2<T> const& rec) noexcept
        {
            return { rec.center(), rec.half_size() };
        }
 
        static tellipse outside_rect(trec2<T> const& rec) noexcept;
 
        bool contains(glm::tvec2<T> pt) const
        {
            const auto d = pt - center;
            return (d.x * d.x) / (radii.x * radii.x) + (d.y * d.y) / (radii.y * radii.y) <= T(1);
        }
 
        T edge_length() const
        {
            const auto a = std::max(radii.x, radii.y);
            const auto b = std::min(radii.x, radii.y);
            const auto h = ((a - b) * (a - b)) / ((a + b) * (a + b));
            return glm::pi<T>() * (a + b) * (1 + ((3 * h) / (10 + sqrtf(4 - 3 * h))));
        }
        
        glm::tvec2<T> edge_point_alpha(T t) const
        {
            throw "unimplemented";
        }
        
        T calculate_area() const { return glm::pi<T>() * radii.x * radii.y; }
        glm::tvec2<T> edge_point(T t) const { return edge_point_alpha(t / edge_length()); }
        trec2<T> bounding_box() const { return trec2<T>{center - radii, center + radii}; }
        
        glm::tvec2<T> projected(glm::tvec2<T> pt) const
        {
            throw "unimplemented";
        }
    };
 
    using ellipse = tellipse<float>;
 
    static_assert(area_shape<ellipse, float>);
}