rcv.hpp

#ifndef RCV_HPP
#define RCV_HPP

#include <time.h>
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <type_traits>
#include <typeindex>
#include <stdexcept>
#include <iomanip>
#include <sstream>

#include <iostream>
#include <numeric>

namespace rcv
{



  template<class T> struct type2cv {};
  template<> struct type2cv<uint8_t>  { static const int value = CV_8U;  };
  template<> struct type2cv<int8_t>   { static const int value = CV_8S;  };
  template<> struct type2cv<uint16_t> { static const int value = CV_16U; };
  template<> struct type2cv<int16_t>  { static const int value = CV_16S; };
  template<> struct type2cv<int32_t>  { static const int value = CV_32S; };
  template<> struct type2cv<float>    { static const int value = CV_32F; };
  template<> struct type2cv<double>   { static const int value = CV_64F; };


  std::string type2string(int imgTypeInt)
  {
    int numImgTypes = 35; // 7 base types, with five channel options each (none or C1, ..., C4)

    int enum_ints[] = {
      CV_8U,  CV_8UC1,  CV_8UC2,  CV_8UC3,  CV_8UC4,
      CV_8S,  CV_8SC1,  CV_8SC2,  CV_8SC3,  CV_8SC4,
      CV_16U, CV_16UC1, CV_16UC2, CV_16UC3, CV_16UC4,
      CV_16S, CV_16SC1, CV_16SC2, CV_16SC3, CV_16SC4,
      CV_32S, CV_32SC1, CV_32SC2, CV_32SC3, CV_32SC4,
      CV_32F, CV_32FC1, CV_32FC2, CV_32FC3, CV_32FC4,
      CV_64F, CV_64FC1, CV_64FC2, CV_64FC3, CV_64FC4};

    static std::string const enum_strings[] = {
      "CV_8U",  "CV_8UC1",  "CV_8UC2",  "CV_8UC3",  "CV_8UC4",
      "CV_8S",  "CV_8SC1",  "CV_8SC2",  "CV_8SC3",  "CV_8SC4",
      "CV_16U", "CV_16UC1", "CV_16UC2", "CV_16UC3", "CV_16UC4",
      "CV_16S", "CV_16SC1", "CV_16SC2", "CV_16SC3", "CV_16SC4",
      "CV_32S", "CV_32SC1", "CV_32SC2", "CV_32SC3", "CV_32SC4",
      "CV_32F", "CV_32FC1", "CV_32FC2", "CV_32FC3", "CV_32FC4",
      "CV_64F", "CV_64FC1", "CV_64FC2", "CV_64FC3", "CV_64FC4"};

    for(int i=0; i<numImgTypes; i++)
    {
      if(imgTypeInt == enum_ints[i]) return enum_strings[i];
    }
    return "unknown image type";
  }


  double constexpr white_value(int mat_type)
  {
    return CV_MAT_TYPE(mat_type) == CV_8U ? 255.0 :
      (
       CV_MAT_TYPE(mat_type) == CV_16U ? 65536.0 : 
       (
        1.0
       )
      );
  }


  cv::Mat convert_and_scale(cv::Mat const & image, int const rtype)
  {
    cv::Mat result;
    image.convertTo(result, rtype, white_value(rtype) / white_value(image.type()));
    return result;
  }


#define RCV_DISPATCH(type, function_name, ...)                                               \
  [&]() {                                                                                    \
    switch(CV_MAT_TYPE(type))                                                                \
    {                                                                                        \
      case CV_8U:  return function_name<uint8_t>(__VA_ARGS__);                               \
      case CV_8S:  return function_name<int8_t>(__VA_ARGS__);                                \
      case CV_16U: return function_name<uint16_t>(__VA_ARGS__);                              \
      case CV_16S: return function_name<int16_t>(__VA_ARGS__);                               \
      case CV_32S: return function_name<int32_t>(__VA_ARGS__);                               \
      case CV_32F: return function_name<float>(__VA_ARGS__);                                 \
      case CV_64F: return function_name<double>(__VA_ARGS__);                                \
      default: throw std::runtime_error("Unsupported data type: " + rcv::type2string(type)); \
    };                                                                                       \
  }()
  

#define RCV_DISPATCH_NO_RETURN(type, function_name, ...)                                     \
  [&]() {                                                                                    \
    switch(CV_MAT_TYPE(type))                                                                \
    {                                                                                        \
      case CV_8U:  function_name<uint8_t>(__VA_ARGS__);   break;                             \
      case CV_8S:  function_name<int8_t>(__VA_ARGS__);    break;                             \
      case CV_16U: function_name<uint16_t>(__VA_ARGS__);  break;                             \
      case CV_16S: function_name<int16_t>(__VA_ARGS__);   break;                             \
      case CV_32S: function_name<int32_t>(__VA_ARGS__);   break;                             \
      case CV_32F: function_name<float>(__VA_ARGS__);     break;                             \
      case CV_64F: function_name<double>(__VA_ARGS__);    break;                             \
      default: throw std::runtime_error("Unsupported data type: " + rcv::type2string(type)); \
    };                                                                                       \
  }()

  // ######################################################################

  cv::Mat hcat(cv::Mat left, cv::Mat right, cv::Scalar fill = cv::Scalar(0))
  {
    if(left.type() != right.type())
      throw std::runtime_error("In rcv::hcat: mismatched types between "
          "left (" + rcv::type2string(left.type()) + ") "
          "and right (" + rcv::type2string(right.type()) + ")");

    int const rows = std::max(left.rows, right.rows);
    int const cols = left.cols + right.cols;
    cv::Mat ret(rows, cols, left.type(), fill); 

    cv::Mat left_ret_roi = ret(cv::Rect(0, 0, left.cols, left.rows));
    left.copyTo(left_ret_roi);

    cv::Mat right_ret_roi = ret(cv::Rect(left.cols, 0, right.cols, right.rows));
    right.copyTo(right_ret_roi);

    return ret;
  }

  // ######################################################################

  cv::Mat hcat(std::vector<cv::Mat> const & images, cv::Scalar fill = cv::Scalar(0))
  {
    if(images.empty()) return cv::Mat();
    if(images.size() == 1) return images[0];

    for(size_t i=1; i<images.size(); ++i)
      if(images[i].type() != images[0].type())
        throw std::runtime_error("In rcv::hcat: mismatched types between "
            "images[0] (" + rcv::type2string(images[0].type()) + ") "
            "and images[" + std::to_string(i) + "] (" + rcv::type2string(images[i].type()) + ")");

    int const rows = std::max_element(images.begin(), images.end(), [](cv::Mat a, cv::Mat b) { return a.rows < b.rows; })->rows;
    int cols = std::accumulate(images.begin(), images.end(), 0, [](int n, cv::Mat m) { return n+m.cols; });

    cv::Mat ret(rows, cols, images[0].type(), fill);

    int c = 0;
    for(cv::Mat const & image : images)
    {
      cv::Mat roi = ret(cv::Rect(c, 0, image.cols, image.rows));
      image.copyTo(roi);
      c += image.cols;
    }

    return ret;
  }
 
  // ######################################################################

  cv::Mat vcat(cv::Mat top, cv::Mat bottom, cv::Scalar fill = cv::Scalar(0))
  {
    if(top.type() != bottom.type())
      throw std::runtime_error("In rcv::vcat: mismatched types between "
          "top (" + rcv::type2string(top.type()) + ") "
          "and bottom (" + rcv::type2string(bottom.type()) + ")");

    int const rows = top.rows + bottom.rows;
    int const cols = std::max(top.cols, bottom.cols);
    cv::Mat ret(rows, cols, top.type(), fill); 

    cv::Mat top_ret_roi = ret(cv::Rect(0, 0, top.cols, top.rows));
    top.copyTo(top_ret_roi);

    cv::Mat bottom_ret_roi = ret(cv::Rect(0, top.rows, bottom.cols, bottom.rows));
    bottom.copyTo(bottom_ret_roi);

    return ret;
  }

  // ######################################################################

  cv::Mat vcat(std::vector<cv::Mat> const & images, cv::Scalar fill = cv::Scalar(0))
  {
    if(images.empty()) return cv::Mat();
    if(images.size() == 1) return images[0];

    for(size_t i=1; i<images.size(); ++i)
      if(images[i].type() != images[0].type())
        throw std::runtime_error("In rcv::vcat: mismatched types between "
            "images[0] (" + rcv::type2string(images[0].type()) + ") "
            "and images[" + std::to_string(i) + "] (" + rcv::type2string(images[i].type()) + ")");

    int rows = std::accumulate(images.begin(), images.end(), 0, [](int n, cv::Mat m) { return n+m.rows; });
    int const cols = std::max_element(images.begin(), images.end(), [](cv::Mat a, cv::Mat b) { return a.cols < b.cols; })->cols;

    cv::Mat ret(rows, cols, images[0].type(), fill);

    int r = 0;
    for(cv::Mat const & image : images)
    {
      cv::Mat roi = ret(cv::Rect(0, r, image.cols, image.rows));
      image.copyTo(roi);
      r += image.rows;
    }


    return ret;
  }
  // ######################################################################
  class AutoScaleIndicator { };
  AutoScaleIndicator autoscale;

  template<class Iterator, class MaxScaleValue> 
    auto get_max_value(Iterator const begin, Iterator const end, MaxScaleValue max_value __attribute__ ((unused))) -> 
    typename std::enable_if<std::is_same<MaxScaleValue, AutoScaleIndicator>::value, typename std::remove_reference<decltype(*begin)>::type>::type
    { return *std::max_element(begin, end); }

  template<class Iterator, class MaxScaleValue> 
    auto get_max_value(Iterator const begin  __attribute__ ((unused)), Iterator const end  __attribute__ ((unused)), MaxScaleValue max_value) -> 
    typename std::enable_if<!std::is_same<MaxScaleValue, AutoScaleIndicator>::value, typename std::remove_reference<decltype(*begin)>::type>::type
    { return max_value; }

  template<class Iterator, class MaxScaleValue> 
    auto get_min_value(Iterator const begin, Iterator const end, MaxScaleValue min_value __attribute__ ((unused))) -> 
    typename std::enable_if<std::is_same<MaxScaleValue, AutoScaleIndicator>::value, typename std::remove_reference<decltype(*begin)>::type>::type
    { return *std::min_element(begin, end); }

  template<class Iterator, class MaxScaleValue> 
    auto get_min_value(Iterator const begin  __attribute__ ((unused)), Iterator const end  __attribute__ ((unused)), MaxScaleValue min_value) -> 
    typename std::enable_if<!std::is_same<MaxScaleValue, AutoScaleIndicator>::value, typename std::remove_reference<decltype(*begin)>::type>::type
    { return min_value; }

  // ######################################################################

  template<class Iterator, class MinScaleValue=AutoScaleIndicator, class MaxScaleValue=AutoScaleIndicator>
  cv::Mat plot(Iterator const begin, Iterator const end, cv::Size plot_size,
      MinScaleValue min_value = autoscale, MaxScaleValue max_value = autoscale,
      cv::Scalar line_color=cv::Scalar::all(255), int line_width=1, int image_type=CV_8UC3, bool write_limits = false)
  {
    typedef typename std::remove_reference<decltype(*begin)>::type T;

    cv::Mat plot = cv::Mat::zeros(plot_size, image_type);

    T min_value_ = get_min_value(begin, end, min_value);
    T max_value_ = get_max_value(begin, end, max_value);

    int old_x = 0;
    int old_y = 0;
    size_t const num_values = std::distance(begin, end);
    Iterator it = begin;
    for(size_t i=0; i<num_values; ++i, ++it)
    {
      int x = float(i)/float(num_values) * plot_size.width;
      int y = (float(*it - min_value_) / float(max_value_ - min_value_)) * plot_size.height;
      y = std::max(0, std::min(plot_size.height-1, y));

      cv::line(plot, cv::Point(old_x, plot_size.height - old_y - 1), cv::Point(x, plot_size.height - y - 1), line_color, line_width);
      old_x = x;
      old_y = y;
    }

    if(write_limits)
    {
      auto to_string = [](T value)
      {
        std::ostringstream out;
        out << std::setprecision(2) << std::fixed << value;
        return out.str();
      };

      int baseline;
      auto const font = CV_FONT_HERSHEY_PLAIN;
      float const font_scale = 1.0;
      cv::Size max_loc = cv::getTextSize(to_string(max_value_), font, font_scale, 1, &baseline);
      cv::putText(plot, to_string(max_value_), cv::Point(0, max_loc.height+5), font, font_scale, cv::Scalar::all(255));
      cv::putText(plot, to_string(min_value_), cv::Point(0, plot.rows-5), font, font_scale, cv::Scalar::all(255));
    }
    return plot; 
  }

  // ######################################################################

  class cubehelix
  {
    public:


      struct create
      {
        create() :
          nlev_(256), start_(0.5), rot_(-1.5), gamma_(1.0), hue_(1.2), reverse_(false) 
        { }

        operator cubehelix()
        {
          return cubehelix(nlev_, start_, rot_, gamma_, hue_, reverse_);
        }

        create & nlev(size_t val)  { nlev_ = val; return *this; }

        create & start(float val)  { start_ = val; return *this; }


        create & rot(float val)    { rot_ = val; return *this; }

        create & gamma(float val)  { gamma_ = val; return *this; }

        create & hue(float val)    { hue_ = val; return *this; }


        create & reverse()         { reverse_ = !reverse_; return *this; }

        size_t nlev_;
        float start_, rot_, gamma_, hue_;
        bool reverse_;
      };



      cubehelix(size_t nlev=256, float start=0.5, float rot=-1.5, float gamma=1.0, float hue=1.2, bool reverse=false) :
        nlev(nlev)
    {
      // Set up the parameters
      std::vector<double> fract(nlev);
      std::iota(fract.begin(), fract.end(), 0);
      for(auto & f : fract) f /= (nlev-1.0);

      std::vector<double> angle(nlev);
      std::transform(fract.begin(), fract.end(), angle.begin(),
          [start, rot](double f) { return 2*M_PI * (start/3.0 + 1.0 + rot*f); });

      for(auto & f : fract) f = std::pow(f, gamma);

      std::vector<double> amp(nlev);
      std::transform(fract.begin(), fract.end(), amp.begin(),
          [hue](double f) { return hue * f * (1.0-f)/2.0; });

      // compute the RGB vectors according to main equations
      red_.resize(nlev);
      grn_.resize(nlev);
      blu_.resize(nlev);
      for(size_t i=0; i<nlev; ++i)
      {
        double const s = std::sin(angle[i]);
        double const c = std::cos(angle[i]);
        double const f = fract[i];
        double const a = amp[i];
        red_[i] = std::max(0.0, std::min( 255.0, std::round((f+a*(-0.14861*c + 1.78277*s))*255.0)));
        grn_[i] = std::max(0.0, std::min( 255.0, std::round((f+a*(-0.29227*c - 0.90649*s))*255.0)));
        blu_[i] = std::max(0.0, std::min( 255.0, std::round((f+a*(1.97294*c))*255.0)));
      }


      if(reverse)
      {
        std::reverse(red_.begin(), red_.end());
        std::reverse(grn_.begin(), grn_.end());
        std::reverse(blu_.begin(), blu_.end());
      }
    }

      cv::Mat operator()(cv::Mat const & input)
      {
        if(input.channels() != 1)
          throw std::runtime_error(
              "Too many channels (" + std::to_string(input.channels()) + ") in input image");

        return RCV_DISPATCH(input.type(), process, input);
      }

   private:
      template<class T>
      cv::Mat process(cv::Mat const & input)
      {
        double minv, maxv;
        cv::minMaxLoc(input, &minv, &maxv);

        if(minv == maxv) return cv::Mat::zeros(input.rows, input.cols, CV_8UC3);
        cv::Mat ret(input.size(), CV_8UC3);

        std::transform(input.begin<T>(), input.end<T>(), ret.begin<cv::Vec3b>(),
            [this, minv, maxv](T const v) 
            { 
              size_t const idx = (v - minv) / (maxv - minv) * (nlev - 1);
              return cv::Vec3b(red_[idx], blu_[idx], grn_[idx]);
            });

        return ret;
      }

      size_t const nlev;
      std::vector<uint8_t> red_, blu_, grn_;
  };
}

#endif // RCV_HPP