#include <string>
#include <vector>
#include <limits>     // std::numeric_limits
#include <stdexcept>  // std::domain_error()
#include <algorithm>  // std::max(),std::rotate()
#include "igs_resource_multithread.h"
#include "igs_ifx_common.h"
#include "igs_fog.h"
#include "igs_attenuation_distribution.cpp"
 
namespace {  //---------------------------------------------------------
void sl_track_render_dark_(
    double *in_out /* RorGorBorA元かつ結果値(0...1) */
    ,
    const double *alpha /* Alpha元値(0...1) */
    ,
    const int width /* 画像幅 */
 
    ,
    double **lens /* lensの外周の左開始位置ポインタ配列 */
    ,
    double **track /* 参照画外周の左開始位置ポインタ配列 */
    ,
    const int *sizes /* lens及び参照scanline毎の長さ配列 */
    ,
    const int size /* lens及び参照scanline数 */
 
    ,
    const double power = 1.0 /* 0無  0...1散暗  1強暗  1...2最強暗 */
    ) {
  for (int xx = 0; xx < width; ++xx) { /* 画像のScanlineループ */
    /* Alphaがないか、Alpha値ゼロより大きいと処理しRGB変化 */
    if ((0 == alpha) || (0.0 < alpha[xx])) {
      double total = 0.0;
      for (int y2 = 0; y2 < size; ++y2) {
        for (int x2 = 0; x2 < sizes[y2]; ++x2) {
          if (track[y2][x2] < in_out[xx]) {
            /* より暗いpixelにのみ暗さの影響を受ける */
            total += lens[y2][x2] * track[y2][x2];
          } else {
            /* より明るいpixelから影響を受けないようにする */
            total += lens[y2][x2] * in_out[xx];
          }
        }
      }
      /* !!!lensによる値の蓄積が0-1とならなければならない!!! */
      /* 変化を、強弱を付けて、AlphaでMaskし、元値に加える */
      total -= in_out[xx]; /* 変化を */
      total *= power;      /* 強弱を付けて */
      if ((0 != alpha) && (alpha[xx] < 1.0)) {
        total *= alpha[xx]; /* AlphaでMaskし */
      }
      total += in_out[xx]; /* 元値に加える */
      /* 0-1にclampし保存 */
      in_out[xx] = ((total < 0.0) ? 0.0 : ((1.0 < total) ? 1.0 : total));
    }
    for (int y2 = 0; y2 < size; ++y2) {
      if (0 < sizes[y2]) {
        ++track[y2];
      } /* 次位置へずらしとく */
    }
  }
}
void sl_track_render_light_(  // = fog = default
    double *in_out            /* RorGorBorA元かつ結果値(0...1) */
    ,
    const double *alpha /* Alpha元値(0...1) */
    ,
    const int width /* 画像幅 */
 
    ,
    double **lens /* lensの外周の左開始位置ポインタ配列 */
    ,
    double **track /* 参照画外周の左開始位置ポインタ配列 */
    ,
    const int *sizes /* lens及び参照scanline毎の長さ配列 */
    ,
    const int size /* lens及び参照scanline数 */
 
    ,
    const double power = 1.0 /* 0無  0...1散光  1強光  1...2最強光 */
    ) {
  for (int xx = 0; xx < width; ++xx) { /* 画像のScanlineループ */
    /* Alphaがないか、Alpha値ゼロより大きいと処理しRGB変化 */
    if ((0 == alpha) || (0.0 < alpha[xx])) {
      double total = 0.0;
      for (int y2 = 0; y2 < size; ++y2) {
        for (int x2 = 0; x2 < sizes[y2]; ++x2) {
          if (in_out[xx] < track[y2][x2]) {
            /* より明るいpixelにのみ明るさの影響を受ける */
            total += lens[y2][x2] * track[y2][x2];
          } else {
            /* より暗いpixelから影響を受けないようにする */
            total += lens[y2][x2] * in_out[xx];
          }
        }
      }
      /* !!!lensによる値の蓄積が0-1とならなければならない!!! */
      /* 変化を、強弱を付けて、AlphaでMaskし、元値に加える */
      total -= in_out[xx]; /* 変化を */
      total *= power;      /* 強弱を付けて */
      if ((0 != alpha) && (alpha[xx] < 1.0)) {
        total *= alpha[xx]; /* AlphaでMaskし */
      }
      total += in_out[xx]; /* 元値に加える */
      /* 0-1にclampし保存 */
      in_out[xx] = ((total < 0.0) ? 0.0 : ((1.0 < total) ? 1.0 : total));
    }
    for (int y2 = 0; y2 < size; ++y2) {
      if (0 < sizes[y2]) {
        ++track[y2];
      } /* 次位置へずらしとく */
    }
  }
}
void sl_track_render_threshold_(
    double *in_out /* RorGorBorA元かつ結果値(0...1) */
    ,
    const double *alpha /* Alpha元値(0...1) */
    ,
    const int width /* 画像幅 */
 
    ,
    double **lens /* lensの外周の左開始位置ポインタ配列 */
    ,
    double **track /* 参照画外周の左開始位置ポインタ配列 */
    ,
    double **thres /* 影響画外周の左開始位置ポインタ配列 */
    ,
    const int *sizes /* lens及び参照scanline毎の長さ配列 */
    ,
    const int size /* lens及び参照scanline数 */
 
    ,
    const double power = 1.0 /* 0無  0...1散光  1強光  1...2最強光 */
    ,
    const double threshold_min = 0.0 /* 0Cut無 0...1部分 1.01全Cut */
    ) {
  for (int xx = 0; xx < width; ++xx) { /* 画像のScanlineループ */
    /* Alphaがないか、Alpha値ゼロより大きいと処理しRGB変化 */
    if ((0 == alpha) || (0.0 < alpha[xx])) {
      double total = 0.0;
      for (int y2 = 0; y2 < size; ++y2) {
        for (int x2 = 0; x2 < sizes[y2]; ++x2) {
          if ((in_out[xx] < track[y2][x2]) &&
              (threshold_min <= thres[y2][x2])) {
            /* より明るいpixelにのみ明るさの影響を受ける */
            total += lens[y2][x2] * track[y2][x2];
          } else {
            /* より暗いpixelから影響を受けないようにする */
            total += lens[y2][x2] * in_out[xx];
          }
        }
      }
      /* !!!lensによる値の蓄積が0-1とならなければならない!!! */
      /* 変化を、強弱を付けて、AlphaでMaskし、元値に加える */
      total -= in_out[xx]; /* 変化を */
      total *= power;      /* 強弱を付けて */
      if ((0 != alpha) && (alpha[xx] < 1.0)) {
        total *= alpha[xx]; /* AlphaでMaskし */
      }
      total += in_out[xx]; /* 元値に加える */
      /* 0-1にclampし保存 */
      in_out[xx] = ((total < 0.0) ? 0.0 : ((1.0 < total) ? 1.0 : total));
    }
    for (int y2 = 0; y2 < size; ++y2) {
      if (0 < sizes[y2]) {
        ++track[y2]; /* 次の画像位置へずらしとく */
        ++thres[y2]; /* 次の画像位置へずらしとく */
      }
    }
  }
}
void sl_track_render_thrminmax_(
    double *in_out /* RorGorBorA元かつ結果値(0...1) */
    ,
    const double *alpha /* Alpha元値(0...1) */
    ,
    const int width /* 画像幅 */
 
    ,
    double **lens /* lensの外周の左開始位置ポインタ配列 */
    ,
    double **track /* 参照画外周の左開始位置ポインタ配列 */
    ,
    double **thres /* 影響画外周の左開始位置ポインタ配列 */
    ,
    const int *sizes /* lens及び参照scanline毎の長さ配列 */
    ,
    const int size /* lens及び参照scanline数 */
 
    ,
    const double power = 1.0 /* 0無  0...1散光  1強光  1...2最強光 */
    ,
    const double threshold_min = 0.0 /* 0Cut無 0...1部分 1.01全Cut */
    ,
    const double threshold_max = 0.0 /* 0Cut無 0...1部分 1.01全Cut */
    ) {
  const double thr_range = threshold_max - threshold_min;
  for (int xx = 0; xx < width; ++xx) { /* 画像のScanlineループ */
    /* Alphaがないか、Alpha値ゼロより大きいと処理しRGB変化 */
    if ((0 == alpha) || (0.0 < alpha[xx])) {
      double total = 0.0;
      for (int y2 = 0; y2 < size; ++y2) {
        for (int x2 = 0; x2 < sizes[y2]; ++x2) {
          if ((in_out[xx] < track[y2][x2]) &&
              (threshold_min <= thres[y2][x2])) {
            /* より明るくかつminより大きい値のpixelにのみ
明るさの影響を受ける */
            if (thres[y2][x2] < threshold_max) {
              /* maxよりは小さい値のpixelは比で影響する */
              total += lens[y2][x2] *
                       (in_out[xx] +
                        (track[y2][x2] - in_out[xx]) *
                            (thres[y2][x2] - threshold_min) / thr_range);
            } else {
              /* maxより大きい値のpixelは明るさ影響を受ける */
              total += lens[y2][x2] * track[y2][x2];
            }
          } else {
            /* より暗いか、minより小さい値のpixelから
影響を受けないようにする */
            total += lens[y2][x2] * in_out[xx];
          }
        }
      }
      /* !!!lensによる値の蓄積が0-1とならなければならない!!! */
      /* 変化を、強弱を付けて、AlphaでMaskし、元値に加える */
      total -= in_out[xx]; /* 変化を */
      total *= power;      /* 強弱を付けて */
      if ((0 != alpha) && (alpha[xx] < 1.0)) {
        total *= alpha[xx]; /* AlphaでMaskし */
      }
      total += in_out[xx]; /* 元値に加える */
      /* 0-1にclampし保存 */
      in_out[xx] = ((total < 0.0) ? 0.0 : ((1.0 < total) ? 1.0 : total));
    }
    for (int y2 = 0; y2 < size; ++y2) {
      if (0 < sizes[y2]) {
        ++track[y2]; /* 次の画像位置へずらしとく */
        ++thres[y2]; /* 次の画像位置へずらしとく */
      }
    }
  }
}
}
namespace {  //---------------------------------------------------------
void sl_track_resize_(const int odd_diameter, const int width,
                      std::vector<std::vector<double>> &pixe_tracks,
                      const bool thr_sw,
                      std::vector<std::vector<double>> &thre_tracks,
                      std::vector<double *> &pixe_starts,
                      std::vector<double *> &thre_starts,
                      std::vector<double> &result,
                      std::vector<double> &alpha_ref) {
  pixe_tracks.resize(odd_diameter);
  for (int yy = 0; yy < odd_diameter; ++yy) {
    pixe_tracks.at(yy).resize(width + odd_diameter - 1);
  }
  if (thr_sw) {
    thre_tracks.resize(odd_diameter);
    for (int yy = 0; yy < odd_diameter; ++yy) {
      thre_tracks.at(yy).resize(width + odd_diameter - 1);
    }
  }
  pixe_starts.resize(odd_diameter);
  thre_starts.resize(odd_diameter);
  result.resize(width);
  alpha_ref.clear(); /* 今はクリア!!!あとで使うとき確保!!! */
}
void sl_track_render_(
    // std::vector< std::vector<double> >&lens_matrix
    std::vector<int> &lens_offsets, std::vector<double *> &lens_starts,
    std::vector<int> &lens_sizes
 
    ,
    std::vector<std::vector<double>> &pixe_tracks,
    std::vector<std::vector<double>> &thre_tracks,
    const std::vector<double> &alpha_ref, std::vector<double> &result,
    std::vector<double *> &pixe_starts, std::vector<double *> &thre_starts
 
    ,
    const double power, const double threshold_min,
    const double threshold_max) {
  /*--- scanline初期位置 ---*/
  for (unsigned int yy = 0; yy < pixe_starts.size(); ++yy) {
    if (lens_offsets.at(yy) < 0) {
      pixe_starts.at(yy) = 0;
    } else {
      pixe_starts.at(yy) = &pixe_tracks.at(yy).at(lens_offsets.at(yy));
    }
  }
  if (0 < thre_tracks.size()) {
    for (unsigned int yy = 0; yy < thre_starts.size(); ++yy) {
      if (lens_offsets.at(yy) < 0) {
        thre_starts.at(yy) = 0;
      } else {
        thre_starts.at(yy) = &thre_tracks.at(yy).at(lens_offsets.at(yy));
      }
    }
  }
  /*--- 自分より暗いpixelから収光 ---*/
  if (power < 0.0) {
    sl_track_render_dark_(&result.at(0),
                          ((0 < alpha_ref.size()) ? &alpha_ref.at(0) : 0),
                          static_cast<int>(result.size())
 
                              ,
                          &lens_starts.at(0), &pixe_starts.at(0),
                          &lens_sizes.at(0), static_cast<int>(lens_sizes.size())
 
                                                 ,
                          -power);
    return;
  }
  /*--- 自分より明るいpixelから収光し光量によってfogが変化 ---*/
  if ((0.0 < threshold_min) || (0.0 < threshold_max)) {
    if (threshold_min < threshold_max) {
      sl_track_render_thrminmax_(
          &result.at(0), ((0 < alpha_ref.size()) ? &alpha_ref.at(0) : 0),
          static_cast<int>(result.size())
 
              ,
          &lens_starts.at(0), &pixe_starts.at(0), &thre_starts.at(0),
          &lens_sizes.at(0), static_cast<int>(lens_sizes.size())
 
                                 ,
          power, threshold_min, threshold_max);
      return;
    } else {
      /*--- 自分より明るいpixelから収光し、
ある光量以上からいきなりfogがかかる ---*/
      sl_track_render_threshold_(
          &result.at(0), ((0 < alpha_ref.size()) ? &alpha_ref.at(0) : 0),
          static_cast<int>(result.size())
 
              ,
          &lens_starts.at(0), &pixe_starts.at(0), &thre_starts.at(0),
          &lens_sizes.at(0), static_cast<int>(lens_sizes.size())
 
                                 ,
          power, threshold_min);
      return;
    }
  }
  /*--- 自分より明るいpixelから収光 ---*/
  sl_track_render_light_(&result.at(0),
                         ((0 < alpha_ref.size()) ? &alpha_ref.at(0) : 0),
                         static_cast<int>(result.size())
 
                             ,
                         &lens_starts.at(0), &pixe_starts.at(0),
                         &lens_sizes.at(0), static_cast<int>(lens_sizes.size())
 
                                                ,
                         power);
}
void sl_track_shift_(std::vector<std::vector<double>> &pixe_tracks,
                     std::vector<std::vector<double>> &thre_tracks) {
  std::rotate(pixe_tracks.begin(), pixe_tracks.end() - 1, pixe_tracks.end());
  if (0 < thre_tracks.size()) {
    std::rotate(thre_tracks.begin(), thre_tracks.end() - 1, thre_tracks.end());
  }
}
void sl_track_clear_(std::vector<std::vector<double>> &pixe_tracks,
                     std::vector<std::vector<double>> &thre_tracks,
                     std::vector<double *> &pixe_starts,
                     std::vector<double *> &thre_starts,
                     std::vector<double> &result,
                     std::vector<double> &alpha_ref) {
  if (!alpha_ref.empty()) {
    alpha_ref.clear();
  }
  if (!result.empty()) {
    result.clear();
  }
  if (!thre_starts.empty()) {
    thre_starts.clear();
  }
  if (!pixe_starts.empty()) {
    pixe_starts.clear();
  }
  if (!thre_tracks.empty()) {
    thre_tracks.clear();
  }
  if (!pixe_tracks.empty()) {
    pixe_tracks.clear();
  }
}
}
namespace {  //--------------------------------------------------------
template <class T>
void rgb_to_lightness_image_(const T *image, const int height, const int width,
                             const int channels, double *lightness) {
  const double val_max = static_cast<double>(std::numeric_limits<T>::max());
  for (int yy = 0; yy < height; ++yy) {
    for (int xx = 0; xx < width; ++xx, image += channels, ++lightness) {
      if (1 == channels) {
        *lightness = static_cast<double>(image[0]) / val_max;
      } else {
        const double red = static_cast<double>(image[0]) / val_max;
        const double gre = static_cast<double>(image[1]) / val_max;
        const double blu = static_cast<double>(image[2]) / val_max;
        /* rgb --> hls のl(明度(lightness))のみの計算 */
        *lightness = (std::max(std::max(red, gre), blu) +
                      std::min(std::min(red, gre), blu)) /
                     2.0;
      }
    }
  }
}
}
namespace {  //--------------------------------------------------------
/*
        画像配列の高さ位置を、実際の範囲内にclampし、scanlineの先頭を返す
        TP is 'unsigned char *' or 'unsigned short *'
  */
template <class TP>
TP sl_top_clamped_in_h_(TP sl, const int height, const int width,
                        const int channels, const int yy) {
  if (height <= yy) {
    return sl + (channels * width * (height - 1));
  } else if (yy < 0) {
    return sl;
  }
  return sl + (channels * width * yy);
}
/*
        trackの左右の余白を画像の端の色で塗りつぶす
  */
template <class T>
void paint_margin_(const int width, const int margin, std::vector<T> &track) {
  if (width <= (margin * 2)) {
    return;
  } /* 余白太すぎ */
 
  for (int xx = 0; xx < margin; ++xx) {
    track.at(xx) = track.at(margin); /* 始点側の余白を塗る */
    track.at(track.size() - 1 - xx) =
        track.at(track.size() - margin - 1); /* 終端側の余白を塗る */
  }
}
}
namespace {  //--------------------------------------------------------
/*
        T is 'unsigned char' or 'unsigned short'
        alphaは先に処理して結果(out_image_array)に入れ、
                その後rgbのために参照する
  */
template <class T>
void get_first_sl_ch_(
    const T *in_image_array,
    const T *out_image_array /* 処理結果alpha値の参照のため必要 */
    ,
    const double *ref_thres_array /* threshold値の参照のため必要 */
    ,
    const int hh, const int ww, const int ch, const int yy, const int zz,
    const int margin, std::vector<std::vector<double>> &pixe_tracks,
    std::vector<std::vector<double>> &thre_tracks, std::vector<double> &result,
    std::vector<double> &alpha_ref) {
  const double val_max = static_cast<double>(std::numeric_limits<T>::max());
  /*--- 入力画像を(マージン含めた1scanline分)得る ---*/
  {
    int yp = -margin + yy;
    int ii = margin * 2;
    for (; yp <= margin + yy; ++yp, --ii) {
      const T *ss = sl_top_clamped_in_h_(in_image_array, hh, ww, ch, yp) + zz;
      std::vector<double> &track = pixe_tracks.at(ii);
      for (int xx = 0; xx < ww; ++xx) {
        track.at(margin + xx) = static_cast<double>(ss[xx * ch]) / val_max;
      }
      paint_margin_(ww, margin, track);
    }
  }
  /*--- (閾値として)参照する画像を(マージン含めた1scanline分)得る -*/
  if ((0 != ref_thres_array) && (0 < thre_tracks.size())) {
    int yp = -margin + yy;
    int ii = margin * 2;
    for (; yp <= margin + yy; ++yp, --ii) {
      const double *ss = sl_top_clamped_in_h_(ref_thres_array, hh, ww, 1, yp);
      std::vector<double> &track = thre_tracks.at(ii);
      for (int xx = 0; xx < ww; ++xx) {
        track.at(margin + xx) = ss[xx * 1];
      }
      paint_margin_(ww, margin, track);
    }
  }
  /*--- 入力画像を保存画像エリアに1scanline分入れる ---*/
  const T *ss = sl_top_clamped_in_h_(in_image_array, hh, ww, ch, yy) + zz;
  for (int xx = 0; xx < ww; ++xx) {
    result.at(xx) = static_cast<double>(ss[xx * ch]) / val_max;
  }
  /*--- 処理結果としてのalpha画像エリアを1scanline分入れる ---*/
  if ((alpha_ref.size() <= 0) || (ch < 4)) {
    return;
  }
  const T *dd = sl_top_clamped_in_h_(out_image_array, hh, ww, ch, yy) + 3;
  for (int xx = 0; xx < ww; ++xx) {
    alpha_ref.at(xx) = static_cast<double>(dd[xx * ch]) / val_max;
  }
}
template <class T>
void get_next_sl_ch_(
    const T *in_image_array,
    const T *out_image_array /* 処理結果alpha値の参照のため必要 */
    ,
    const double *ref_thres_array /* threshold値の参照のため必要 */
    ,
    const int hh, const int ww, const int ch, const int yy, const int zz,
    const int margin, std::vector<std::vector<double>> &pixe_tracks,
    std::vector<std::vector<double>> &thre_tracks, std::vector<double> &result,
    std::vector<double> &alpha_ref) {
  const double val_max = static_cast<double>(std::numeric_limits<T>::max());
  /*--- 入力画像を(1scanline分)得る ---*/
  {
    const T *mm =
        sl_top_clamped_in_h_(in_image_array, hh, ww, ch, yy + margin) + zz;
    std::vector<double> &track = pixe_tracks.at(0);
    for (int xx = 0; xx < ww; ++xx) {
      track.at(margin + xx) = static_cast<double>(mm[xx * ch]) / val_max;
    }
    paint_margin_(ww, margin, track);
  }
  /*--- (閾値として)参照する画像を(1scanline分)得る --*/
  if ((0 != ref_thres_array) && (0 < thre_tracks.size())) {
    const double *mm =
        sl_top_clamped_in_h_(ref_thres_array, hh, ww, 1, yy + margin);
    std::vector<double> &track = thre_tracks.at(0);
    for (int xx = 0; xx < ww; ++xx) {
      track.at(margin + xx) = mm[xx * 1];
    }
    paint_margin_(ww, margin, track);
  }
  /*--- 入力画像を保存画像エリアに1scanline分入れる ---*/
  const T *ss = sl_top_clamped_in_h_(in_image_array, hh, ww, ch, yy) + zz;
  for (int xx = 0; xx < ww; ++xx) {
    result.at(xx) = static_cast<double>(ss[xx * ch]) / val_max;
  }
  /*--- 処理結果としてのalpha画像エリアを1scanline分入れる ---*/
  if ((alpha_ref.size() <= 0) || (ch < 4)) {
    return;
  }
  const T *dd = sl_top_clamped_in_h_(out_image_array, hh, ww, ch, yy) + 3;
  for (int xx = 0; xx < ww; ++xx) {
    alpha_ref.at(xx) = static_cast<double>(dd[xx * ch]) / val_max;
  }
}
template <class TP>
void copy_sl_ch_(const TP in_image_array, TP out_image_array, const int hh,
                 const int ww, const int ch, const int yy, const int zz) {
  const TP ss = sl_top_clamped_in_h_(in_image_array, hh, ww, ch, yy) + zz;
  TP dd       = sl_top_clamped_in_h_(out_image_array, hh, ww, ch, yy) + zz;
  for (int xx = 0; xx < ww; ++xx) {
    dd[ch * xx] = ss[ch * xx];
  }
}
template <class T>
void put_sl_ch_(std::vector<double> &result, const int hh, const int ww,
                const int ch, const int yy, const int zz, T *out_image_array) {
  const double val_max = static_cast<double>(std::numeric_limits<T>::max());
  T *dd = sl_top_clamped_in_h_(out_image_array, hh, ww, ch, yy) + zz;
  for (int xx = 0; xx < ww; ++xx) {
    dd[ch * xx] = static_cast<T>(result.at(xx) * (val_max + 0.999999));
  }
}
}
namespace {  //--------------------------------------------------------
template <class T>
class one_thread_ final
    : public igs::resource::thread_execute_interface { /* thread単位の実行設定
                                                    */
public:
  one_thread_() {}
  void setup(T in_image, T out_image, double *ref_thresh
 
             ,
             const int height, const int width, const int channels
 
             ,
             const int y_begin, const int y_end
 
             // , std::vector< std::vector<double> > *lens_matrix_p
             ,
             std::vector<int> *lens_offsets_p,
             std::vector<double *> *lens_starts_p,
             std::vector<int> *lens_sizes_p
 
             ,
             const double power, const double threshold_min,
             const double threshold_max, const bool alpha_rendering_sw) {
    this->in_image_   = in_image;
    this->out_image_  = out_image;
    this->ref_thresh_ = ref_thresh;
 
    this->height_   = height;
    this->width_    = width;
    this->channels_ = channels;
 
    this->y_begin_ = y_begin;
    this->y_end_   = y_end;
 
    // this->lens_matrix_p_ = lens_matrix_p;
    this->lens_offsets_p_ = lens_offsets_p;
    this->lens_starts_p_  = lens_starts_p;
    this->lens_sizes_p_   = lens_sizes_p;
 
    this->power_              = power;
    this->threshold_min_      = threshold_min;
    this->threshold_max_      = threshold_max;
    this->alpha_rendering_sw_ = alpha_rendering_sw;
 
    sl_track_resize_(static_cast<int>(this->lens_offsets_p_->size()),
                     this->width_, this->pixe_tracks_,
                     ((0 == ref_thresh) ? false : true), this->thre_tracks_,
                     this->pixe_starts_, this->thre_starts_, this->result_,
                     this->alpha_ref_);
  }
  void run(void) override {
    bool rgb_rendering_sw   = true;
    bool alpha_rendering_sw = this->alpha_rendering_sw_;
    if (this->pixe_tracks_.size() <= 1) {
      rgb_rendering_sw   = false;
      alpha_rendering_sw = false;
    }  // not render,then copy
 
    /* first scanline-->next scanlineで処理するので
かならすchannel毎にまとめてループする */
 
    int yy;
    if (igs::image::rgba::siz == this->channels_) {
      using namespace igs::image::rgba;
      for (yy = this->y_begin_; yy <= this->y_end_; ++yy) {
        this->rendering_sl_ch_(yy, alp, alpha_rendering_sw);
      }
      /* alpha処理後にalpha参照用設定をする */
      this->alpha_ref_.resize(this->width_);
 
      for (yy = this->y_begin_; yy <= this->y_end_; ++yy) {
        this->rendering_sl_ch_(yy, blu, rgb_rendering_sw);
      }
      for (yy = this->y_begin_; yy <= this->y_end_; ++yy) {
        this->rendering_sl_ch_(yy, gre, rgb_rendering_sw);
      }
      for (yy = this->y_begin_; yy <= this->y_end_; ++yy) {
        this->rendering_sl_ch_(yy, red, rgb_rendering_sw);
      }
    } else if (igs::image::rgb::siz == this->channels_) {
      using namespace igs::image::rgb;
      for (yy = this->y_begin_; yy <= this->y_end_; ++yy) {
        this->rendering_sl_ch_(yy, blu, rgb_rendering_sw);
      }
      for (yy = this->y_begin_; yy <= this->y_end_; ++yy) {
        this->rendering_sl_ch_(yy, gre, rgb_rendering_sw);
      }
      for (yy = this->y_begin_; yy <= this->y_end_; ++yy) {
        this->rendering_sl_ch_(yy, red, rgb_rendering_sw);
      }
    } else if (1 == this->channels_) { /* grayscale */
      for (yy = this->y_begin_; yy <= this->y_end_; ++yy) {
        this->rendering_sl_ch_(yy, 0, rgb_rendering_sw);
      }
    }
  }
  void clear(void) {
    sl_track_clear_(this->pixe_tracks_, this->thre_tracks_, this->pixe_starts_,
                    this->thre_starts_, this->result_, this->alpha_ref_);
  }
 
private:
  T in_image_;
  T out_image_;
  double *ref_thresh_;
 
  int height_;
  int width_;
  int channels_;
 
  int y_begin_;
  int y_end_;
 
  // std::vector< std::vector<double> > *lens_matrix_p_;
  std::vector<int> *lens_offsets_p_;
  std::vector<double *> *lens_starts_p_;
  std::vector<int> *lens_sizes_p_;
 
  double power_;
  double threshold_min_;
  double threshold_max_;
  bool alpha_rendering_sw_;
 
  std::vector<std::vector<double>> pixe_tracks_;
  std::vector<std::vector<double>> thre_tracks_;
  std::vector<double *> pixe_starts_;
  std::vector<double *> thre_starts_;
  std::vector<double> result_;
  std::vector<double> alpha_ref_;
 
  void rendering_sl_ch_(int yy, int zz, bool rendering_sw) {
    if (!rendering_sw) {
      copy_sl_ch_(this->in_image_, this->out_image_, this->height_,
                  this->width_, this->channels_, yy, zz);
      return;
    }
    if (yy == this->y_begin_) {
      get_first_sl_ch_(this->in_image_, this->out_image_, this->ref_thresh_,
                       this->height_, this->width_, this->channels_, yy, zz,
                       static_cast<int>(this->pixe_tracks_.size() / 2),
                       this->pixe_tracks_, this->thre_tracks_, this->result_,
                       this->alpha_ref_);
    } else {
      sl_track_shift_(this->pixe_tracks_, this->thre_tracks_);
      get_next_sl_ch_(this->in_image_, this->out_image_, this->ref_thresh_,
                      this->height_, this->width_, this->channels_, yy, zz,
                      static_cast<int>(this->pixe_tracks_.size() / 2),
                      this->pixe_tracks_, this->thre_tracks_, this->result_,
                      this->alpha_ref_);
    }
    sl_track_render_(
        //  *(this->lens_matrix_p_)
        *(this->lens_offsets_p_), *(this->lens_starts_p_),
        *(this->lens_sizes_p_)
 
            ,
        this->pixe_tracks_, this->thre_tracks_, this->alpha_ref_
 
        ,
        this->result_
 
        ,
        this->pixe_starts_, this->thre_starts_
 
        ,
        this->power_, this->threshold_min_, this->threshold_max_);
    put_sl_ch_(this->result_, this->height_, this->width_, this->channels_, yy,
               zz, this->out_image_);
  }
};
}
namespace {  //--------------------------------------------------------
template <class T>
class multi_thread_ {
public:
  multi_thread_(T in_image, T out_image, double *ref_thres, const int height,
                const int width, const int channels
 
                ,
                const int number_of_thread  // 1 ... INT_MAX
 
                ,
                const double radius  // 25.0(0...100(DOUBLE_MAX))
                ,
                const double curve  // 1.00(0.01 ... 100)
                ,
                const int polygon_number  // 2(2 ... 16(INT_MAX))
                ,
                const double degree  // 0(0 ... DOUBLE_MAX)
 
                ,
                const double power  // 1.00(-2.00 ... 2.00)
                ,
                const double threshold_min  // 0.00(0.00 ... 1.01)
                ,
                const double threshold_max  // 0.00(0.00 ... 1.01)
                ,
                const bool alpha_rendering_sw  // false(true,false)
                ) {
    /*--------------スレッド数の設定--------------------*/
    int thread_num = number_of_thread;
    if ((thread_num < 1) || (height < thread_num)) {
      thread_num = 1;
    } /* ゼロ以下か、高さより多い */
    /*--------------メモリ確保--------------------------*/
    int odd_diameter = 0;
    attenuation_distribution_(this->lens_matrix_, this->lens_offsets_,
                              this->lens_starts_, this->lens_sizes_,
                              odd_diameter,
                              radius /* 直径(radiusの2倍)1以下ならエラーthrow */
                              ,
                              curve /* curveがゼロならエラーthrow */
                              ,
                              polygon_number, degree);
    this->threads_.resize(thread_num);
    /*-------スレッド毎の処理指定-----------------------*/
    int h_sub = height / thread_num;
    if (0 != (height % thread_num)) {
      ++h_sub; /* 割り切れないときは一つ増やす */
    }
    int yy = 0;
    for (int ii = 0; ii < thread_num; ++ii, yy += h_sub) {
      /*
      5 h_scanline,4 thread --> h_count is 2
      thread	1	2	3	4
      h_count	2	2	1	0
      */
      if (height < (yy + h_sub)) {
        h_sub = height - yy;
      }
      this->threads_.at(ii).setup(
          in_image, out_image, ref_thres
 
          ,
          height, width, channels
 
          ,
          yy, yy + h_sub - 1
 
          // , &(this->lens_matrix_)
          ,
          &(this->lens_offsets_), &(this->lens_starts_), &(this->lens_sizes_)
 
                                                             ,
          power, threshold_min, threshold_max, alpha_rendering_sw);
    }
    /*------スレッド毎のスレッド指定------*/
    for (int ii = 0; ii < thread_num; ++ii) {
      this->mthread_.add(&(this->threads_.at(ii)));
    }
  }
  void run(void) { this->mthread_.run(); }
  void clear() {
    this->mthread_.clear();
    this->threads_.clear();
    this->lens_sizes_.clear();
    this->lens_starts_.clear();
    this->lens_offsets_.clear();
    this->lens_matrix_.clear();
  }
 
private:
  std::vector<std::vector<double>> lens_matrix_;
  std::vector<int> lens_offsets_;
  std::vector<double *> lens_starts_;
  std::vector<int> lens_sizes_;
  std::vector<one_thread_<T>> threads_;
  igs::resource::multithread mthread_;
};
}
//--------------------------------------------------------------------
/* パラメータの指定を見て、画像に変化の無い場合、
呼び出し側で、fog処理するか判断する。fog処理しないときの処理も忘れずに */
bool igs::fog::have_change(const double radius  // 25.0(0 ... 100(DOUBLE_MAX))
                           ,
                           const double power  // 1.00(-2.00 ... 2.00)
                           ,
                           const double threshold_min  // 0.00(0.00 ... 1.01)
                           ) {
  /* 収光(変化)しない
          場合1  直径が1以下
          場合2  powerがゼロ(マイナスは有効としている)
          場合3  powerがプラスで、threshold_minが1よりも大きい
  */
  if ((static_cast<int>(ceil(radius * 2.0)) <= 1) || (0.0 == power) ||
      ((0.0 < power) && (1.0 < threshold_min))) {
    return false;
  }
  return true;
}
/* fog処理する */
void igs::fog::convert(void *in  // no margin
                       ,
                       void *out  // no margin
                       ,
                       double *buffer  // no margin
 
                       ,
                       const int height, const int width, const int channels,
                       const int bits
 
                       ,
                       const int number_of_thread  // 1 ... INT_MAX
 
                       ,
                       const double radius  // 25.0(0 ... 100(DOUBLE_MAX))
                       ,
                       const double curve  // 1.00(0.01 ... 100)
                       ,
                       const int polygon_number  // 2(2 ... 16(INT_MAX))
                       ,
                       const double degree  // 0(0 ... DOUBLE_MAX)
 
                       ,
                       const double power  // 1.00(-2.00 ... 2.00)
                       ,
                       const double threshold_min  // 0.00(0.00 ... 1.01)
                       ,
                       const double threshold_max  // 0.00(0.00 ... 1.01)
                       ,
                       const bool alpha_rendering_sw  // false(true,false)
                       ) {
  if ((igs::image::rgba::siz != channels) &&
      (igs::image::rgb::siz != channels) && (1 != channels) /* grayscale */
      ) {
    throw std::domain_error("Bad channels,Not rgba/rgb/grayscale");
  }
 
  if (std::numeric_limits<unsigned char>::digits == bits) {
    if (0 != buffer) {
      rgb_to_lightness_image_(static_cast<const unsigned char *>(in), height,
                              width, channels, buffer);
    }
    multi_thread_<unsigned char *> mthread(
        static_cast<unsigned char *>(in), static_cast<unsigned char *>(out),
        buffer, height, width, channels, number_of_thread, radius, curve,
        polygon_number, degree, power, threshold_min, threshold_max,
        alpha_rendering_sw);
    mthread.run();
    mthread.clear();
  } else if (std::numeric_limits<unsigned short>::digits == bits) {
    if (0 != buffer) {
      rgb_to_lightness_image_(static_cast<const unsigned short *>(in), height,
                              width, channels, buffer);
    }
    multi_thread_<unsigned short *> mthread(
        static_cast<unsigned short *>(in), static_cast<unsigned short *>(out),
        buffer, height, width, channels, number_of_thread, radius, curve,
        polygon_number, degree, power, threshold_min, threshold_max,
        alpha_rendering_sw);
    mthread.run();
    mthread.clear();
  } else {
    throw std::domain_error("Bad bits,Not uchar/ushort");
  }
}