#include <iostream></iostream>

#include <iomanip></iomanip>

#include <algorithm> /* std::copy() */</algorithm>

#include "igs_maxmin_slrender.h"

#include "igs_maxmin_lens_matrix.h"

void igs::maxmin::slrender::resize(

	const int odd_diameter, const int width, const bool alpha_ref_sw, std::vector<std::vector<double>> &tracks, std::vector<double> &alpha_ref, std::vector<double> &result)</double></double></std::vector<double>

{

	tracks.resize(odd_diameter);

	for (int yy = 0; yy < odd_diameter; ++yy) {

		tracks.at(yy).resize(width + odd_diameter - 1);

	}

	if (alpha_ref_sw) {

		alpha_ref.resize(width);

	}

	result.resize(width);

}

void igs::maxmin::slrender::clear(

	std::vector<std::vector<double>> &tracks, std::vector<double> &alpha_ref, std::vector<double> &result)</double></double></std::vector<double>

{

	result.clear();

	alpha_ref.clear();

	tracks.clear();

}

void igs::maxmin::slrender::shift(

	std::vector<std::vector<double>> &tracks)</std::vector<double>

{

	/* 先頭からtracks.end()-1番目の要素が先頭にくるように回転 */

	std::rotate(tracks.begin(), tracks.end() - 1, tracks.end());

}

namespace

{

double maxmin_(

	const double src, const bool min_sw, const std::vector<const *="" double=""> &begin_ptr, const std::vector<int> &lens_sizes, const std::vector<std::vector<double>> &lens_ratio)</std::vector<double></int></const>

{

	if (min_sw) {

		/* 暗を広げる場合、反転して判断し、結果は反転して戻す */

		double val = 1.0 - src;			  /* 反転して判断 */

		const double rev_src = 1.0 - src; /* 反転して判断 */

		for (unsigned yy = 0; yy < begin_ptr.size(); ++yy) {

			const int sz = lens_sizes.at(yy);

			if (sz <= 0) {

				continue;

			}

			const double *xptr = begin_ptr.at(yy);

			const double *rptr = &lens_ratio.at(yy).at(0);

			for (int xx = 0; xx < sz; ++xx, ++xptr, ++rptr) {

				double crnt = 1.0 - (*xptr); /* 反転して判断 */

				/* 元値と同じか(反転してるので)小さい値は不要 */

				if (crnt <= rev_src) {

					continue;

				}

				/* 元値との差に比率を掛けて結果値を出す */

				crnt = rev_src + (crnt - rev_src) * (*rptr);

				/* 今までの中で(反転してるので)より大きいなら代入 */

				if (val < crnt) {

					val = crnt;

				}

			}

		}

		return 1.0 - val; /* 結果は反転して戻す */

	}

	/* Max */

	double val = src;

	for (unsigned yy = 0; yy < begin_ptr.size(); ++yy) {

		const int sz = lens_sizes.at(yy);

		if (sz <= 0) {

			continue;

		}

		const double *xptr = begin_ptr.at(yy);

		const double *rptr = &lens_ratio.at(yy).at(0);

		for (int xx = 0; xx < sz; ++xx, ++xptr, ++rptr) {

			/* 元値と同じか小さい値は不要 */

			if ((*xptr) <= src) {

				continue;

			}

			/* 元値との差に比率を掛けて結果値を出す */

			const double crnt = src + ((*xptr) - src) * (*rptr);

			/* 今までの中でより大きいなら代入 */

			if (val < crnt) {

				val = crnt;

			}

		}

	}

	return val;

}

void set_begin_ptr_(

	const std::vector<std::vector<double>> &tracks, const std::vector<int> &lens_offsets, const int offset, std::vector<const *="" double=""> &begin_ptr)</const></int></std::vector<double>

{

	for (unsigned ii = 0; ii < lens_offsets.size(); ++ii) {

		begin_ptr.at(ii) =

			(0 <= lens_offsets.at(ii))

				? &tracks.at(ii).at(offset + lens_offsets.at(ii))

				: 0;

	}

}

}

/* --- tracksをレンダリングする --------------------------------------*/

void igs::maxmin::slrender::render(

	const double radius, const double smooth_outer_range, const int polygon_number, const double roll_degree

	,

	const bool min_sw

	,

	std::vector<int> &lens_offsets, std::vector<int> &lens_sizes, std::vector<std::vector<double>> &lens_ratio</std::vector<double></int></int>

	,

	const std::vector<std::vector<double>> &tracks /* RGBのどれか */</std::vector<double>

	,

	const std::vector<double> &alpha_ref /* alpha値で影響度合を決める */</double>

	,

	std::vector<double> &result /* 計算結果 */</double>

	)

{

	/* 初期位置 */

	std::vector<const *="" double=""> begin_ptr(lens_offsets.size());</const>

	set_begin_ptr_(tracks, lens_offsets, 0, begin_ptr);

	/* 効果半径に変化がある場合 */

	if (0 < alpha_ref.size()) {

		double before_radius = 0.0;

		for (unsigned xx = 0; xx < result.size(); ++xx) {

			/* 次の処理の半径 */

			const double radius2 = alpha_ref.at(xx) * radius;

			/* ゼロ以上なら処理する */

			if (0.0 < alpha_ref.at(xx)) {

				/* 前のPixelと違う大きさならreshapeする */

				if (radius2 != before_radius) {

					igs::maxmin::reshape_lens_matrix(

						radius2, igs::maxmin::outer_radius_from_radius(radius2, smooth_outer_range), igs::maxmin::diameter_from_outer_radius(radius + smooth_outer_range), polygon_number, roll_degree, lens_offsets, lens_sizes, lens_ratio);

					set_begin_ptr_(

						tracks, lens_offsets, xx, begin_ptr);

				}

				/* 各ピクセルの処理 */

				result.at(xx) = maxmin_(

					result.at(xx), min_sw, begin_ptr, lens_sizes, lens_ratio);

			} /* alpha_refがゼロなら変化なし */

			/* 次の位置へ移動 */

			for (unsigned ii = 0; ii < begin_ptr.size(); ++ii) {

				if (begin_ptr.at(ii) != 0) {

					++begin_ptr.at(ii);

				}

			}

			if (radius2 != before_radius) {

				before_radius = radius2;

			}

		}

	}

	/* 効果半径が変わらない場合 */

	else {

		for (unsigned xx = 0; xx < result.size(); ++xx) {

			/* 各ピクセルの処理 */

			result.at(xx) = maxmin_(

				result.at(xx), min_sw, begin_ptr, lens_sizes, lens_ratio);

			/* 次の位置へ移動 */

			for (unsigned ii = 0; ii < begin_ptr.size(); ++ii) {

				if (begin_ptr.at(ii) != 0) {

					++begin_ptr.at(ii);

				}

			}

		}

	}

}