#include <vector>	// std::vector
#include <cmath>	 // cos(),sin(),sqrt()
#include <limits>	// std::numeric_limits<T>
#include <stdexcept> // std::domain_error()
#include "igs_ifx_common.h"
#include "igs_radial_blur.h"
namespace
{
//------------------------------------------------------------------
template <class T>
class radial_
{
public:
	radial_(
		const T *in_top, const int height, const int width, const int channels, const double xc, const double yc, const double sub_size, const int imax, const double dmax, const double intensity /* 平均値ぼかし強度 */
		,
		const double radius /* 平均値ぼかしの始まる半径 */
		)
		: in_top_(in_top), hh_(height), ww_(width), cc_(channels), xc_(xc), yc_(yc), sub_size_(sub_size), imax_(imax), dmax_(dmax), intensity_(intensity), radius_(radius)
	{
	}
	void pixel_value(
		const T *in_current_pixel, const int xx, const int yy, const int z1, const int z2, const double ref_increase_val, const double ref_decrease_val, const double each_pixel_blur_ratio, T *result_pixel)
	{
		/* Pixel位置(0.5 1.5 2.5 ...) */
		const double xp = static_cast<double>(xx) + 0.5;
		const double yp = static_cast<double>(yy) + 0.5;

		/* 中心からPixel位置へのベクトルと長さ */
		const double xv = xp - this->xc_;
		const double yv = yp - this->yc_;
		const double dist = sqrt(xv * xv + yv * yv);

		/* 指定半径の範囲内なら何もしない */
		if (dist <= this->radius_) {
			for (int zz = z1; zz <= z2; ++zz) {
				result_pixel[zz] = in_current_pixel[zz];
			}
			return;
		}

		/* 中心からPixel位置への単位ベクトル */
		const double cosval = xv / dist;
		const double sinval = yv / dist;

		/* Radial方向のSamplingの開始位置と終了位置 */
		double scale = this->intensity_;
		if (0.0 <= each_pixel_blur_ratio) {
			scale *= each_pixel_blur_ratio;
		}
		const double length = (dist - this->radius_) *
							  scale;
		const double count_half = floor(
			length / 2.0 / this->sub_size_);
		const double sub_sta = -this->sub_size_ * count_half;
		const double sub_end = this->sub_size_ * count_half;

		/* 積算値と積算回数 */
		std::vector<double> accum_val(this->cc_);
		int accum_counter = 0;

		/* 円周接線方向Samplingの相対位置 */
		for (double ss = this->sub_size_ / 2.0 - 0.5;
			 ss < 0.5; ss += this->sub_size_) {

			/* 円周接線方向Sampling位置 */
			const double xps = xp + ss * sinval;
			const double yps = yp + ss * cosval;

			/* 中心からSampling位置へのベクトルと長さ */
			const double xvs = xps - this->xc_;
			const double yvs = yps - this->yc_;
			const double dists = sqrt(xvs * xvs + yvs * yvs);

			/* 中心からSampling位置への単位ベクトル */
			const double cosvals = xvs / dists;
			const double sinvals = yvs / dists;

			/* Radial方向のSampling */
			for (double tt = sub_sta;
				 tt <= sub_end; tt += this->sub_size_) {
				/* Sampling位置からPixel位置を得る */
				int xi = static_cast<int>(xps + tt * cosvals);
				int yi = static_cast<int>(yps + tt * sinvals);

				/* clamp */
				xi = (xi < 0) ? 0 : ((this->ww_ <= xi) ? this->ww_ - 1 : xi);
				yi = (yi < 0) ? 0 : ((this->hh_ <= yi) ? this->hh_ - 1 : yi);

				/* 画像のPixel位置 */
				const T *in_current = this->in_top_ +
									  this->cc_ * this->ww_ * yi +
									  this->cc_ * xi;

				/* 積算 */
				for (int zz = z1; zz <= z2; ++zz) {
					accum_val[zz] +=
						static_cast<double>(in_current[zz]);
				}
				++accum_counter;
			}
		}
		/* 積算しなかったとき(念のためのCheck) */
		if (accum_counter <= 0) {
			for (int zz = z1; zz <= z2; ++zz) {
				result_pixel[zz] = in_current_pixel[zz];
			}
			return;
		}
		/* ここで画像Pixelに保存 */
		for (int zz = z1; zz <= z2; ++zz) {
			accum_val[zz] /= static_cast<double>(accum_counter);

			if ((0 <= ref_increase_val) &&
				(in_current_pixel[zz] < accum_val[zz])) {
				/* 増分のみMask! */
				accum_val[zz] =
					static_cast<double>(in_current_pixel[zz]) +
					(accum_val[zz] - in_current_pixel[zz]) *
						ref_increase_val;
			} else if ((0 <= ref_decrease_val) &&
					   (accum_val[zz] < in_current_pixel[zz])) {
				/* 減分のみMask! */
				accum_val[zz] =
					static_cast<double>(in_current_pixel[zz]) +
					(accum_val[zz] - in_current_pixel[zz]) *
						ref_decrease_val;
			}

			accum_val[zz] += 0.5; /* 誤差対策 */
			if (this->dmax_ < accum_val[zz]) {
				result_pixel[zz] = static_cast<T>(this->imax_);
			} else if (accum_val[zz] < 0) {
				result_pixel[zz] = 0;
			} else {
				result_pixel[zz] = static_cast<T>(accum_val[zz]);
			}
		}
	}

private:
	radial_() {}

	const T *in_top_;
	const int hh_;
	const int ww_;
	const int cc_;
	const double xc_;
	const double yc_;
	const double sub_size_;
	const int imax_;
	const double dmax_;
	const double intensity_;
	const double radius_;

	/* copy constructorを無効化 */
	radial_(const radial_ &);

	/* 代入演算子を無効化 */
	radial_ &operator=(const radial_ &);
};
template <class IT, class RT>
void radial_convert_template_(
	const IT *in, const int margin /* 参照画像(in)がもつ余白 */

	,
	const RT *ref /* 求める画像(out)と同じ高さ、幅、チャンネル数 */
	,
	const int ref_bits, const int ref_mode // R,G,B,A,luminance

	,
	IT *out, const int hh /* 求める画像(out)の高さ */
	,
	const int ww /* 求める画像(out)の幅 */
	,
	const int cc, const double xc, const double yc, const double intensity /* 強度。ゼロより大きく2以下 */
	/* radius円境界での平均値ぼかしゼロとするためintensityは2より小さい */
	,
	const double radius /* 平均値ぼかしの始まる半径 */
	,
	const int sub_div /* 1ならJaggy、2以上はAntialias */
	,
	const bool alpha_rendering_sw)
{
	ref_bits; // for warning

	/* 強度のないとき、または、サブ分割がないとき、なにもしない */
	if (intensity <= 0.0 || sub_div <= 0) {
		return;
	}

	radial_<IT> cl_ra(
		in, hh + margin * 2, ww + margin * 2, cc, xc + margin, yc + margin, 1.0 / sub_div, std::numeric_limits<IT>::max() /* サンプリング値 */
		,
		static_cast<double>(std::numeric_limits<IT>::max()), intensity, radius);

#if defined RGBA_ORDER_OF_TOONZ6
	const int z1 = igs::image::rgba::blu;
	const int z2 = igs::image::rgba::red;
#elif defined RGBA_ORDER_OF_OPENGL
	const int z1 = igs::image::rgba::red;
	const int z2 = igs::image::rgba::blu;
#else
	Must be define / DRGBA_ORDER_OF_TOONZ6 or / DRGBA_ORDER_OF_OPENGL
#endif
	const IT *p_in = in + margin * (ww + margin * 2) * cc + margin * cc;
	IT *pout = out;

	if (0 == ref) { /* 参照なし */
		if (igs::image::rgba::siz == cc) {
			using namespace igs::image::rgba;
			if (alpha_rendering_sw) { /* Alphaも処理する */
				for (int yy = margin; yy < hh + margin; ++yy, p_in += 2 * margin * cc) {
					for (int xx = margin; xx < ww + margin; ++xx, p_in += cc, pout += cc) {
						cl_ra.pixel_value(p_in, xx, yy, alp, alp, -1.0, -1.0, -1.0, pout);
						if (0 == pout[alp]) {
							pout[red] = p_in[red];
							pout[gre] = p_in[gre];
							pout[blu] = p_in[blu];
							continue;
						}
						cl_ra.pixel_value(p_in, xx, yy, z1, z2, -1.0, -1.0, -1.0, pout);
					}
				}
			} else { /* Alpha処理しない、RGB増分をAlphaでMaskする */
				const unsigned int val_max = std::numeric_limits<IT>::max();
				for (int yy = margin; yy < hh + margin; ++yy, p_in += 2 * margin * cc) {
					for (int xx = margin; xx < ww + margin; ++xx, p_in += cc, pout += cc) {
						pout[alp] = p_in[alp];
						if (0 == pout[alp]) {
							pout[red] = p_in[red];
							pout[gre] = p_in[gre];
							pout[blu] = p_in[blu];
							continue;
						}
						/* Alpha値あるならRGB増分のみAlphaでMaskする */
						cl_ra.pixel_value(
							p_in, xx, yy, z1, z2, static_cast<double>(p_in[alp]) / val_max, -1.0, -1.0, pout);
					}
				}
			}
		} else { /* Alphaがない, RGB/Grayscale... */
			for (int yy = margin; yy < hh + margin; ++yy, p_in += 2 * margin * cc) {
				for (int xx = margin; xx < ww + margin; ++xx, p_in += cc, pout += cc) {
					cl_ra.pixel_value(p_in, xx, yy, 0, cc - 1, -1.0, -1.0, -1.0, pout);
				}
			}
		}
	} else { /* 参照あり */
		const RT *refe = ref;
		const int r_max = std::numeric_limits<RT>::max();
		if (igs::image::rgba::siz == cc) {
			using namespace igs::image::rgba;
			if (alpha_rendering_sw) { /* Alpha処理する */
				for (int yy = margin; yy < hh + margin; ++yy, p_in += 2 * margin * cc) {
					for (int xx = margin; xx < ww + margin; ++xx, p_in += cc, pout += cc, refe += cc) {
						const double refv = igs::color::ref_value(
							refe, cc, r_max, ref_mode);
						if (0 == refv) {
							for (int zz = 0; zz < cc; ++zz) {
								pout[zz] = p_in[zz];
							}
							continue;
						}

						cl_ra.pixel_value(p_in, xx, yy, alp, alp, -1.0, -1.0, refv, pout);
						if (0 == pout[alp]) {
							pout[red] = p_in[red];
							pout[gre] = p_in[gre];
							pout[blu] = p_in[blu];
							continue;
						}
						cl_ra.pixel_value(p_in, xx, yy, z1, z2, -1.0, -1.0, refv, pout);
					}
				}
			} else { /* Alpha処理しない、RGB増分をAlphaでMaskする */
				const unsigned int val_max = std::numeric_limits<IT>::max();
				for (int yy = margin; yy < hh + margin; ++yy, p_in += 2 * margin * cc) {
					for (int xx = margin; xx < ww + margin; ++xx, p_in += cc, pout += cc, refe += cc) {
						const double refv = igs::color::ref_value(
							refe, cc, r_max, ref_mode);
						if (0 == refv) {
							for (int zz = 0; zz < cc; ++zz) {
								pout[zz] = p_in[zz];
							}
							continue;
						}

						pout[alp] = p_in[alp];
						if (0 == pout[alp]) {
							pout[red] = p_in[red];
							pout[gre] = p_in[gre];
							pout[blu] = p_in[blu];
							continue;
						}
						cl_ra.pixel_value(p_in, xx, yy, z1, z2, static_cast<double>(p_in[alp]) / val_max, -1.0, refv, pout);
					}
				}
			}
		} else { /* Alphaがない, RGB/Grayscale... */
			for (int yy = margin; yy < hh + margin; ++yy, p_in += 2 * margin * cc) {
				for (int xx = margin; xx < ww + margin; ++xx, p_in += cc, pout += cc, refe += cc) {
					const double refv = igs::color::ref_value(
						refe, cc, r_max, ref_mode);
					if (0 == refv) {
						for (int zz = 0; zz < cc; ++zz) {
							pout[zz] = p_in[zz];
						}
						continue;
					}

					cl_ra.pixel_value(p_in, xx, yy, 0, cc - 1, -1.0, -1.0, refv, pout);
				}
			}
		}
	}
}
}
//--------------------------------------------------------------------
namespace
{
class twist_
{
public:
	twist_(
		const int height, const double xc, const double yc, const double twist_radian, const double twist_radius)
		: xc_(xc), yc_(yc), twist_xp_(0), twist_yp_(0), twist_radian_(twist_radian), twist_radius_(twist_radius), current_xp_(0), current_yp_(0), current_radian_(0), current_cos_(0), current_sin_(0), current_radius_(0)
	{
		/* twist_radiusは、Twist曲線上半径1のPixel画像上半径 */
		/* twist_radiusはゼロのとき、高さの半分を設定する */
		if (this->twist_radius_ <= 0.0) {
			this->twist_radius_ = height / 2.0;
		}
		/* ゼロだと計算不能になる */
		if (this->twist_radius_ <= 0.0) {
			throw std::domain_error(
				"twist_radius is equal less than zero");
		}
	}
	void current_pos(const double xp, const double yp)
	{
		/* 現在位置 */
		this->current_xp_ = xp;
		this->current_yp_ = yp;

		/* 中心からの距離 */
		const double xv = xp - this->xc_;
		const double yv = yp - this->yc_;
		this->current_radius_ = sqrt(xv * xv + yv * yv);

		/* 基準からの距離比 */
		const double tt = this->current_radius_ / this->twist_radius_;

		/* Twist曲線上の位置 */
		const double xx = tt * cos(tt * this->twist_radian_);
		const double yy = tt * sin(tt * this->twist_radian_);

		/* Twist曲線の回転角度 */
		this->current_radian_ = atan2(yv, xv) - atan2(yy, xx);

		/* Twist曲線上の位置を回転角度に傾けた位置 */
		this->current_cos_ = cos(this->current_radian_);
		this->current_sin_ = sin(this->current_radian_);
		this->twist_xp_ = xx * this->current_cos_ -
						  yy * this->current_sin_;
		this->twist_yp_ = xx * this->current_sin_ +
						  yy * this->current_cos_;
	}
	void twist_pos(
		const double pixel_pos, int &xi, int &yi)
	{
		/* 基準半径からの比 */
		const double tt = (this->current_radius_ + pixel_pos) /
						  this->twist_radius_;

		/* Twist曲線上の比による位置 */
		const double xx = tt * cos(tt * this->twist_radian_);
		const double yy = tt * sin(tt * this->twist_radian_);

		/* その位置の角度に傾ける */
		double x2 = xx * this->current_cos_ -
					yy * this->current_sin_;
		double y2 = xx * this->current_sin_ +
					yy * this->current_cos_;

		/* Twist曲線上の位置の差 */
		x2 = (x2 - this->twist_xp_);
		y2 = (y2 - this->twist_yp_);

		/* Pixel画像上の位置の差 */
		x2 *= this->twist_radius_;
		y2 *= this->twist_radius_;

		/* Pixel画像上の位置 */
		x2 += this->current_xp_;
		y2 += this->current_yp_;

		xi = static_cast<int>(x2);
		yi = static_cast<int>(y2);
	}

private:
	twist_();

	const double xc_;
	const double yc_;

	double twist_xp_;
	double twist_yp_;
	double twist_radian_;
	double twist_radius_;

	double current_xp_;
	double current_yp_;
	double current_radian_;
	double current_cos_;
	double current_sin_;
	double current_radius_;

	/* copy constructorを無効化 */
	twist_(const twist_ &);

	/* 代入演算子を無効化 */
	twist_ &operator=(const twist_ &);
};
//--------------------------------
template <class T>
class radial_twist_
{
public:
	radial_twist_(
		const T *in_top, const int height /* 求める画像(out)の高さ */
		,
		const int width /* 求める画像(out)の幅 */
		,
		const int channels, const double xc, const double yc, const double sub_size, const int imax, const double dmax, const double intensity /* 平均値ぼかし強度 */
		,
		const double radius /* 平均値ぼかしの始まる半径 */
		,
		const double twist_radian, const double twist_radius)
		: in_top_(in_top), hh_(height), ww_(width), cc_(channels), xc_(xc), yc_(yc), sub_size_(sub_size), imax_(imax), dmax_(dmax), intensity_(intensity), radius_(radius), cl_tw_(
																																												height, xc, yc, twist_radian, twist_radius)
	{
	}
	void pixel_value(
		const T *in_current_pixel, const int xx, const int yy, const int z1, const int z2, const double ref_increase_val, const double ref_decrease_val, const double each_pixel_blur_ratio, T *result_pixel)
	{
		/* Pixel位置(0.5 1.5 2.5 ...) */
		const double xp = static_cast<double>(xx) + 0.5;
		const double yp = static_cast<double>(yy) + 0.5;

		/* 中心からPixel位置へのベクトルと長さ */
		const double xv = xp - this->xc_;
		const double yv = yp - this->yc_;
		const double dist = sqrt(xv * xv + yv * yv);

		/* 指定半径の範囲内なら何もしない */
		if (dist <= this->radius_) {
			for (int zz = z1; zz <= z2; ++zz) {
				result_pixel[zz] = in_current_pixel[zz];
			}
			return;
		}

		/* Radial方向のSamplingの開始位置と終了位置 */
		double scale = this->intensity_;
		if (0.0 <= each_pixel_blur_ratio) {
			scale *= each_pixel_blur_ratio;
		}
		const double length = (dist - this->radius_) *
							  scale;
		const double count_half = floor(length / 2.0 / this->sub_size_);
		const double sub_sta = -this->sub_size_ * count_half;
		const double sub_end = this->sub_size_ * count_half;

		/* 積算値と積算回数 */
		std::vector<double> accum_val(this->cc_);
		int accum_counter = 0;

		/* SubPixelによるSamplingの相対位置 */
		for (double xsub = this->sub_size_ / 2.0 - 0.5;
			 xsub < 0.5; xsub += this->sub_size_) {
			for (double ysub = this->sub_size_ / 2.0 - 0.5;
				 ysub < 0.5; ysub += this->sub_size_) {

				/* Sampling位置をセット */
				this->cl_tw_.current_pos(xp + xsub, yp + ysub);

				/* Radial&Twist方向のSampling */
				for (double tt = sub_sta; tt <= sub_end; tt += this->sub_size_) {
					/* Sampling位置からPixel位置を得る */
					int xi = 0;
					int yi = 0;
					this->cl_tw_.twist_pos(tt, xi, yi);

					/* clamp */
					xi = (xi < 0) ? 0 : ((this->ww_ <= xi) ? this->ww_ - 1 : xi);
					yi = (yi < 0) ? 0 : ((this->hh_ <= yi) ? this->hh_ - 1 : yi);

					/* 画像のPixel位置 */
					const T *in_current = this->in_top_ +
										  this->cc_ * this->ww_ * yi +
										  this->cc_ * xi;

					/* 積算 */
					for (int zz = z1; zz <= z2; ++zz) {
						accum_val[zz] +=
							static_cast<double>(in_current[zz]);
					}
					++accum_counter;
				}
			}
		}
		/* 積算しなかったとき(念のためのCheck) */
		if (accum_counter <= 0) {
			for (int zz = z1; zz <= z2; ++zz) {
				result_pixel[zz] = in_current_pixel[zz];
			}
			return;
		}
		/* ここで画像Pixelに保存 */
		for (int zz = z1; zz <= z2; ++zz) {
			accum_val[zz] /= static_cast<double>(accum_counter);

			if ((0 <= ref_increase_val) &&
				(in_current_pixel[zz] < accum_val[zz])) {
				/* 増分のみMask! */
				accum_val[zz] =
					static_cast<double>(in_current_pixel[zz]) +
					(accum_val[zz] - in_current_pixel[zz]) *
						ref_increase_val;
			} else if ((0 <= ref_decrease_val) &&
					   (accum_val[zz] < in_current_pixel[zz])) {
				/* 減分のみMask! */
				accum_val[zz] =
					static_cast<double>(in_current_pixel[zz]) +
					(accum_val[zz] - in_current_pixel[zz]) *
						ref_decrease_val;
			}

			accum_val[zz] += 0.5; /* 誤差対策 */
			if (this->dmax_ < accum_val[zz]) {
				result_pixel[zz] = static_cast<T>(this->imax_);
			} else if (accum_val[zz] < 0) {
				result_pixel[zz] = 0;
			} else {
				result_pixel[zz] = static_cast<T>(
					accum_val[zz]);
			}
		}
	}

private:
	radial_twist_() {}

	const T *in_top_;
	const int hh_;
	const int ww_;
	const int cc_;
	const double xc_;
	const double yc_;
	const double sub_size_;
	const int imax_;
	const double dmax_;
	const double intensity_;
	const double radius_;
	twist_ cl_tw_;

	/* copy constructorを無効化 */
	radial_twist_(const radial_twist_ &);

	/* 代入演算子を無効化 */
	radial_twist_ &operator=(const radial_twist_ &);
};
//--------------------------------
template <class IT, class RT>
void twist_convert_template_(
	const IT *in, const int margin /* 参照画像(in)がもつ余白 */

	,
	const RT *ref /* 求める画像(out)と同じ高さ、幅、チャンネル数 */
	,
	const int ref_bits, const int ref_mode // R,G,B,A,luminance

	,
	IT *out, const int hh /* 求める画像(out)の高さ */
	,
	const int ww /* 求める画像(out)の幅 */
	,
	const int cc, const double xc, const double yc, const double twist_radian, const double twist_radius, const double intensity /* 強度。ゼロより大きく2以下 */
	/* radius円境界での平均値ぼかしゼロとするためintensityは2より小さい */
	,
	const double radius /* 平均値ぼかしの始まる半径 */
	,
	const int sub_div /* 1ならJaggy、2以上はAntialias */
	,
	const bool alpha_rendering_sw)
{
	ref_bits; // for warning

	/* 強度のないとき、または、サブ分割がないとき、なにもしない */
	if (intensity <= 0.0 || sub_div <= 0) {
		return;
	}

	radial_twist_<IT> cl_ratw(
		in, hh + margin * 2, ww + margin * 2, cc, xc + margin, yc + margin, 1.0 / sub_div, std::numeric_limits<IT>::max(), static_cast<double>(std::numeric_limits<IT>::max()), intensity, radius, twist_radian, twist_radius);

#if defined RGBA_ORDER_OF_TOONZ6
	const int z1 = igs::image::rgba::blu;
	const int z2 = igs::image::rgba::red;
#elif defined RGBA_ORDER_OF_OPENGL
	const int z1 = igs::image::rgba::red;
	const int z2 = igs::image::rgba::blu;
#else
	Must be define / DRGBA_ORDER_OF_TOONZ6 or / DRGBA_ORDER_OF_OPENGL
#endif

	const IT *p_in = in + margin * (ww + margin * 2) * cc + margin * cc;
	IT *pout = out;

	if (0 == ref) { /* 参照なし */
		if (igs::image::rgba::siz == cc) {
			using namespace igs::image::rgba;
			if (alpha_rendering_sw) { /* Alphaも処理する */
				for (int yy = margin; yy < hh + margin; ++yy, p_in += 2 * margin * cc) {
					for (int xx = margin; xx < ww + margin; ++xx, p_in += cc, pout += cc) {
						cl_ratw.pixel_value(p_in, xx, yy, alp, alp, -1.0, -1.0, -1.0, pout);
						if (0 == pout[alp]) {
							pout[red] = p_in[red];
							pout[gre] = p_in[gre];
							pout[blu] = p_in[blu];
							continue;
						}
						cl_ratw.pixel_value(p_in, xx, yy, z1, z2, -1.0, -1.0, -1.0, pout);
					}
				}
			} else { /* Alpha処理しない、RGB増分をAlphaでMaskする */
				const unsigned int val_max = std::numeric_limits<IT>::max();
				for (int yy = margin; yy < hh + margin; ++yy, p_in += 2 * margin * cc) {
					for (int xx = margin; xx < ww + margin; ++xx, p_in += cc, pout += cc) {
						pout[alp] = p_in[alp];
						if (0 == pout[alp]) {
							pout[red] = p_in[red];
							pout[gre] = p_in[gre];
							pout[blu] = p_in[blu];
							continue;
						}
						cl_ratw.pixel_value(
							p_in, xx, yy, z1, z2, static_cast<double>(p_in[alp]) / val_max, -1.0, -1.0, pout);
					}
				}
			}
		} else { /* Alphaがない, RGB/Grayscale... */
			for (int yy = margin; yy < hh + margin; ++yy, p_in += 2 * margin * cc) {
				for (int xx = margin; xx < ww + margin; ++xx, p_in += cc, pout += cc) {
					cl_ratw.pixel_value(p_in, xx, yy, 0, cc - 1, -1.0, -1.0, -1.0, pout);
				}
			}
		}
	} else { /* 参照あり */
		const RT *refe = ref;
		const int r_max = std::numeric_limits<RT>::max();
		if (igs::image::rgba::siz == cc) {
			using namespace igs::image::rgba;
			if (alpha_rendering_sw) { /* Alphaも処理する */
				for (int yy = margin; yy < hh + margin; ++yy, p_in += 2 * margin * cc) {
					for (int xx = margin; xx < ww + margin; ++xx, p_in += cc, pout += cc, refe += cc) {
						const double refv = igs::color::ref_value(
							refe, cc, r_max, ref_mode);
						if (0 == refv) {
							for (int zz = 0; zz < cc; ++zz) {
								pout[zz] = p_in[zz];
							}
							continue;
						}

						cl_ratw.pixel_value(p_in, xx, yy, alp, alp, -1.0, -1.0, refv, pout);
						if (0 == pout[alp]) {
							pout[red] = p_in[red];
							pout[gre] = p_in[gre];
							pout[blu] = p_in[blu];
							continue;
						}
						cl_ratw.pixel_value(p_in, xx, yy, z1, z2, -1.0, -1.0, refv, pout);
					}
				}
			} else { /* Alpha処理しない、RGB増分をAlphaでMaskする */
				const unsigned int val_max = std::numeric_limits<IT>::max();
				for (int yy = margin; yy < hh + margin; ++yy, p_in += 2 * margin * cc) {
					for (int xx = margin; xx < ww + margin; ++xx, p_in += cc, pout += cc, refe += cc) {
						const double refv = igs::color::ref_value(
							refe, cc, r_max, ref_mode);
						if (0 == refv) {
							for (int zz = 0; zz < cc; ++zz) {
								pout[zz] = p_in[zz];
							}
							continue;
						}

						pout[alp] = p_in[alp];
						if (0 == pout[alp]) {
							pout[red] = p_in[red];
							pout[gre] = p_in[gre];
							pout[blu] = p_in[blu];
							continue;
						}
						cl_ratw.pixel_value(p_in, xx, yy, z1, z2, static_cast<double>(p_in[alp]) / val_max, -1.0, refv, pout);
					}
				}
			}
		} else { /* Alphaがない, RGB/Grayscale... */
			for (int yy = margin; yy < hh + margin; ++yy, p_in += 2 * margin * cc) {
				for (int xx = margin; xx < ww + margin; ++xx, p_in += cc, pout += cc, refe += cc) {
					const double refv = igs::color::ref_value(
						refe, cc, r_max, ref_mode);
					if (0 == refv) {
						for (int zz = 0; zz < cc; ++zz) {
							pout[zz] = p_in[zz];
						}
						continue;
					}

					cl_ratw.pixel_value(p_in, xx, yy, 0, cc - 1, -1.0, -1.0, refv, pout);
				}
			}
		}
	}
}
}
//--------------------------------------------------------------------
void igs::radial_blur::convert(
	const unsigned char *in, const int margin /* 参照画像(in)がもつ余白 */

	,
	const unsigned char *ref /* outと同じ高さ、幅、チャンネル数 */
	,
	const int ref_bits, const int ref_mode // R,G,B,A,luminance

	,
	unsigned char *out

	,
	const int height /* 求める画像(out)の高さ */
	,
	const int width /* 求める画像(out)の幅 */
	,
	const int channels, const int bits

	,
	const double xc, const double yc, const double twist_radian, const double twist_radius
	/*
Twist Radius
	ひねりの基準半径を指定します。
	単位はミリメートルです。
	最小は0。最大1000mm(1m)です。
	初期値は0でひねりはありません。
*/
	,
	const double intensity /* 強度。ゼロより大きく2以下 */
	/* radius円境界での平均値ぼかしゼロとするためintensityは2より小さい */
	,
	const double radius /* 平均値ぼかしの始まる半径 */
	,
	const int sub_div /* 1ならJaggy、2以上はAntialias */
	,
	const bool alpha_rendering_sw)
{
	if ((igs::image::rgba::siz != channels) &&
		(igs::image::rgb::siz != channels) &&
		(1 != channels) /* bit(monoBW) */
		) {
		throw std::domain_error("Bad channels,Not rgba/rgb/grayscale");
	}

	if (
		(std::numeric_limits<unsigned char>::digits != bits) &&
		(std::numeric_limits<unsigned short>::digits != bits)) {
		throw std::domain_error("Bad in bits,Not uchar/ushort");
	}
	if ((0 != ref) &&
		(std::numeric_limits<unsigned char>::digits != ref_bits) &&
		(std::numeric_limits<unsigned short>::digits != ref_bits)) {
		throw std::domain_error("Bad ref bits,Not uchar/ushort");
	}

	/* 強度のないとき、または、サブ分割がないとき */
	if (intensity <= 0.0 || sub_div <= 0) {
		if (std::numeric_limits<unsigned char>::digits == bits) {
			igs::image::copy_except_margin(
				in, margin, out, height, width, channels);
		} else if (std::numeric_limits<unsigned short>::digits == bits) {
			igs::image::copy_except_margin(
				reinterpret_cast<const unsigned short *>(in), margin, reinterpret_cast<unsigned short *>(out), height, width, channels);
		}
		return;
	}

	if (0.0 == twist_radian) {
		if (std::numeric_limits<unsigned char>::digits == ref_bits) {
			if (std::numeric_limits<unsigned char>::digits == bits) {
				radial_convert_template_(
					in, margin, ref, ref_bits, ref_mode, out, height, width, channels, xc, yc, intensity, radius, sub_div, alpha_rendering_sw);
			} else if (std::numeric_limits<unsigned short>::digits == bits) {
				radial_convert_template_(
					reinterpret_cast<const unsigned short *>(in), margin, ref, ref_bits, ref_mode, reinterpret_cast<unsigned short *>(out), height, width, channels, xc, yc, intensity, radius, sub_div, alpha_rendering_sw);
			}
		} else { /* ref_bitsがゼロでも(refがなくても)ここにくる */
			if (std::numeric_limits<unsigned char>::digits == bits) {
				radial_convert_template_(
					in, margin, reinterpret_cast<const unsigned short *>(ref), ref_bits, ref_mode, out, height, width, channels, xc, yc, intensity, radius, sub_div, alpha_rendering_sw);
			} else if (std::numeric_limits<unsigned short>::digits == bits) {
				radial_convert_template_(
					reinterpret_cast<const unsigned short *>(in), margin, reinterpret_cast<const unsigned short *>(ref), ref_bits, ref_mode, reinterpret_cast<unsigned short *>(out), height, width, channels, xc, yc, intensity, radius, sub_div, alpha_rendering_sw);
			}
		}
	} else {
		if (std::numeric_limits<unsigned char>::digits == ref_bits) {
			if (std::numeric_limits<unsigned char>::digits == bits) {
				twist_convert_template_(
					in, margin, ref, ref_bits, ref_mode, out, height, width, channels, xc, yc, twist_radian, twist_radius, intensity, radius, sub_div, alpha_rendering_sw);
			} else if (std::numeric_limits<unsigned short>::digits == bits) {
				twist_convert_template_(
					reinterpret_cast<const unsigned short *>(in), margin, ref, ref_bits, ref_mode, reinterpret_cast<unsigned short *>(out), height, width, channels, xc, yc, twist_radian, twist_radius, intensity, radius, sub_div, alpha_rendering_sw);
			}
		} else { /* ref_bitsがゼロでも(refがなくても)ここにくる */
			if (std::numeric_limits<unsigned char>::digits == bits) {
				twist_convert_template_(
					in, margin, reinterpret_cast<const unsigned short *>(ref), ref_bits, ref_mode, out, height, width, channels, xc, yc, twist_radian, twist_radius, intensity, radius, sub_div, alpha_rendering_sw);
			} else if (std::numeric_limits<unsigned short>::digits == bits) {
				twist_convert_template_(
					reinterpret_cast<const unsigned short *>(in), margin, reinterpret_cast<const unsigned short *>(ref), ref_bits, ref_mode, reinterpret_cast<unsigned short *>(out), height, width, channels, xc, yc, twist_radian, twist_radius, intensity, radius, sub_div, alpha_rendering_sw);
			}
		}
	}
}
#if 0  //-------------------- comment out start ------------------------
namespace {
 double enlarge_margin_length_(
	const double xc
	,const double yc
	,const double xp
	,const double yp
	,const double intensity
	,const double radius
	,const double sub_size
 ) {
	const double xv = xp - xc;
	const double yv = yp - yc;
	const double dist = sqrt(xv*xv + yv*yv);

	/* "dist = len - (len - radius) * intensity / 2.0;"より */
	const double len = (2.0 * dist - radius * intensity) /
				(2.0-intensity);

	/***const double length = (len - radius) * intensity;
	const double count_half = floor(length / sub_size);
	return sub_size * count_half;***/

	if (len <= radius) { return 0; }
	return (len - radius) * intensity / 2.0;
 }
}
int igs::radial_blur::enlarge_margin( /* Twist時は正確ではない... */
	const int height
	,const int width
	,const double xc
	,const double yc
	,const double twist_radian
	,const double twist_radius
	,const double intensity/* 強度。ゼロより大きく2以下 */
 /* radius円境界での平均値ぼかしゼロとするためintensityは2より小さい */
	,const double radius	/* 平均値ぼかしの始まる半径 */
	,const int sub_div	/* 1ならJaggy、2以上はAntialias */
) {
	/* 強度のないとき、2以上のとき、または、サブ分割がないとき、
	なにもしない */
	if (intensity <= 0.0 || 2.0 <= intensity || sub_div <= 0) {
		return 0;
	}

	double margin1 = 0;
	double margin2 = 0;

	margin1 = enlarge_margin_length_(
	  xc,yc,-width/2.0,-height/2.0,intensity,radius,1.0/sub_div);

	margin2 = enlarge_margin_length_(
	  xc,yc,-width/2.0, height/2.0,intensity,radius,1.0/sub_div);
	if (margin1 < margin2) { margin1 = margin2; }

	margin2 = enlarge_margin_length_(
	  xc,yc, width/2.0,-height/2.0,intensity,radius,1.0/sub_div);
	if (margin1 < margin2) { margin1 = margin2; }

	margin2 = enlarge_margin_length_(
	  xc,yc, width/2.0, height/2.0,intensity,radius,1.0/sub_div);
	if (margin1 < margin2) { margin1 = margin2; }

	return static_cast<int>(ceil(margin1));
}
#endif //-------------------- comment out end -------------------------
namespace
{
double reference_margin_length_(
	const double xc, const double yc, const double xp, const double yp, const double intensity, const double radius, const double sub_size)
{
	const double xv = xp - xc;
	const double yv = yp - yc;
	const double dist = sqrt(xv * xv + yv * yv);
	if (dist <= radius) {
		return 0;
	}
	const double half_length = (dist - radius) * intensity / 2.0;
	const double count_half = floor(half_length / sub_size);
	return sub_size * count_half;
}
}
int igs::radial_blur::reference_margin(																																					 /* Twist時は正確ではない... */
									   const int height, const int width, const double xc, const double yc, const double twist_radian, const double twist_radius, const double intensity /* 強度。ゼロより大きく2以下 */
									   /* radius円境界での平均値ぼかしゼロとするためintensityは2より小さい */
									   ,
									   const double radius /* 平均値ぼかしの始まる半径 */
									   ,
									   const int sub_div /* 1ならJaggy、2以上はAntialias */
									   )
{
	twist_radius; // for warning
	twist_radian; // for warning

	/* 強度のないとき、2以上のとき、または、サブ分割がないとき、
	なにもしない */
	if (intensity <= 0.0 || 2.0 <= intensity || sub_div <= 0) {
		return 0;
	}

	double margin1 = 0;
	double margin2 = 0;

	/*
	四隅から参照する外部への最大マージンを計算する
	*/
	margin1 = reference_margin_length_(
		xc, yc, -width / 2.0, -height / 2.0, intensity, radius, 1.0 / sub_div);

	margin2 = reference_margin_length_(
		xc, yc, -width / 2.0, height / 2.0, intensity, radius, 1.0 / sub_div);
	if (margin1 < margin2) {
		margin1 = margin2;
	}

	margin2 = reference_margin_length_(
		xc, yc, width / 2.0, -height / 2.0, intensity, radius, 1.0 / sub_div);
	if (margin1 < margin2) {
		margin1 = margin2;
	}

	margin2 = reference_margin_length_(
		xc, yc, width / 2.0, height / 2.0, intensity, radius, 1.0 / sub_div);
	if (margin1 < margin2) {
		margin1 = margin2;
	}

	return static_cast<int>(ceil(margin1));
}