config.h

#ifndef INCLUDE_GAZE_UTIL_CONFIG_H_
#define INCLUDE_GAZE_UTIL_CONFIG_H_

#include "opencv2/opencv.hpp"
#include "yaml-cpp/yaml.h"


namespace gaze {

namespace util {

YAML::Node get_config();

YAML::Node get_config(int pipeline_step_number);

}  // namespace util

}  // namespace gaze


namespace YAML {

template<>
struct convert<cv::Point3d> {
  static Node encode(const cv::Point3d& rhs) {
    Node node;
    node.push_back(rhs.x);
    node.push_back(rhs.y);
    node.push_back(rhs.z);
    return node;
  }

  static bool decode(const Node& node, cv::Point3d& rhs) {  // NOLINT
    if (!node.IsSequence() || node.size() != 3) {
      return false;
    }
    rhs.x = node[0].as<double>();
    rhs.y = node[1].as<double>();
    rhs.z = node[2].as<double>();
    return true;
  }
};


template<>
struct convert<cv::Vec3d> {
  static Node encode(const cv::Vec3d& rhs) {
    Node node;
    node.push_back(rhs[0]);
    node.push_back(rhs[1]);
    node.push_back(rhs[2]);
    return node;
  }

  static bool decode(const Node& node, cv::Vec3d& rhs) {  // NOLINT
    if (!node.IsSequence() || node.size() != 3) {
      return false;
    }
    rhs[0] = node[0].as<double>();
    rhs[1] = node[1].as<double>();
    rhs[2] = node[2].as<double>();
    return true;
  }
};


template<>
struct convert<cv::Mat> {
  static Node encode(const cv::Mat& rhs) {
    Node node;
    node["rows"] = rhs.rows;
    node["cols"] = rhs.cols;
    node["dt"] = 'd';

    Node data;
    for (auto d = rhs.datastart; d != rhs.dataend; ++d) {
      data.push_back(static_cast<double>(*d));
    }
    node["data"] = data;
    return node;
  }

  static bool decode(const Node& node, cv::Mat& rhs) {  // NOLINT
    if (!node["rows"] || !node["cols"] || !node["dt"] || !node["data"] ||
        !node["data"].IsSequence()) {
      return false;
    }
    char dt = node["dt"].as<char>();
    if (dt != 'd') {
      return false;
    }
    int rows = node["rows"].as<int>();
    int cols = node["cols"].as<int>();
    if (static_cast<decltype(node["data"].size())>(rows * cols) !=
        node["data"].size()) {
      return false;
    }

    double* data = new double[rows * cols];
    for (auto i = decltype(node["data"].size()){0}; i < node["data"].size();
        ++i) {
      data[i] = node["data"][i].as<double>();
    }
    cv::Mat mat = cv::Mat(rows, cols, CV_64F, data);
    mat.copyTo(rhs);
    delete[] data;
    return true;
  }
};

}  // namespace YAML

#endif  // INCLUDE_GAZE_UTIL_CONFIG_H_