geometry.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_GEOMETRY_H
#define EGT_GEOMETRY_H
 
#include <algorithm>
#include <cassert>
#include <cmath>
#include <egt/detail/math.h>
#include <egt/detail/meta.h>
#include <ostream>
#include <string>
 
namespace egt
{
inline namespace v1
{
using DefaultDim = int;
 
namespace detail
{
 
enum class Compatible
{
    normal,
    display,
    grid
};
 
}
 
 
template <class Dim, detail::Compatible DimCompat = detail::Compatible::normal>
class PointType
{
public:
 
    using DimType = Dim;
 
    constexpr PointType() noexcept = default;
 
    constexpr PointType(Dim x, Dim y) noexcept
        : m_x(x),
          m_y(y)
    {}
 
    template<class Dim2>
    constexpr PointType(const PointType<Dim2>& p)
        : m_x(p.x()),
          m_y(p.y())
    {}
 
    constexpr PointType& operator+=(const PointType& rhs) noexcept
    {
        m_x += rhs.m_x;
        m_y += rhs.m_y;
        return *this;
    }
 
    constexpr PointType& operator-=(const PointType& rhs) noexcept
    {
        m_x -= rhs.m_x;
        m_y -= rhs.m_y;
        return *this;
    }
 
    constexpr PointType& operator*=(const PointType& rhs) noexcept
    {
        m_x *= rhs.m_x;
        m_y *= rhs.m_y;
        return *this;
    }
 
    constexpr PointType& operator/=(const PointType& rhs) noexcept
    {
        m_x /= rhs.m_x;
        m_y /= rhs.m_y;
        return *this;
    }
 
    template <class T>
    constexpr PointType& operator+=(const T& rhs) noexcept
    {
        m_x += rhs;
        m_y += rhs;
        return *this;
    }
 
    template <class T>
    constexpr PointType& operator-=(const T& rhs) noexcept
    {
        m_x -= rhs;
        m_y -= rhs;
        return *this;
    }
 
    template <class T>
    constexpr PointType& operator*=(const T& rhs) noexcept
    {
        m_x *= rhs;
        m_y *= rhs;
        return *this;
    }
 
    template <class T>
    constexpr PointType& operator/=(const T& rhs) noexcept
    {
        m_x /= rhs;
        m_y /= rhs;
        return *this;
    }
 
    template <class T>
    PointType point_on_circumference(T radius, T angle) const noexcept
    {
        return PointType(m_x + radius * std::cos(angle),
                         m_y + radius * std::sin(angle));
    }
 
    template <class T>
    EGT_NODISCARD T angle_to(const PointType& point) const noexcept
    {
        return std::atan2(point.m_x - m_x, m_y - point.m_y);
    }
 
    EGT_NODISCARD Dim distance_to(const PointType& point) const noexcept
    {
        return std::hypot(point.m_x - m_x, point.m_y - m_y);
    }
 
    EGT_NODISCARD constexpr Dim x() const noexcept { return m_x; }
    EGT_NODISCARD constexpr Dim y() const noexcept { return m_y; }
 
    constexpr void x(Dim x) noexcept { m_x = x; }
    constexpr void y(Dim y) noexcept { m_y = y; }
 
protected:
    Dim m_x{0};
    Dim m_y{0};
};
 
template<class Dim, detail::Compatible DimCompat>
constexpr PointType<Dim, DimCompat> operator-(const PointType<Dim, DimCompat>& a) noexcept
{
    return PointType<Dim, DimCompat>(-a.x(), -a.y());
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr bool operator==(const PointType<Dim, DimCompat>& lhs, const PointType<Dim, DimCompat>& rhs) noexcept
{
    return lhs.x() == rhs.x() && lhs.y() == rhs.y();
}
 
template<detail::Compatible DimCompat>
constexpr bool operator==(const PointType<float, DimCompat>& lhs, const PointType<float, DimCompat>& rhs)
{
    return detail::float_equal(lhs.x(), rhs.x()) &&
           detail::float_equal(lhs.y(), rhs.y());
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr bool operator!=(const PointType<Dim, DimCompat>& lhs, const PointType<Dim, DimCompat>& rhs) noexcept
{
    return !(lhs == rhs);
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr PointType<Dim, DimCompat> operator-(PointType<Dim, DimCompat> lhs, const PointType<Dim, DimCompat>& rhs) noexcept
{
    lhs -= rhs;
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr PointType<Dim, DimCompat> operator+(PointType<Dim, DimCompat> lhs, const PointType<Dim, DimCompat>& rhs) noexcept
{
    lhs += rhs;
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr PointType<Dim, DimCompat> operator/(PointType<Dim, DimCompat> lhs, const PointType<Dim, DimCompat>& rhs) noexcept
{
    lhs /= rhs;
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr PointType<Dim, DimCompat> operator*(PointType<Dim, DimCompat> lhs, const PointType<Dim, DimCompat>& rhs) noexcept
{
    lhs *= rhs;
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat, class T>
constexpr PointType<Dim, DimCompat> operator-(PointType<Dim, DimCompat> lhs, const T& rhs) noexcept
{
    lhs -= rhs;
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat, class T>
constexpr PointType<Dim, DimCompat> operator+(PointType<Dim, DimCompat> lhs, const T& rhs) noexcept
{
    lhs += rhs;
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat, class T>
constexpr PointType<Dim, DimCompat> operator/(PointType<Dim, DimCompat> lhs, const T& rhs) noexcept
{
    lhs /= rhs;
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat, class T>
constexpr PointType<Dim, DimCompat> operator*(PointType<Dim, DimCompat> lhs, const T& rhs) noexcept
{
    lhs *= rhs;
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat>
std::ostream& operator<<(std::ostream& os, const PointType<Dim, DimCompat>& point)
{
    os << "[" << point.x() << "," << point.y() << "]";
    return os;
}
 
using Point = PointType<DefaultDim, detail::Compatible::normal>;
 
static_assert(detail::rule_of_5<Point>(), "must fulfill rule of 5");
 
using PointF = PointType<float, detail::Compatible::normal>;
 
using DisplayPoint = PointType<DefaultDim, detail::Compatible::display>;
 
template<class Dim, detail::Compatible DimCompat = detail::Compatible::normal>
class SizeType
{
public:
 
    using DimType = Dim;
 
    constexpr SizeType() noexcept = default;
 
    constexpr SizeType(Dim width, Dim height) noexcept
        : m_height(height),
          m_width(width)
    {}
 
    template<class Dim2>
    constexpr SizeType(const SizeType<Dim2>& s)
        : m_height(s.height()),
          m_width(s.width())
    {}
 
    EGT_NODISCARD constexpr bool empty() const noexcept
    {
        // cppcheck-suppress unsignedLessThanZero
        return m_width <= 0 || m_height <= 0;
    }
 
    constexpr void clear() noexcept
    {
        m_height = m_width = 0;
    }
 
    constexpr SizeType& operator+=(const SizeType& rhs) noexcept
    {
        m_width += rhs.m_width;
        m_height += rhs.m_height;
        return *this;
    }
 
    constexpr SizeType& operator-=(const SizeType& rhs) noexcept
    {
        m_width -= rhs.m_width;
        m_height -= rhs.m_height;
        return *this;
    }
 
    constexpr SizeType& operator*=(const SizeType& rhs) noexcept
    {
        m_width *= rhs.m_width;
        m_height *= rhs.m_height;
        return *this;
    }
 
    constexpr SizeType& operator/=(const SizeType& rhs) noexcept
    {
        m_width /= rhs.m_width;
        m_height /= rhs.m_height;
        return *this;
    }
 
    template<class T>
    constexpr SizeType& operator+=(const T& rhs) noexcept
    {
        m_width += rhs;
        m_height += rhs;
        return *this;
    }
 
    template<class T>
    constexpr SizeType& operator-=(const T& rhs) noexcept
    {
        m_width -= rhs;
        m_height -= rhs;
        return *this;
    }
 
    template<class T>
    constexpr SizeType& operator*=(const T& rhs) noexcept
    {
        m_width *= rhs;
        m_height *= rhs;
        return *this;
    }
 
    template<class T>
    constexpr SizeType& operator/=(const T& rhs) noexcept
    {
        m_width /= rhs;
        m_height /= rhs;
        return *this;
    }
 
    EGT_NODISCARD constexpr Dim width() const  noexcept { return m_width; }
    EGT_NODISCARD constexpr Dim height() const  noexcept { return m_height; }
 
    constexpr void width(Dim width)  noexcept { m_width = width; }
    constexpr void height(Dim height)  noexcept { m_height = height; }
 
protected:
    Dim m_height{0};
 
    Dim m_width{0};
};
 
template<class Dim, detail::Compatible DimCompat>
constexpr bool operator==(const SizeType<Dim, DimCompat>& lhs, const SizeType<Dim, DimCompat>& rhs) noexcept
{
    return lhs.width() == rhs.width() && lhs.height() == rhs.height();
}
 
template<detail::Compatible DimCompat>
constexpr bool operator==(const SizeType<float, DimCompat>& lhs, const SizeType<float, DimCompat>& rhs)
{
    return detail::float_equal(lhs.width(), rhs.width()) &&
           detail::float_equal(lhs.height(), rhs.height());
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr bool operator!=(const SizeType<Dim, DimCompat>& lhs, const SizeType<Dim, DimCompat>& rhs) noexcept
{
    return !(lhs == rhs);
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr SizeType<Dim, DimCompat> operator-(SizeType<Dim, DimCompat> lhs, const SizeType<Dim, DimCompat>& rhs) noexcept
{
    lhs -= rhs;
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr SizeType<Dim, DimCompat> operator+(SizeType<Dim, DimCompat> lhs, const SizeType<Dim, DimCompat>& rhs) noexcept
{
    lhs += rhs;
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr SizeType<Dim, DimCompat> operator*(SizeType<Dim, DimCompat> lhs, const SizeType<Dim, DimCompat>& rhs) noexcept
{
    lhs *= rhs;
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr SizeType<Dim, DimCompat> operator/(SizeType<Dim, DimCompat> lhs, const SizeType<Dim, DimCompat>& rhs) noexcept
{
    lhs /= rhs;
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat, class T>
constexpr SizeType<Dim, DimCompat> operator-(SizeType<Dim, DimCompat> lhs, const T& rhs) noexcept
{
    lhs -= rhs;
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat, class T>
constexpr SizeType<Dim, DimCompat> operator+(SizeType<Dim, DimCompat> lhs, const T& rhs) noexcept
{
    lhs += rhs;
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat, class T>
constexpr SizeType<Dim, DimCompat> operator*(SizeType<Dim, DimCompat> lhs, const T& rhs) noexcept
{
    lhs *= rhs;
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat, class T>
constexpr SizeType<Dim, DimCompat> operator/(SizeType<Dim, DimCompat> lhs, const T& rhs) noexcept
{
    lhs /= rhs;
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat>
std::ostream& operator<<(std::ostream& os, const SizeType<Dim, DimCompat>& size)
{
    os << size.width() << "x" << size.height();
    return os;
}
 
using Size = SizeType<DefaultDim, detail::Compatible::normal>;
 
static_assert(detail::rule_of_5<Size>(), "must fulfill rule of 5");
 
using SizeF = SizeType<float, detail::Compatible::normal>;
 
template<class Dim, detail::Compatible DimCompat = detail::Compatible::normal>
class RectType
{
public:
 
    using DimType = Dim;
 
    constexpr RectType() noexcept = default;
 
    constexpr explicit RectType(const PointType<Dim>& point, const SizeType<Dim, DimCompat>& size) noexcept
        : m_origin(point),
          m_size(size)
    {
        assert(width() >= 0);
        assert(height() >= 0);
    }
 
    // cppcheck-suppress noExplicitConstructor
    // NOLINTNEXTLINE(hicpp-explicit-conversions)
    constexpr RectType(const SizeType<Dim, DimCompat>& size) noexcept
        : RectType( {}, size)
    {}
 
    constexpr RectType(Dim x, Dim y, Dim width, Dim height) noexcept
        : RectType( {x, y}, {width, height})
    {}
 
    template<typename Dim2>
    constexpr RectType(const RectType<Dim2>& r)
        : m_origin(r.point()),
          m_size(r.size())
    {}
 
    constexpr RectType& operator+=(const SizeType<Dim, DimCompat>& rhs) noexcept
    {
        m_size += rhs;
        return *this;
    }
 
    constexpr RectType& operator-=(const SizeType<Dim, DimCompat>& rhs) noexcept
    {
        m_size -= rhs;
        return *this;
    }
 
    constexpr RectType& operator+=(const PointType<Dim, DimCompat>& rhs) noexcept
    {
        m_origin += rhs;
        return *this;
    }
 
    constexpr RectType& operator-=(const PointType<Dim, DimCompat>& rhs) noexcept
    {
        m_origin -= rhs;
        return *this;
    }
 
    EGT_NODISCARD constexpr Dim area() const noexcept
    {
        return width() * height();
    }
 
    EGT_NODISCARD constexpr PointType<Dim, DimCompat> center() const noexcept
    {
        return PointType<Dim, DimCompat>(x() + (width() / 2.f), y() + (height() / 2.f));
    }
 
    constexpr void move_to_center(const PointType<Dim, DimCompat>& center) noexcept
    {
        const PointType<Dim, DimCompat> pos(center.x() - width() / 2.,
                                            center.y() - height() / 2.);
 
        m_origin = pos;
    }
 
    constexpr void grow_around_center(Dim radius) noexcept
    {
        m_origin -= (radius / 2);
        m_size += radius;
    }
 
    constexpr void shrink_around_center(Dim radius) noexcept
    {
        m_origin += (radius / 2);
        m_size -= radius;
    }
 
    EGT_NODISCARD constexpr const PointType<Dim, DimCompat>& point() const noexcept
    {
        return m_origin;
    }
 
    constexpr void point(const PointType<Dim, DimCompat>& p) noexcept
    {
        m_origin = p;
    }
 
    EGT_NODISCARD constexpr const SizeType<Dim, DimCompat>& size() const noexcept
    {
        return m_size;
    }
 
    constexpr void size(const SizeType<Dim, DimCompat>& size) noexcept
    {
        m_size = size;
    }
 
    EGT_NODISCARD constexpr Dim top() const noexcept
    {
        return m_origin.y();
    }
 
    EGT_NODISCARD constexpr Dim left() const noexcept
    {
        return m_origin.x();
    }
 
    EGT_NODISCARD constexpr Dim bottom() const noexcept
    {
        return top() + height();
    }
 
    EGT_NODISCARD constexpr Dim right() const noexcept
    {
        return left() + width();
    }
 
    EGT_NODISCARD constexpr PointType<Dim, DimCompat> top_left() const noexcept
    {
        return PointType<Dim, DimCompat>(left(), top());
    }
 
    EGT_NODISCARD constexpr PointType<Dim, DimCompat> top_right() const noexcept
    {
        return PointType<Dim, DimCompat>(right(), top());
    }
 
    EGT_NODISCARD constexpr PointType<Dim, DimCompat> bottom_left() const noexcept
    {
        return PointType<Dim, DimCompat>(left(), bottom());
    }
 
    EGT_NODISCARD constexpr PointType<Dim, DimCompat> bottom_right() const noexcept
    {
        return PointType<Dim, DimCompat>(right(), bottom());
    }
 
    constexpr void clear() noexcept
    {
        m_origin = {};
        m_size = {};
    }
 
    EGT_NODISCARD constexpr bool empty() const noexcept
    {
        return width() <= 0 || height() <= 0;
    }
 
    EGT_NODISCARD constexpr bool intersect(const PointType<Dim, DimCompat>& point) const noexcept
    {
        return (point.x() < right() && point.x() >= left() &&
                point.y() < bottom() && point.y() >= top());
    }
 
    EGT_NODISCARD constexpr bool intersect(const RectType& rect) const noexcept
    {
        return (x() < rect.x() + rect.width() && x() + width() > rect.x() &&
                y() < rect.y() + rect.height() && y() + height() > rect.y());
    }
 
    static constexpr RectType merge(const RectType& lhs,
                                    const RectType& rhs) noexcept
    {
        const auto xmin = std::min(lhs.x(), rhs.x());
        const auto xmax = std::max(lhs.x() + lhs.width(),
                                   rhs.x() + rhs.width());
        const auto ymin = std::min(lhs.y(), rhs.y());
        const auto ymax = std::max(lhs.y() + lhs.height(),
                                   rhs.y() + rhs.height());
 
        return RectType<Dim, DimCompat>(xmin, ymin, xmax - xmin, ymax - ymin);
    }
 
    static constexpr RectType intersection(const RectType& lhs,
                                           const RectType& rhs) noexcept
    {
        const auto x0 = std::max(lhs.x(), rhs.x());
        const auto y0 = std::max(lhs.y(), rhs.y());
        const auto w0 = std::min(lhs.x() + lhs.width(), rhs.x() + rhs.width()) - x0;
        const auto h0 = std::min(lhs.y() + lhs.height(), rhs.y() + rhs.height()) - y0;
 
        if (w0 < 0 || h0 < 0)
            return RectType<Dim, DimCompat>();
 
        return RectType<Dim, DimCompat>(x0, y0, w0, h0);
    }
 
    EGT_NODISCARD constexpr bool contains(const RectType& rhs) const noexcept
    {
        return rhs.right() < right() &&
               rhs.bottom() < bottom() &&
               rhs.left() > left() &&
               rhs.top() > top();
    }
 
    EGT_NODISCARD constexpr Dim x() const noexcept { return m_origin.x(); }
    EGT_NODISCARD constexpr Dim y() const noexcept { return m_origin.y(); }
 
    constexpr void x(Dim x) noexcept { m_origin.x(x); }
    constexpr void y(Dim y) noexcept { m_origin.y(y); }
 
    EGT_NODISCARD constexpr Dim width() const noexcept { return m_size.width(); }
    EGT_NODISCARD constexpr Dim height() const noexcept { return m_size.height(); }
 
    constexpr void width(Dim width) noexcept { m_size.width(width); }
    constexpr void height(Dim height) noexcept { m_size.height(height); }
 
protected:
 
    PointType<Dim, DimCompat> m_origin;
    SizeType<Dim, DimCompat> m_size;
};
 
template<class Dim, detail::Compatible DimCompat>
std::ostream& operator<<(std::ostream& os, const RectType<Dim, DimCompat>& rect)
{
    os << "["  << rect.x() << "," << rect.y() << "-" <<
       rect.width() << "x" << rect.height() << "]";
    return os;
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr RectType<Dim, DimCompat> operator-(RectType<Dim, DimCompat> lhs, const SizeType<Dim, DimCompat>& rhs) noexcept
{
    lhs.size(lhs.size() - rhs);
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr RectType<Dim, DimCompat> operator+(RectType<Dim, DimCompat> lhs, const SizeType<Dim, DimCompat>& rhs) noexcept
{
    lhs.size(lhs.size() + rhs);
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr RectType<Dim, DimCompat> operator*(RectType<Dim, DimCompat> lhs, const SizeType<Dim, DimCompat>& rhs) noexcept
{
    lhs.size(lhs.size() * rhs);
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr RectType<Dim, DimCompat> operator/(RectType<Dim, DimCompat> lhs, const SizeType<Dim, DimCompat>& rhs) noexcept
{
    lhs.size(lhs.size() / rhs);
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr RectType<Dim, DimCompat> operator+(RectType<Dim, DimCompat> lhs, const PointType<Dim, DimCompat>& rhs) noexcept
{
    lhs.point(lhs.point() + rhs);
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr RectType<Dim, DimCompat> operator-(RectType<Dim, DimCompat> lhs, const PointType<Dim, DimCompat>& rhs) noexcept
{
    lhs.point(lhs.point() - rhs);
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr RectType<Dim, DimCompat> operator*(RectType<Dim, DimCompat> lhs, const PointType<Dim, DimCompat>& rhs) noexcept
{
    lhs.point(lhs.point() * rhs);
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr RectType<Dim, DimCompat> operator/(RectType<Dim, DimCompat> lhs, const PointType<Dim, DimCompat>& rhs) noexcept
{
    lhs.point(lhs.point() / rhs);
    return lhs;
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr bool operator==(const RectType<Dim, DimCompat>& lhs, const RectType<Dim, DimCompat>& rhs) noexcept
{
    return lhs.point() == rhs.point() &&
           lhs.size() == rhs.size();
}
 
template<class Dim, detail::Compatible DimCompat>
constexpr bool operator!=(const RectType<Dim, DimCompat>& lhs, const RectType<Dim, DimCompat>& rhs) noexcept
{
    return !(lhs == rhs);
}
 
using Rect = RectType<DefaultDim, detail::Compatible::normal>;
 
static_assert(detail::rule_of_5<Rect>(), "must fulfill rule of 5");
 
using RectF = RectType<float, detail::Compatible::normal>;
 
template<class Dim>
class LineType
{
public:
 
    using DimType = Dim;
 
    constexpr explicit LineType(const PointType<Dim>& start, const PointType<Dim>& end) noexcept
        : m_start(start),
          m_end(end)
    {}
 
    EGT_NODISCARD constexpr PointType<Dim> start() const noexcept { return m_start; }
    EGT_NODISCARD constexpr PointType<Dim> end() const noexcept { return m_end; }
 
    constexpr void start(const PointType<Dim>& start) noexcept { m_start = start; }
    constexpr void end(const PointType<Dim>& end) noexcept { m_end = end; }
 
    EGT_NODISCARD constexpr RectType<Dim> rect() const noexcept
    {
        const auto x = std::min(m_start.x(), m_end.x());
        const auto y = std::min(m_start.y(), m_end.y());
        const auto x2 = std::max(m_start.x(), m_end.x());
        const auto y2 = std::max(m_start.y(), m_end.y());
 
        return RectType<Dim>(x, y, x2 - x, y2 - y);
    }
 
protected:
    PointType<Dim> m_start;
    PointType<Dim> m_end;
};
 
template<class Dim>
std::ostream& operator<<(std::ostream& os, const LineType<Dim>& line)
{
    os << "[" << line.start() << "-" << line.end() << "]";
    return os;
}
 
using Line = LineType<DefaultDim>;
 
using LineF = LineType<float>;
 
static_assert(detail::rule_of_5<Line>(), "must fulfill rule of 5");
 
template<class Dim>
class ArcType
{
public:
 
    using DimType = Dim;
 
    constexpr explicit ArcType(const PointType<Dim>& center = {}, Dim radius = {},
                               float angle1 = 0.0f, float angle2 = 0.0f) noexcept
        : m_center(center),
          m_radius(radius),
          m_angle1(angle1),
          m_angle2(angle2)
    {
    }
 
    template<class Dim2>
    constexpr ArcType(const ArcType<Dim2>& a)
        : m_center(a.center()),
          m_radius(a.radius()),
          m_angle1(a.angle1()),
          m_angle2(a.angle2())
    {
    }
 
    EGT_NODISCARD EGT_API bool empty() const noexcept;
 
    constexpr void radius(Dim radius) noexcept { m_radius = radius; }
    constexpr void angle1(float angle) noexcept { m_angle1 = angle; }
    constexpr void angle2(float angle) noexcept { m_angle2 = angle; }
    constexpr void center(const PointType<Dim>& center) noexcept { m_center = center; }
 
    EGT_NODISCARD constexpr Dim radius() const noexcept { return m_radius; }
    EGT_NODISCARD constexpr float angle1() const noexcept { return m_angle1; }
    EGT_NODISCARD constexpr float angle2() const noexcept { return m_angle2; }
    EGT_NODISCARD constexpr PointType<Dim> center() const noexcept { return m_center; }
 
protected:
 
    PointType<Dim> m_center;
 
    Dim m_radius{0};
 
    float m_angle1{};
 
    float m_angle2{};
};
 
using Arc = ArcType<DefaultDim>;
 
static_assert(detail::rule_of_5<Arc>(), "must fulfill rule of 5");
 
using ArcF = ArcType<float>;
 
template<class Dim>
class CircleType : public ArcType<Dim>
{
public:
 
    using DimType = Dim;
 
    constexpr explicit CircleType(const PointType<Dim>& center = {}, Dim radius = {}) noexcept
        : ArcType<Dim>(center, radius, 0, 2.f * detail::pi<float>())
    {
    }
 
    template<class Dim2>
    constexpr CircleType(const CircleType<Dim2>& c)
        : CircleType(c.center(), c.radius())
    {
    }
 
    EGT_NODISCARD constexpr RectType<Dim> rect() const noexcept
    {
        RectType<Dim> r(this->center() - Point(this->radius(), this->radius()),
                        SizeType<Dim>(this->radius() * 2, this->radius() * 2));
        return r;
    }
 
    template <class T>
    PointType<Dim> point_on_circumference(T angle) const noexcept
    {
        return PointType<Dim>(this->x() + this->radius() * std::cos(angle),
                              this->y() + this->radius() * std::sin(angle));
    }
};
 
template<class Dim>
std::ostream& operator<<(std::ostream& os, const CircleType<Dim>& circle)
{
    os << "[" << circle.center() << "-" << circle.radius() << "]";
    return os;
}
 
using Circle = CircleType<DefaultDim>;
 
static_assert(detail::rule_of_5<Circle>(), "must fulfill rule of 5");
 
using CircleF = CircleType<float>;
 
template<class Dim>
class EllipseType
{
public:
    using DimType = Dim;
 
    explicit constexpr EllipseType(const PointType<Dim>& center = {},
                                   Dim radiusa = {},
                                   Dim radiusb = {}) noexcept
        : m_center(center),
          m_radiusa(radiusa),
          m_radiusb(radiusb)
    {
    }
 
    template<class Dim2>
    constexpr EllipseType(const EllipseType<Dim2>& e)
        : EllipseType(e.center(), e.radiusa(), e.radiusb())
    {
    }
 
    EGT_NODISCARD constexpr Dim perimeter() const noexcept
    {
        return 2.f * detail::pi<float>() * std::sqrt((m_radiusa * m_radiusa +
                m_radiusb * m_radiusb) / 2.f);
    }
 
    template <class T>
    PointType<Dim> point_on_circumference(T angle) noexcept
    {
        const auto x = m_radiusa * std::cos(angle);
        const auto y = m_radiusb * std::sin(angle);
        return center() + PointType<Dim>(x, y);
    }
 
    constexpr void radiusa(const Dim radiusa) noexcept { m_radiusa = radiusa; }
    constexpr void radiusb(const Dim radiusb) noexcept { m_radiusb = radiusb; }
    constexpr void center(const PointType<Dim>& center) noexcept { m_center = center; }
 
    EGT_NODISCARD constexpr Dim radiusa() const noexcept { return m_radiusa; }
    EGT_NODISCARD constexpr Dim radiusb() const noexcept { return m_radiusb; }
    EGT_NODISCARD constexpr PointType<Dim> center() const noexcept { return m_center; }
 
protected:
 
    PointType<Dim> m_center;
 
    Dim m_radiusa{0};
 
    Dim m_radiusb{0};
};
 
using Ellipse = EllipseType<DefaultDim>;
 
static_assert(detail::rule_of_5<Ellipse>(), "must fulfill rule of 5");
 
using EllipseF = EllipseType<float>;
 
template<class Dim>
std::ostream& operator<<(std::ostream& os, const EllipseType<Dim>& ellipse)
{
    os << "[" << ellipse.center() << "-" << ellipse.radiusa() <<
       "-" << ellipse.radiusb() << "]";
    return os;
}
 
}
}
 
#endif