//
|
// Copyright 2005-2007 Adobe Systems Incorporated
|
//
|
// Distributed under the Boost Software License, Version 1.0
|
// See accompanying file LICENSE_1_0.txt or copy at
|
// http://www.boost.org/LICENSE_1_0.txt
|
//
|
#ifndef BOOST_GIL_POINT_HPP
|
#define BOOST_GIL_POINT_HPP
|
|
#include <boost/gil/utilities.hpp>
|
#include <boost/gil/detail/std_common_type.hpp>
|
|
#include <boost/config.hpp>
|
|
#include <cstddef>
|
#include <type_traits>
|
|
namespace boost { namespace gil {
|
|
/// \addtogroup PointModel
|
///
|
/// Example:
|
/// \code
|
/// point<std::ptrdiff_t> p(3,2);
|
/// assert((p[0] == p.x) && (p[1] == p.y));
|
/// assert(axis_value<0>(p) == 3);
|
/// assert(axis_value<1>(p) == 2);
|
/// \endcode
|
|
/// \brief 2D point both axes of which have the same dimension type
|
/// \ingroup PointModel
|
/// Models: Point2DConcept
|
template <typename T>
|
class point
|
{
|
public:
|
using value_type = T;
|
|
template<std::size_t D>
|
struct axis
|
{
|
using coord_t = value_type;
|
};
|
|
static constexpr std::size_t num_dimensions = 2;
|
|
point() = default;
|
point(T px, T py) : x(px), y(py) {}
|
|
point operator<<(std::ptrdiff_t shift) const
|
{
|
return point(x << shift, y << shift);
|
}
|
|
point operator>>(std::ptrdiff_t shift) const
|
{
|
return point(x >> shift, y >> shift);
|
}
|
|
point& operator+=(point const& p)
|
{
|
x += p.x;
|
y += p.y;
|
return *this;
|
}
|
|
point& operator-=(point const& p)
|
{
|
x -= p.x;
|
y -= p.y;
|
return *this;
|
}
|
|
point& operator/=(double d)
|
{
|
if (d < 0 || 0 < d)
|
{
|
x = static_cast<T>(x / d);
|
y = static_cast<T>(y / d);
|
}
|
return *this;
|
}
|
|
point& operator*=(double d)
|
{
|
x = static_cast<T>(x * d);
|
y = static_cast<T>(y * d);
|
return *this;
|
}
|
|
T const& operator[](std::size_t i) const
|
{
|
return this->*mem_array[i];
|
}
|
|
T& operator[](std::size_t i)
|
{
|
return this->*mem_array[i];
|
}
|
|
T x{0};
|
T y{0};
|
|
private:
|
// this static array of pointers to member variables makes operator[] safe
|
// and doesn't seem to exhibit any performance penalty.
|
static T point<T>::* const mem_array[num_dimensions];
|
};
|
|
/// Alias template for backward compatibility with Boost <=1.68.
|
template <typename T>
|
using point2 = point<T>;
|
|
/// Common type to represent 2D dimensions or in-memory size of image or view.
|
/// @todo TODO: rename to dims_t or dimensions_t for purpose clarity?
|
using point_t = point<std::ptrdiff_t>;
|
|
template <typename T>
|
T point<T>::* const point<T>::mem_array[point<T>::num_dimensions] =
|
{
|
&point<T>::x,
|
&point<T>::y
|
};
|
|
/// \ingroup PointModel
|
template <typename T>
|
BOOST_FORCEINLINE
|
bool operator==(const point<T>& p1, const point<T>& p2)
|
{
|
return p1.x == p2.x && p1.y == p2.y;
|
}
|
|
/// \ingroup PointModel
|
template <typename T>
|
BOOST_FORCEINLINE
|
bool operator!=(const point<T>& p1, const point<T>& p2)
|
{
|
return p1.x != p2.x || p1.y != p2.y;
|
}
|
|
/// \ingroup PointModel
|
template <typename T>
|
BOOST_FORCEINLINE
|
point<T> operator+(const point<T>& p1, const point<T>& p2)
|
{
|
return { p1.x + p2.x, p1.y + p2.y };
|
}
|
|
/// \ingroup PointModel
|
template <typename T>
|
BOOST_FORCEINLINE
|
point<T> operator-(const point<T>& p)
|
{
|
return { -p.x, -p.y };
|
}
|
|
/// \ingroup PointModel
|
template <typename T>
|
BOOST_FORCEINLINE
|
point<T> operator-(const point<T>& p1, const point<T>& p2)
|
{
|
return { p1.x - p2.x, p1.y - p2.y };
|
}
|
|
/// \ingroup PointModel
|
template <typename T, typename D>
|
BOOST_FORCEINLINE
|
auto operator/(point<T> const& p, D d)
|
-> typename std::enable_if
|
<
|
std::is_arithmetic<D>::value,
|
point<typename detail::std_common_type<T, D>::type>
|
>::type
|
{
|
static_assert(std::is_arithmetic<D>::value, "denominator is not arithmetic type");
|
using result_type = typename detail::std_common_type<T, D>::type;
|
if (d < 0 || 0 < d)
|
{
|
double const x = static_cast<double>(p.x) / static_cast<double>(d);
|
double const y = static_cast<double>(p.y) / static_cast<double>(d);
|
return point<result_type>{
|
static_cast<result_type>(iround(x)),
|
static_cast<result_type>(iround(y))};
|
}
|
else
|
{
|
return point<result_type>{0, 0};
|
}
|
}
|
|
/// \ingroup PointModel
|
template <typename T, typename M>
|
BOOST_FORCEINLINE
|
auto operator*(point<T> const& p, M m)
|
-> typename std::enable_if
|
<
|
std::is_arithmetic<M>::value,
|
point<typename detail::std_common_type<T, M>::type>
|
>::type
|
{
|
static_assert(std::is_arithmetic<M>::value, "multiplier is not arithmetic type");
|
using result_type = typename detail::std_common_type<T, M>::type;
|
return point<result_type>{p.x * m, p.y * m};
|
}
|
|
/// \ingroup PointModel
|
template <typename T, typename M>
|
BOOST_FORCEINLINE
|
auto operator*(M m, point<T> const& p)
|
-> typename std::enable_if
|
<
|
std::is_arithmetic<M>::value,
|
point<typename detail::std_common_type<T, M>::type>
|
>::type
|
{
|
static_assert(std::is_arithmetic<M>::value, "multiplier is not arithmetic type");
|
using result_type = typename detail::std_common_type<T, M>::type;
|
return point<result_type>{p.x * m, p.y * m};
|
}
|
|
/// \ingroup PointModel
|
template <std::size_t K, typename T>
|
BOOST_FORCEINLINE
|
T const& axis_value(point<T> const& p)
|
{
|
static_assert(K < point<T>::num_dimensions, "axis index out of range");
|
return p[K];
|
}
|
|
/// \ingroup PointModel
|
template <std::size_t K, typename T>
|
BOOST_FORCEINLINE
|
T& axis_value(point<T>& p)
|
{
|
static_assert(K < point<T>::num_dimensions, "axis index out of range");
|
return p[K];
|
}
|
|
/// \addtogroup PointAlgorithm
|
///
|
/// Example:
|
/// \code
|
/// assert(iround(point<double>(3.1, 3.9)) == point<std::ptrdiff_t>(3,4));
|
/// \endcode
|
|
/// \ingroup PointAlgorithm
|
template <typename T>
|
inline point<std::ptrdiff_t> iround(point<T> const& p)
|
{
|
static_assert(std::is_integral<T>::value, "T is not integer");
|
return { static_cast<std::ptrdiff_t>(p.x), static_cast<std::ptrdiff_t>(p.y) };
|
}
|
|
/// \ingroup PointAlgorithm
|
inline point<std::ptrdiff_t> iround(point<float> const& p)
|
{
|
return { iround(p.x), iround(p.y) };
|
}
|
|
/// \ingroup PointAlgorithm
|
inline point<std::ptrdiff_t> iround(point<double> const& p)
|
{
|
return { iround(p.x), iround(p.y) };
|
}
|
|
/// \ingroup PointAlgorithm
|
inline point<std::ptrdiff_t> ifloor(point<float> const& p)
|
{
|
return { ifloor(p.x), ifloor(p.y) };
|
}
|
|
/// \ingroup PointAlgorithm
|
inline point<std::ptrdiff_t> ifloor(point<double> const& p)
|
{
|
return { ifloor(p.x), ifloor(p.y) };
|
}
|
|
/// \ingroup PointAlgorithm
|
inline point<std::ptrdiff_t> iceil(point<float> const& p)
|
{
|
return { iceil(p.x), iceil(p.y) };
|
}
|
|
/// \ingroup PointAlgorithm
|
inline point<std::ptrdiff_t> iceil(point<double> const& p)
|
{
|
return { iceil(p.x), iceil(p.y) };
|
}
|
|
}} // namespace boost::gil
|
|
#endif
|
