cv_mat.hpp

Go to the documentation of this file.

# /*
#  * Created by YongGyu Lee on 2020/12/08.
#  */
#
# ifndef VCCC_TYPE_SUPPORT_OPENCV_CV_MAT_HPP
# define VCCC_TYPE_SUPPORT_OPENCV_CV_MAT_HPP
#
# include <tuple>
# include <type_traits>
# include <utility>
#
# include "opencv2/opencv.hpp"
 
namespace vccc {
namespace internal {
 
template<size_t I, typename CVMatX, bool v>
struct tuple_element_impl;
 
template<size_t I, typename T, int m, int n>
struct tuple_element_impl<I, cv::Matx<T, m, n>, true> {
  using type = T;
};
 
} // namespace internal
} // namespace vccc
 
namespace std {
 
//template<typename T, int m, int n> struct internal::cv_size<cv::Matx<T, m, n>>;
//template<std::size_t i, std::size_t j, typename T, int m, int n> constexpr T& at(cv::Matx<T, m, n>& matx);
//template<std::size_t i, std::size_t j, typename T, int m, int n> constexpr const T& at(const cv::Matx<T, m, n>& matx);
//template<std::size_t i, std::size_t j, typename T, int m, int n> constexpr T&& at(cv::Matx<T, m, n>&& matx);
//template<std::size_t i, std::size_t j, typename T, int m, int n> constexpr const T&& at(const cv::Matx<T, m, n>&& matx);
 
template<typename T, int m, int n>
struct tuple_size<cv::Matx<T, m, n>> : std::integral_constant<size_t, m * n> {};
 
template<size_t I, typename T, int m, int n>
struct tuple_element<I, cv::Matx<T, m, n>> :
    vccc::internal::tuple_element_impl<I, cv::Matx<T, m, n>, (I < m * n)> {};
 
 
 
template<std::size_t i, typename T, int m, int n>
constexpr inline tuple_element_t<i, cv::Matx<T, m, n>>&
get(cv::Matx<T, m, n>& matx) noexcept {
  return matx(i);
}
 
template<std::size_t i, typename T, int m, int n>
constexpr inline const tuple_element_t<i, cv::Matx<T, m, n>>&
get(const cv::Matx<T, m, n>& matx) noexcept {
  return matx(i);
}
 
template<std::size_t i, typename T, int m, int n>
constexpr inline tuple_element_t<i, cv::Matx<T, m, n>>&&
get(cv::Matx<T, m, n>&& matx) noexcept {
  return std::move(matx(i));
}
 
template<std::size_t i, typename T, int m, int n>
constexpr inline const tuple_element_t<i, cv::Matx<T, m, n>>&&
get(const cv::Matx<T, m, n>&& matx) noexcept {
  return std::move(matx(i));
}
 
 
} // namespace std
 
namespace vccc {
template<std::size_t i, std::size_t j, typename T, int m, int n>
constexpr inline T&
at(cv::Matx<T, m, n>& matx) {
  static_assert(i < m && j < n, "Index out of bounds in vccc::at<> (cv::Matx)");
  static_assert(m > 1 && n > 1, "Invalid size (cv::Matx)");
  return matx(i, j);
}
 
template<std::size_t i, std::size_t j, typename T, int m, int n>
constexpr inline const T&
at(const cv::Matx<T, m, n>& matx) {
  static_assert(i < m && j < n, "Index out of bounds in vccc::at<> (const cv::Matx)");
  static_assert(m > 1 && n > 1, "Invalid size (const cv::Matx)");
  return matx(i, j);
}
 
template<std::size_t i, std::size_t j, typename T, int m, int n>
constexpr inline T&&
at(cv::Matx<T, m, n>&& matx) {
  static_assert(i < m && j < n, "Index out of bounds in vccc::at<> (cv::Matx&&)");
  static_assert(m > 1 && n > 1, "Invalid size (cv::Matx&&)");
  return std::move(matx(i, j));
}
 
template<std::size_t i, std::size_t j, typename T, int m, int n>
constexpr inline const T&&
at(const cv::Matx<T, m, n>&& matx) {
  static_assert(i < m && j < n, "Index out of bounds in vccc::at<> (const cv::Matx&&)");
  static_assert(m > 1 && n > 1, "Invalid size (const cv::Matx&&)");
  return std::move(matx(i, j));
}
 
 
template<typename T, int m, int n, typename N>
cv::Matx<T, m, n> add(const cv::Matx<T, m, n>& matx, N n_)
{
  return matx + cv::Matx<T, m, n>::all(n_);
}
 
} // namespace vccc
 
# endif // VCCC_TYPE_SUPPORT_OPENCV_CV_MAT_HPP