#pragma once

/*--------------------------------

Iwa_TangentFlowFx

Computing a smooth, feature-preserving local edge flow (edge tangent flow, ETF)

Implementation of "Coherent Line Drawing" by H.Kang et al, Proc. NPAR 2007.

----------------------------------*/

#ifndef IWA_TANGENT_FLOW_FX_H

#define IWA_TANGENT_FLOW_FX_H

#include "stdfx.h"

#include "tfxparam.h"

#include <qthread></qthread>

struct double2 {

  double x, y;

  double2(double _x = 0., double _y = 0.) {

    x = _x;

    y = _y;

  }

};

struct int2 {

  int x, y;

  int2 operator+(const int2& other) const {

    return int2{x + other.x, y + other.y};

  }

  int2 operator-(const int2& other) const {

    return int2{x - other.x, y - other.y};

  }

  int len2() const { return x * x + y * y; }

  int2(int _x = 0, int _y = 0) {

    x = _x;

    y = _y;

  }

};

class SobelFilterWorker : public QThread {

  double* m_source_buf;

  double2* m_flow_buf;

  double* m_grad_mag_buf;

  int2* m_offset_buf;

  double m_mag_threshold;

  TDimension m_dim;

  int m_yFrom, m_yTo;

  bool m_hasEmptyVector = false;

public:

  SobelFilterWorker(double* source_buf, double2* flow_buf, double* grad_mag_buf,

                    int2* offset_buf, double mag_threshold, TDimension dim,

                    int yFrom, int yTo)

      : m_source_buf(source_buf)

      , m_flow_buf(flow_buf)

      , m_grad_mag_buf(grad_mag_buf)

      , m_offset_buf(offset_buf)

      , m_mag_threshold(mag_threshold)

      , m_dim(dim)

      , m_yFrom(yFrom)

      , m_yTo(yTo) {}

  void run();

  bool hasEmptyVector() { return m_hasEmptyVector; }

};

class TangentFlowWorker : public QThread {

  double2* m_flow_cur_buf;

  double2* m_flow_new_buf;

  double* m_grad_mag_buf;

  TDimension m_dim;

  int m_kernelRadius;

  int m_yFrom, m_yTo;

public:

  TangentFlowWorker(double2* flow_cur_buf, double2* flow_new_buf,

                    double* grad_mag_buf, TDimension dim, int kernelRadius,

                    int yFrom, int yTo)

      : m_flow_cur_buf(flow_cur_buf)

      , m_flow_new_buf(flow_new_buf)

      , m_grad_mag_buf(grad_mag_buf)

      , m_dim(dim)

      , m_kernelRadius(kernelRadius)

      , m_yFrom(yFrom)

      , m_yTo(yTo) {}

  void run();

};

class Iwa_TangentFlowFx final : public TStandardRasterFx {

  FX_PLUGIN_DECLARATION(Iwa_TangentFlowFx)

protected:

  TRasterFxPort m_source;

  TIntParamP m_iteration;

  TDoubleParamP m_kernelRadius;

  TDoubleParamP m_threshold;

  TBoolParamP m_alignDirection;

  TDoubleParamP m_pivotAngle;

  // obtain source tile brightness, normalizing 0 to 1

  template <typename pixel="" raster,="" typename=""></typename>

  void setSourceTileToBuffer(const RASTER srcRas, double* buf);

  // render vector field in red & green channels

  template <typename pixel="" raster,="" typename=""></typename>

  void setOutputRaster(double2* buf, double* grad_buf, const RASTER dstRas);

  // compute the initial vector field.

  // apply sobel filter, rotate by 90 degrees and normalize.

  // also obtaining gradient magnitude (length of the vector length)

  // empty regions will be filled by using Fast Sweeping Method

  void computeInitialFlow(double* source_buf, double2* flow_buf,

                          double* grad_mag_buf, const TDimension dim,

                          double mag_threshold);

  // 基準の角度に向きを合わせる

  void alignFlowDirection(double2* flow_buf, const TDimension dim,

                          const double2& pivotVec);

public:

  Iwa_TangentFlowFx();

  void doCompute(TTile& tile, double frame,

                 const TRenderSettings& settings) override;

  bool doGetBBox(double frame, TRectD& bBox,

                 const TRenderSettings& info) override;

  bool canHandle(const TRenderSettings& info, double frame) override;

};

#endif