peak_common_point.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/detail/peak_common_backend_accessor.hpp>
#include <peak_common/detail/peak_common_math.hpp>
#include <peak_common/detail/peak_common_type_traits.hpp>
#include <peak_common_c/detail/peak_common_defines.h>
 
#include <array>
#include <sstream>
 
namespace peak
{
namespace common
{
 
namespace detail
{
template <typename T, size_t dimension>
class PointXd
{
public:
    static_assert(dimension >= 2, "A Point must consist of at least two coordinates (x,y)!");
    static_assert(std::is_arithmetic<T>::value, "A point must be created from an arithmetic type!");
 
    constexpr PointXd() = default;
 
    constexpr explicit PointXd(std::array<T, dimension> coordinates)
        : m_coordinates{ coordinates }
    {}
 
    PEAK_COMMON_NO_DISCARD constexpr T GetX() const
    {
        return m_coordinates.at(0);
    }
 
    PEAK_COMMON_NO_DISCARD constexpr T GetY() const
    {
        return m_coordinates.at(1);
    }
 
    template <typename H,
        size_t d
        ,
        typename std::enable_if_t<std::is_integral<H>::value, int> = 0
        >
    constexpr bool operator==(const PointXd<H, d>& rhs) const
    {
        return std::equal(this->m_coordinates.begin(), this->m_coordinates.end(), rhs.GetCoordinates().begin());
    }
 
    template <typename H, size_t d>
    constexpr bool operator!=(const PointXd<H, d>& rhs) const
    {
        return !(*this == rhs);
    }
 
    template <typename H,
        size_t d
        ,
        typename std::enable_if_t<std::is_floating_point<H>::value, int> = 0
        >
    constexpr bool operator==(const PointXd<H, d>& rhs) const
    {
        using common_type = std::common_type_t<T, H>;
 
        // Unit in the last place
        constexpr uint32_t ulp = 4;
 
        return std::equal(this->m_coordinates.begin(), this->m_coordinates.end(), rhs.GetCoordinates().begin(),
            [ulp](const auto& left, const auto& right) {
                return detail::AreAlmostEqual<common_type>(static_cast<common_type>(left), static_cast<common_type>(right), ulp);
            });
    }
 
    PEAK_COMMON_NO_DISCARD constexpr std::array<T, dimension> GetCoordinates() const
    {
        return m_coordinates;
    }
 
private:
    std::array<T, dimension> m_coordinates{};
};
 
template <typename T>
class PointT : public PointXd<T, 2>
{
 
private:
    using PointType = PointT<T>;
 
public:
    static_assert(std::is_arithmetic<T>::value, "Template argument of Point must be arithmetic.");
 
    constexpr PointT() = default;
 
    constexpr PointT(T x, T y)
        : PointXd<T, 2>({ x, y })
    {}
 
    friend std::ostream& operator<<(std::ostream& os, PointT point)
    {
        return os << "{ x: " << point.GetX() << ", y: " << point.GetY() << " }";
    }
 
    PEAK_COMMON_NO_DISCARD std::string ToString() const
    {
        std::ostringstream ss;
        ss << *this;
        return ss.str();
    }
 
private:
    friend detail::BackendAccessor<PointT<T>>;
 
    template <typename U = T, typename std::enable_if<has_c_type_of<PointT<U>>::value, bool>::type = false>
    constexpr explicit PointT(peak::common::detail::c_type_of_t<PointT<U>> point)
        : PointT(static_cast<T>(point.x), static_cast<T>(point.y))
    {}
 
    template <typename U = T, typename std::enable_if<has_c_type_of<PointT<U>>::value, bool>::type = false>
    constexpr explicit operator peak::common::detail::c_type_of_t<PointT<U>>() const
    {
        return { this->GetX(), this->GetY() };
    }
 
    friend detail::BackendAccessor<PointType>;
};
 
} // namespace detail
 
using Point = detail::PointT<int32_t>;
 
using PointF = detail::PointT<float>;
 
using PointU = detail::PointT<uint32_t>;
 
} // namespace common 
} // namespace peak