#include <string></string>

#include <vector></vector>

#include <limits>	// std::numeric_limits</limits>

#include <stdexcept> // std::domain_error()</stdexcept>

#include <algorithm> // std::max(),std::rotate()</algorithm>

#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)</double></double></double></double></std::vector<double></std::vector<double>

{

	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</double>

	std::vector<int> &lens_offsets, std::vector<double *=""> &lens_starts, std::vector<int> &lens_sizes</int></double></int>

	,

	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</double></double></double></double></std::vector<double></std::vector<double>

	,

	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())</int>

																				,

			&lens_starts.at(0), &pixe_starts.at(0), &lens_sizes.at(0), static_cast<int>(lens_sizes.size())</int>

																		   ,

			-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())</int>

																					,

				&lens_starts.at(0), &pixe_starts.at(0), &thre_starts.at(0), &lens_sizes.at(0), static_cast<int>(lens_sizes.size())</int>

																								   ,

				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())</int>

																					,

				&lens_starts.at(0), &pixe_starts.at(0), &thre_starts.at(0), &lens_sizes.at(0), static_cast<int>(lens_sizes.size())</int>

																								   ,

				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())</int>

																			,

		&lens_starts.at(0), &pixe_starts.at(0), &lens_sizes.at(0), static_cast<int>(lens_sizes.size())</int>

																	   ,

		power);

}

void sl_track_shift_(

	std::vector<std::vector<double>> &pixe_tracks, std::vector<std::vector<double>> &thre_tracks)</std::vector<double></std::vector<double>

{

	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)</double></double></double></double></std::vector<double></std::vector<double>

{

	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=""></class>

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>(</double>

		std::numeric_limits<t>::max());</t>

	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;</double>

			} else {

				const double red = static_cast<double>(image[0]) / val_max;</double>

				const double gre = static_cast<double>(image[1]) / val_max;</double>

				const double blu = static_cast<double>(image[2]) / val_max;</double>

				/* 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=""></class>

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=""></class>

void paint_margin_(

	const int width, const int margin, std::vector<t> &track)</t>

{

	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=""></class>

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)</double></double></std::vector<double></std::vector<double>

{

	const double val_max = static_cast<double>(</double>

		std::numeric_limits<t>::max());</t>

	/*--- 入力画像を(マージン含めた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);</double>

			for (int xx = 0; xx < ww; ++xx) {

				track.at(margin + xx) =

					static_cast<double>(ss[xx * ch]) / val_max;</double>

			}

			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);</double>

			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;</double>

	}

	/*--- 処理結果としての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;</double>

	}

}

template <class t=""></class>

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)</double></double></std::vector<double></std::vector<double>

{

	const double val_max = static_cast<double>(</double>

		std::numeric_limits<t>::max());</t>

	/*--- 入力画像を(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);</double>

		for (int xx = 0; xx < ww; ++xx) {

			track.at(margin + xx) =

				static_cast<double>(mm[xx * ch]) / val_max;</double>

		}

		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);</double>

		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;</double>

	}

	/*--- 処理結果としての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;</double>

	}

}

template <class tp=""></class>

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=""></class>

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)</double>

{

	const double val_max = static_cast<double>(</double>

		std::numeric_limits<t>::max());</t>

	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));</t>

	}

}

}

namespace

{ //--------------------------------------------------------

template <class t=""></class>

class one_thread_ : 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</double>

		,

		std::vector<int> *lens_offsets_p, std::vector<double *=""> *lens_starts_p, std::vector<int> *lens_sizes_p</int></double></int>

		,

		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_);</int>

	}

	void run(void)

	{

		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_;</double>

	std::vector<int> *lens_offsets_p_;</int>

	std::vector<double *=""> *lens_starts_p_;</double>

	std::vector<int> *lens_sizes_p_;</int>

	double power_;

	double threshold_min_;

	double threshold_max_;

	bool alpha_rendering_sw_;

	std::vector<std::vector<double>> pixe_tracks_;</std::vector<double>

	std::vector<std::vector<double>> thre_tracks_;</std::vector<double>

	std::vector<double *=""> pixe_starts_;</double>

	std::vector<double *=""> thre_starts_;</double>

	std::vector<double> result_;</double>

	std::vector<double> alpha_ref_;</double>

	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),</int>

				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),</int>

				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>

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<double>

	std::vector<int> lens_offsets_;</int>

	std::vector<double *=""> lens_starts_;</double>

	std::vector<int> lens_sizes_;</int>

	std::vector<one_thread_<t>> threads_;</one_thread_<t>

	igs::resource::multithread mthread_;

};

}

//--------------------------------------------------------------------

/* パラメータの指定を見て、画像に変化の無い場合、