/home/hauberg/Dokumenter/Capture/humim-tracker-0.1/src/ntk/utils/opencv_utils.h

Go to the documentation of this file.

#ifndef NTK_OPENCV_UTILS_H
#define NTK_OPENCV_UTILS_H

#include <ntk/core.h>

# define for_all_rc(im) \
  for (int r = 0; r < (im).rows; ++r) \
  for (int c = 0; c < (im).cols; ++c)

// depth row col iterations
# define for_all_drc(im) \
  for (int d = 0; d < (im).size[0]; ++d) \
  for (int r = 0; r < (im).size[1]; ++r) \
  for (int c = 0; c < (im).size[2]; ++c)

inline bool operator<(const cv::Point2i& p1, const cv::Point2i& p2)
{
  if (p1.x == p2.x) return p1.y < p2.y;
  return p1.x < p2.x;
}

namespace ntk
{

template <class T>
class Rect3_
{
public:
  Rect3_() :
    x(0), y(0), z(0),
    width(-1), height(-1), depth(-1)
  {}

  void extendToInclude(const cv::Point3f& p)
  {
    if (width < T(0) || height < T(0) || depth < T(0))
    {
      x = p.x;
      y = p.y;
      z = p.z;
      width = 1e-5;
      height = 1e-5;
      depth = 1e-5;
    }
    else
    {
      T min_x = std::min(x, p.x);
      T max_x = std::max(x+width, p.x);
      T min_y = std::min(y, p.y);
      T max_y = std::max(y+height, p.y);
      T min_z = std::min(z, p.z);
      T max_z = std::max(z+depth, p.z);

      x = min_x; width = max_x - min_x;
      y = min_y; height = max_y - min_y;
      z = min_z; depth = max_z - min_z;
    }
  }

  bool isEmpty() const
  {
    return width < 0 || height < 0 || depth < 0;
  }

  cv::Point3_<T> centroid() const
  {
    return cv::Point3_<T>(x+(width/T(2)), y+(height/T(2)), z + (depth / T(2)));
  }

public:
  T x,y,z,width,height,depth;
};

typedef Rect3_<float> Rect3f;

ntk::Rect3f bounding_box(const std::vector<cv::Point3f>& points);

}

namespace ntk
{

  inline cv::Point2f box_center(const cv::Rect_<float>& bbox)
  {
    return cv::Point2f(bbox.x + bbox.width/2.0, bbox.y + bbox.height/2.0);
  }

template <class ScalarType>
cv::Vec3d toVec3d(const cv::Mat_<ScalarType>& m)
{
  //ntk_assert(m.rows == 3 && m.cols == 1, "m is not a vector.");
  return cv::Vec3d(m(0,0), m(1,0), m(2,0));
}

template <class ScalarType>
cv::Vec2f toVec2f(const cv::Mat_<ScalarType>& m)
{
  //ntk_assert((m.rows == 2 || m.rows == 3) && m.cols == 1, "m is not a vector.");
  return cv::Vec2f(m(0,0), m(1,0));
}

template <class ScalarType1, class ScalarType2>
void copyMatWithCast(cv::Mat_<ScalarType1>& dest, const cv::Mat_<ScalarType2>& src)
{
  //ntk_assert(dest.size == src.size, "Size mismatch");
  for_all_rc(src)
  {
    dest(r,c) = src(r,c);
  }
}

cv::Mat4b toMat4b(const cv::Mat3b& im);
cv::Mat3b toMat3b(const cv::Mat4b& im);

void apply_mask(cv::Mat1b& im, const cv::Mat1b& mask);
void apply_mask(cv::Mat3b& im, const cv::Mat1b& mask);
void apply_mask(cv::Mat1f& im, const cv::Mat1b& mask);

void read_from_yaml(cv::FileNode node, cv::Vec3f& v);
void write_to_yaml(cv::FileStorage& output_file, const std::string& name, const cv::Vec3f& v);

void read_from_yaml(cv::FileNode node, cv::Rect& v);
void write_to_yaml(cv::FileStorage& output_file, const std::string& name, const cv::Rect& v);

void read_from_yaml(cv::FileNode node, bool& b);
void write_to_yaml(cv::FileStorage& output_file, const std::string& name, bool b);

void read_from_yaml(cv::FileNode node, int& b);
void write_to_yaml(cv::FileStorage& output_file, const std::string& name, int b);

void read_from_yaml(cv::FileNode node, double& b);
void write_to_yaml(cv::FileStorage& output_file, const std::string& name, double b);

void read_from_yaml(cv::FileNode node, cv::Mat& matrix);
void write_to_yaml(cv::FileStorage& output_file, const std::string& name, const cv::Mat& matrix);

void writeMatrix(cv::FileStorage& output_file, const std::string& name, const cv::Mat& matrix);
void readMatrix(cv::FileStorage& input_file, const std::string& name, cv::Mat& matrix);

cv::Mat1b normalize_toMat1b(const cv::Mat1f& image);
cv::Mat3b toMat3b(const cv::Mat1b& image);

void imwrite_normalized(const std::string& filename, const cv::Mat1f& m);
void imshow_normalized(const std::string& window_name, const cv::Mat1f& m);

void imwrite_yml(const std::string& filename, const cv::Mat& image);
cv::Mat imread_yml(const std::string& filename);

cv::Mat1f imread_Mat1f_raw(const std::string& filename);
void imwrite_Mat1f_raw(const std::string& filename, const cv::Mat1f& m);

inline cv::Mat getCvByteImage(int width, int height) { return cv::Mat(height, width, CV_8UC1); }
inline cv::Mat getCvFloatImage(int width, int height) { return cv::Mat(height, width, CV_32FC1); }
inline cv::Mat getCvColorByteImage(int width, int height) { return cv::Mat(height, width, CV_8UC3); }
inline cv::Mat getCvColorFloatImage(int width, int height) { return cv::Mat(height, width, CV_32FC3); }

double overlap_ratio(const cv::Rect_<float>& r1, const cv::Rect_<float>& r2);

inline bool is_yx_in_range(const cv::Mat& image, int y, int x)
{ return (x >= 0) && (y >= 0) && (x < image.cols) && (y < image.rows); }

inline void normalize(cv::Vec3f& v)
{
  v *= float(1.0 / (sqrt(v.dot(v))));
}

inline cv::Vec3b bgr_to_rgb(const cv::Vec3b& v)
{ return cv::Vec3b(v[2], v[1], v[0]); }

void adjustRectToImage(cv::Rect& rect, const cv::Size& image_size);

}

#endif // NTK_OPENCV_UTILS_H