#include <cmath>	 // pow(-)</cmath>

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

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

#include <vector></vector>

#include "igs_level_auto.h"

#include "igs_ifx_common.h" /* igs::image::rgba */

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

namespace

{

double level_value_(

	double value,

	double mul_max,

	bool act_sw,

	double in_min,

	double in_max,

	double out_min,

	double out_max,

	double gamma)

{

	if (act_sw) {

		if (in_max == in_min) {

			value = in_max;

		} else {

			/* 制限(in_min〜in_max) */

			if (in_min < in_max) {

				if (value < in_min) {

					value = in_min;

				} else if (in_max < value) {

					value = in_max;

				}

			} else {

				if (value < in_max) {

					value = in_max;

				} else if (in_min < value) {

					value = in_min;

				}

			}

			/* 正規化(0〜1) */

			value = (value - in_min) / (in_max - in_min);

			/* Gamma変換 */

			if ((1.0 != gamma) && (0.0 != gamma)) {

				value = pow(value, 1.0 / gamma);

			}

		}

		/* Outputの範囲にスケール変換 */

		value = out_min + value * (out_max - out_min);

		/* 0...1の間で制限かける */

		if (value < 0.0) {

			value = 0.0;

		} else if (1.0 < value) {

			value = 1.0;

		}

	}

	/* 0〜1.0 --> 0〜mul_maxスケール変換し、整数値化 */

	return floor(value * mul_max);

}

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

void level_ctable_template_(

	const unsigned int channels,

	const bool *act_sw,			// user setting

	const int *in_min,			// image pixel value

	const int *in_max,			// image pixel value

	const double *in_min_shift, // user settting

	const double *in_max_shift, // user settting

	const double *out_min,		// user settting

	const double *out_max,		// user settting

	const double *gamma,		// user settting

	const unsigned int div_num,

	std::vector<std::vector<unsigned int="">> &table_array</std::vector<unsigned>

	/*

	std::vector< std::vector<t> > &table_array</t>

 とするとvc2005mdで他プログラムとのリンク時、

	allocatorの２重定義でエラーとなる。

	std::vector< std::vector<unsigned int=""> >&table_array</unsigned>

 ならOK

 2009-01-27

*/

	)

{

	const double div_val = static_cast<double>(div_num);</double>

	const double mul_val = div_val + 0.999999;

#if defined _WIN32 // vc compile_type

	double in_min_[4], in_max_[4];

#else

	double in_min_[channels], in_max_[channels];

#endif

	for (unsigned int cc = 0; cc < channels; ++cc) {

		in_min_[cc] = in_min_shift[cc] + in_min[cc] / div_val;

		in_max_[cc] = in_max_shift[cc] + in_max[cc] / div_val;

	}

	table_array.resize(channels);

	for (unsigned int cc = 0; cc < channels; ++cc) {

		table_array[cc].resize(div_num + 1);

		for (unsigned int yy = 0; yy <= div_num; ++yy) {

			table_array[cc][yy] =

				static_cast<unsigned int="">(level_value_(</unsigned>

					yy / div_val,

					mul_val,

					act_sw[cc],

					in_min_[cc], in_max_[cc],

					out_min[cc], out_max[cc],

					gamma[cc]));

		}

	}

}

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

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

void change_template_(

	T *image_array,

	const int height,

	const int width,

	const int channels,

	const bool *act_sw,

	const double *in_min_shift,

	const double *in_max_shift,

	const double *out_min,

	const double *out_max,

	const double *gamma)

{

/* 1.まず最大値、最小値を求める */

#if defined _WIN32

	int in_min[4], in_max[4];

#else

	int in_min[channels], in_max[channels];

#endif

	for (int zz = 0; zz < channels; ++zz) {

		in_min[zz] = in_max[zz] = image_array[zz];

	}

	T *image_crnt = image_array;

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

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

			for (int zz = 0; zz < channels; ++zz) {

				if (image_crnt[zz] < in_min[zz]) {

					in_min[zz] = image_crnt[zz];

				} else if (in_max[zz] < image_crnt[zz]) {

					in_max[zz] = image_crnt[zz];

				}

			}

			image_crnt += channels;

		}

	}

	/* 2.最大値、最小値から変換テーブルを求める */

	std::vector<std::vector<unsigned int="">> table_array;</std::vector<unsigned>

	level_ctable_template_(

		channels,

		act_sw,

		in_min, in_max, in_min_shift, in_max_shift,

		out_min, out_max,

		gamma,

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

		table_array);

	/* 3.変換テーブルを使ってlevel変換する */

	image_crnt = image_array;

	const int pixsize = height * width;

	if (igs::image::rgba::siz == channels) {

		using namespace igs::image::rgba;

		for (int ii = 0; ii < pixsize; ++ii, image_crnt += channels) {

			image_crnt[red] = static_cast<t>(table_array[0][image_crnt[red]]);</t>

			image_crnt[gre] = static_cast<t>(table_array[1][image_crnt[gre]]);</t>

			image_crnt[blu] = static_cast<t>(table_array[2][image_crnt[blu]]);</t>

			image_crnt[alp] = static_cast<t>(table_array[3][image_crnt[alp]]);</t>

		}

	} else if (igs::image::rgb::siz == channels) {

		using namespace igs::image::rgb;

		for (int ii = 0; ii < pixsize; ++ii, image_crnt += channels) {

			image_crnt[red] = static_cast<t>(table_array[0][image_crnt[red]]);</t>

			image_crnt[gre] = static_cast<t>(table_array[1][image_crnt[gre]]);</t>

			image_crnt[blu] = static_cast<t>(table_array[2][image_crnt[blu]]);</t>

		}

	} else if (1 == channels) { /* grayscale */

		for (int ii = 0; ii < pixsize; ++ii, ++image_crnt) {

			image_crnt[0] = static_cast<t>(table_array[0][image_crnt[0]]);</t>

		}

	}

	table_array.clear();

}

}

void igs::level_auto::change(

	unsigned char *image_array,

	const int height,

	const int width,

	const int channels,

	const int bits,

	const bool *act_sw,			// channels array

	const double *in_min_shift, // channels array

	const double *in_max_shift, // channels array

	const double *out_min,		// channels array

	const double *out_max,		// channels array

	const double *gamma			// channels array

	)

{

	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) {</unsigned>

		change_template_(

			image_array,

			height, width, channels,

			act_sw, in_min_shift, in_max_shift,

			out_min, out_max, gamma);

	} else if (std::numeric_limits<unsigned short="">::digits == bits) {</unsigned>

		change_template_(

			reinterpret_cast<unsigned *="" short="">(image_array),</unsigned>

			height, width, channels,

			act_sw, in_min_shift, in_max_shift,

			out_min, out_max, gamma);

	} else {

		throw std::domain_error("Bad bits,Not uchar/ushort");

	}

}