/*

guardare DAFARE

write_lut_image ??? quando ?

*/

#include "autoadjust.h"

#include "cleanupcommon.h"

#define TO_ABS(x)       \

	{                   \

		if ((x) < 0)    \

			(x) = -(x); \

	}

typedef struct big {

	UINT lo, hi;

} BIG;

#define CLEAR_BIG(B) ((B).lo = 0, (B).hi = 0, (B))

#define ADD_BIG(B, X) ((B).lo += (UINT)(X), \

					   (B).hi += (B).lo >> 30, (B).lo &= 0x3fffffff, (B))

#define ADD_BIG_BIG(B1, B2) ((B1).lo += (B2).lo, (B1).hi += (B2).hi, \

							 (B1).hi += (B1).lo >> 30, (B1).lo &= 0x3fffffff, (B1))

#define BIG_TO_DOUBLE(B) ((double)(B).hi * (double)0x40000000 + (double)(B).lo)

static int Black = 0;

static int Ref_cum[256];

static int Ref_edgelen;

/*---------------------------------------------------------------------------*/

void autoadj_set_black_value(int black)

{

	Black = black;

}

/*===========================================================================*/

static void smooth_func256(float func[256], int rad)

{

	int i, j, k;

	float smooth[256];

	for (i = 0; i < 256; i++) {

		k = i - rad;

		notLessThan(0, k);

		smooth[i] = func[k] / 2;

		k = i + rad;

		notMoreThan(255, k);

		smooth[i] += func[k] / 2;

		for (j = i - rad + 1; j <= i + rad - 1; j++) {

			k = j;

			notLessThan(0, k);

			notMoreThan(255, k);

			smooth[i] += func[k];

		}

		smooth[i] /= 2 * rad;

	}

	for (i = 0; i < 256; i++)

		func[i] = smooth[i];

}

/*---------------------------------------------------------------------------*/

static void build_cum(int histo[256], int cum[256])

{

	int i;

	cum[0] = histo[0];

	for (i = 1; i < 256; i++)

		cum[i] = cum[i - 1] + histo[i];

}

/*===========================================================================*/

static int Window_x0, Window_y0, Window_x1, Window_y1;

void set_autoadjust_window(int x0, int y0, int x1, int y1)

{

	Window_x0 = x0;

	Window_y0 = y0;

	Window_x1 = x1;

	Window_y1 = y1;

	if (Window_x0 > Window_x1)

		tswap(Window_x0, Window_x1);

	if (Window_y0 > Window_y1)

		tswap(Window_y0, Window_y1);

}

/*---------------------------------------------------------------------------*/

static void get_virtual_buffer(const TRasterImageP &image,

							   int *p_lx, int *p_ly, int *p_wrap,

							   UCHAR **p_buffer)

{

	int x0, y0, x1, y1;

	int x_margin, y_margin;

	int lx, ly, wrap;

	UCHAR *buffer;

	TRasterGR8P ras8(image->getRaster());

	assert(ras8);

	double xdpi, ydpi;

	image->getDpi(xdpi, ydpi);

	/* BORDO DI MEZZO CENTIMETRO */

	x_margin = troundp(mmToPixel(5.0, xdpi));

	y_margin = troundp(mmToPixel(5.0, ydpi));

	x0 = Window_x0 + x_margin;

	y0 = Window_y0 + y_margin;

	x1 = Window_x1 - x_margin;

	y1 = Window_y1 - y_margin;

	notLessThan(x0 + 9, x1);

	notLessThan(y0 + 9, y1);

	notLessThan(0, x0);

	notMoreThan(ras8->getLx() - 1, x0);

	notLessThan(0, y0);

	notMoreThan(ras8->getLy() - 1, y0);

	notLessThan(0, x1);

	notMoreThan(ras8->getLx() - 1, x1);

	notLessThan(0, y1);

	notMoreThan(ras8->getLy() - 1, y1);

	lx = x1 - x0 + 1;

	ly = y1 - y0 + 1;

	wrap = ras8->getWrap();

	buffer = (UCHAR *)ras8->getRawData() + x0 + y0 * wrap;

	*p_lx = lx;

	*p_ly = ly;

	*p_wrap = wrap;

	*p_buffer = buffer;

}

/*===========================================================================*/

void black_eq_algo(const TRasterImageP &image)

{

	int lx, ly, wrap;

	int x, y, grey /*, width*/;

	int d_histo[256][256];

	int d, dd, m;

	UCHAR *buffer, *pix, *north, *south;

	UCHAR prev, darkest;

	long n;

	float mean_d[256];

	BIG s;

	int max_d_grey;

	float max_d;

	float fac;

	int val;

	UCHAR lut[256];

	image->getRaster()->lock();

	get_virtual_buffer(image, &lx, &ly, &wrap, &buffer);

	for (grey = 0; grey < 256; grey++) {

		for (d = 0; d < 256; d++)

			d_histo[grey][d] = 0;

	}

	for (y = 1; y < ly - 1; y++) {

		pix = buffer + y * wrap + 1;

		north = pix + wrap;

		south = pix - wrap;

		for (x = 1; x < lx - 1; x++, pix++, north++, south++) {

			m = 2 * ((int)north[0] + (int)pix[-1] + 2 * (int)pix[0] + (int)pix[1] + (int)south[0]) + (int)north[-1] + (int)north[1] + (int)south[-1] + (int)south[1];

			m = (m + 8) >> 4;

			d = (int)north[-1] + (int)north[0] * 2 + (int)north[1] - (int)south[-1] - (int)south[0] * 2 - (int)south[1];

			TO_ABS(d)

			dd = (int)north[-1] + (int)pix[-1] * 2 + (int)south[-1] - (int)north[1] - (int)pix[1] * 2 - (int)south[1];

			TO_ABS(dd)

			if (dd > d)

				d = dd;

			dd = (int)pix[-1] + (int)north[-1] * 2 + (int)north[0] - (int)pix[1] - (int)south[1] * 2 - (int)south[0];

			TO_ABS(dd)

			if (dd > d)

				d = dd;

			dd = (int)pix[1] + (int)north[1] * 2 + (int)north[0] - (int)pix[-1] - (int)south[-1] * 2 - (int)south[0];

			TO_ABS(dd)

			if (dd > d)

				d = dd;

			d = (d + 2) >> 2;

			d_histo[m][d]++;

		}

	}

	for (grey = 0; grey < 256; grey++) {

		n = 0;

		CLEAR_BIG(s);

		for (d = 0; d < 256; d++) {

			ADD_BIG(s, d_histo[grey][d] * d);

			n += d_histo[grey][d];

		}

		if (n)

			mean_d[grey] = (float)(BIG_TO_DOUBLE(s) / n);

		else

			mean_d[grey] = 0;

	}

	smooth_func256(mean_d, 5);

	max_d_grey = 0;

	max_d = 0.0;

	for (grey = 0; grey < 256; grey++) {

		if (max_d < mean_d[grey]) {

			max_d = mean_d[grey];

			max_d_grey = grey;

		}

	}

	n = 0;

	CLEAR_BIG(s);

	for (y = 0; y < ly; y++) {

		pix = buffer + y * wrap;

		prev = 255;

		darkest = 255;

		for (x = 0; x < lx; x++, pix++) {

			if (*pix < max_d_grey) {

				if (prev < max_d_grey)

					notMoreThan(*pix, darkest);

				else

					darkest = *pix;

			} else {

				if (prev < max_d_grey) {

					ADD_BIG(s, darkest);

					n++;

				}

			}

			prev = *pix;

		}

	}

	darkest = troundp(BIG_TO_DOUBLE(s) / n);

	/*

for (grey = 0; grey < darkest; grey++)

  lut[grey] = 0;

fac = (float)255 / (float)(255 - darkest);

for (grey = darkest; grey < 256; grey++)

  lut[grey] = 255 - troundp ((255 - grey) * fac);

*/

	notLessThan(0, Black);

	;

	notMoreThan(255, Black);

	fac = (float)(255 - Black) / (float)(255 - darkest);

	for (grey = 0; grey < 256; grey++) {

		val = 255 - troundp((255 - grey) * fac);

		notLessThan(0, val);

		notMoreThan(255, val);

		lut[grey] = val;

	}

	apply_lut(image, lut);

	image->getRaster()->unlock();

}

/*===========================================================================*/

#define MAX_WIDTH 100

/*---------------------------------------------------------------------------*/

void build_lw(const TRasterImageP &image, float lw[256])

{

	int lx, ly, wrap;

	int x, y, grey, width;

	int d_histo[256][256];

	int d, dd;

	int lw_histo[256][MAX_WIDTH + 1];

	int x_start[256];

	static int *y_start[256];

	static int y_start_alloc = 0;

	UCHAR *buffer, *pix, *north, *south;

	UCHAR cur_grey, x_prev_grey, x_next_grey, y_prev_grey, y_next_grey;

	int x_grad, y_grad;

	long n;

	float mean_d[256];

	BIG s;

	int max_d_grey;

	float max_d;

	long max_d_n;

	get_virtual_buffer(image, &lx, &ly, &wrap, &buffer);

	if (y_start_alloc < lx) {

		for (grey = 0; grey < 256; grey++) {

			delete[] y_start[grey];

			y_start[grey] = new int[lx];

			//TREALLOC (y_start[grey], lx);

		}

		y_start_alloc = lx;

	}

	for (grey = 0; grey < 256; grey++) {

		for (d = 0; d < 256; d++)

			d_histo[grey][d] = 0;

		for (x = 0; x < lx; x++)

			y_start[grey][x] = -MAX_WIDTH - 1;

		for (width = 0; width <= MAX_WIDTH; width++)

			lw_histo[grey][width] = 0;

	}

	for (y = 1; y < ly - 1; y++) {

		for (grey = 0; grey < 256; grey++)

			x_start[grey] = -MAX_WIDTH - 1;

		pix = buffer + y * wrap + 1;

		north = pix + wrap;

		south = pix - wrap;

		for (x = 1; x < lx - 1; x++, pix++, north++, south++) {

			d = (int)north[-1] + (int)north[0] * 2 + (int)north[1] - (int)south[-1] - (int)south[0] * 2 - (int)south[1];

			TO_ABS(d)

			dd = (int)north[-1] + (int)pix[-1] * 2 + (int)south[-1] - (int)north[1] - (int)pix[1] * 2 - (int)south[1];

			TO_ABS(dd)

			if (dd > d)

				d = dd;

			dd = (int)pix[-1] + (int)north[-1] * 2 + (int)north[0] - (int)pix[1] - (int)south[1] * 2 - (int)south[0];

			TO_ABS(dd)

			if (dd > d)

				d = dd;

			dd = (int)pix[1] + (int)north[1] * 2 + (int)north[0] - (int)pix[-1] - (int)south[-1] * 2 - (int)south[0];

			TO_ABS(dd)

			if (dd > d)

				d = dd;

			d >>= 3;

			d_histo[*pix][d]++;

			cur_grey = pix[0];

			x_prev_grey = pix[-1];

			x_next_grey = pix[1];

			y_prev_grey = south[0];

			y_next_grey = north[0];

			x_grad = (int)x_next_grey - (int)x_prev_grey;

			y_grad = (int)y_next_grey - (int)y_prev_grey;

			if (cur_grey < x_prev_grey) {

				if (x_grad < 0 && x_grad < y_grad && x_grad < -y_grad)

					for (grey = cur_grey; grey < x_prev_grey; grey++)

						x_start[grey] = x;

				else

					for (grey = cur_grey; grey < x_prev_grey; grey++)

						x_start[grey] = -MAX_WIDTH - 1;

			} else if (cur_grey > x_prev_grey) {

				if (x_grad > 0 && x_grad > y_grad && x_grad > -y_grad)

					for (grey = x_prev_grey; grey < cur_grey; grey++) {

						width = x - x_start[grey];

						if (width <= MAX_WIDTH)

							lw_histo[grey][width]++;

					}

			}

			if (cur_grey < y_prev_grey) {

				if (y_grad < 0 && y_grad < x_grad && y_grad < -x_grad)

					for (grey = cur_grey; grey < y_prev_grey; grey++)

						y_start[grey][x] = y;

				else

					for (grey = cur_grey; grey < y_prev_grey; grey++)

						y_start[grey][x] = -MAX_WIDTH - 1;

			} else if (cur_grey > y_prev_grey) {

				if (y_grad > 0 && y_grad > x_grad && y_grad > -x_grad)

					for (grey = y_prev_grey; grey < cur_grey; grey++) {

						width = y - y_start[grey][x];

						if (width <= MAX_WIDTH)

							lw_histo[grey][width]++;

					}

			}

		}

	}

	for (grey = 0; grey < 256; grey++) {

		n = 0;

		CLEAR_BIG(s);

		for (width = 0; width <= MAX_WIDTH; width++) {

			ADD_BIG(s, lw_histo[grey][width] * width);

			n += lw_histo[grey][width];

		}

		if (n)

			lw[grey] = (float)(BIG_TO_DOUBLE(s) / n);

		else

			lw[grey] = 0.0;

	}

	max_d_grey = 0;

	max_d = 0.0;

	for (grey = 0; grey < 256; grey++) {

		n = 0;

		CLEAR_BIG(s);

		for (d = 0; d < 256; d++) {

			ADD_BIG(s, d_histo[grey][d] * d);

			n += d_histo[grey][d];

		}

		if (n)

			mean_d[grey] = (float)(BIG_TO_DOUBLE(s) / n);

		else

			mean_d[grey] = 0.0;

		if (max_d < mean_d[grey]) {

			max_d = mean_d[grey];

			max_d_grey = grey;

		}

	}

	max_d_n = 0;

	for (width = 0; width <= MAX_WIDTH; width++)

		max_d_n += lw_histo[max_d_grey][width];

	for (grey = max_d_grey - 1; grey >= 0; grey--) {

		if (!lw[grey])

			break;

		n = 0;

		for (width = 0; width <= MAX_WIDTH; width++)

			n += lw_histo[grey][width];

		if (n < max_d_n / 10)

			break;

	}

	for (; grey >= 0; grey--)

		lw[grey] = 0.0;

	for (grey = max_d_grey + 1; grey < 256; grey++) {

		if (!lw[grey])

			break;

		if (255 - grey < (255 - max_d_grey) / 2)

			break;

		if (mean_d[grey] < max_d / 2.0)

			break;

	}

	for (; grey < 256; grey++)

		lw[grey] = 0.0;

}

/*---------------------------------------------------------------------------*/

void build_lw_lut(float ref_lw[256], float lw[256], UCHAR lut[256])

{

	/* crea una lut tale che l'immagine con il profilo di linewidths lw

   venga mappata in un'immagine con il profilo di riferimento ref_lw.

   Le lw sono non decrescenti e delimitate da 0.0 li' dove non sono valide

*/

	int i, j;

	float bot_ref_lw, top_ref_lw, bot_lw, top_lw;

	int bot_ref_gr, top_ref_gr, bot_gr, top_gr;

	float min_lw, max_lw;

	int min_ref_gr, max_ref_gr, min_gr, max_gr;

	float fac;

	for (i = 0; !ref_lw[i]; i++) {

	}

	bot_ref_lw = ref_lw[i];

	bot_ref_gr = i;

	for (i = 255; !ref_lw[i]; i--) {

	}

	top_ref_lw = ref_lw[i];

	top_ref_gr = i;

	for (i = 0; !lw[i]; i++) {

	}

	bot_lw = lw[i];

	bot_gr = i;

	for (i = 255; !lw[i]; i--) {

	}

	top_lw = lw[i];

	top_gr = i;

	min_lw = std::max(bot_ref_lw, bot_lw);

	max_lw = std::min(top_ref_lw, top_lw);

	if (min_lw >= max_lw) {

		for (i = 0; i < 256; i++)

			lut[i] = i;

		return;

	}

	for (i = bot_ref_gr; ref_lw[i] < min_lw; i++) {

	}

	min_ref_gr = i;

	for (i = top_ref_gr; ref_lw[i] > max_lw; i--) {

	}

	max_ref_gr = i;

	for (i = bot_gr; lw[i] < min_lw; i++) {

	}

	min_gr = i;

	for (i = top_gr; lw[i] > max_lw; i--) {

	}

	max_gr = i;

	j = min_ref_gr;

	for (i = min_gr; i <= max_gr; i++) {

		while (ref_lw[j] < lw[i] && j < max_ref_gr)

			j++;

		lut[i] = j;

	}

	fac = (float)min_ref_gr / (float)min_gr;

	for (i = 0; i < min_gr; i++)

		lut[i] = troundp(i * fac);

	fac = (float)(255 - max_ref_gr) / (float)(255 - max_gr);

	for (i = 255; i > max_gr; i--)

		lut[i] = 255 - troundp((255 - i) * fac);

	/***

printf ("-----\n\lut:\n\n");

for (i = 255; i >= 0; i--)

  printf ("%4d :%4u\n", i, lut[i]);

printf ("\n");

***/

}

/*===========================================================================*/

void build_gr_cum(const TRasterImageP &image, int cum[256])

{

	int lx, ly, wrap, true_lx, true_ly;

	int i, x, y;

	UCHAR *pix, *buffer;

	int histo[256], raster_is_savebox;

	get_virtual_buffer(image, &lx, &ly, &wrap, &buffer);

	for (i = 0; i < 256; i++)

		histo[i] = 0;

	for (y = 0; y < ly; y++) {

		pix = buffer + y * wrap;

		for (x = 0; x < lx; x++)

			histo[*pix++]++;

	}

	raster_is_savebox = 1;

	TRect saveBox = image->getSavebox();

	if ((saveBox.getLx() > 0 && saveBox.getLx() < image->getRaster()->getLx()) ||

		(saveBox.getLy() > 0 && saveBox.getLy() < image->getRaster()->getLy()))

		raster_is_savebox = 0;

	if (raster_is_savebox) {

		true_lx = saveBox.getLx() ? saveBox.getLx() : image->getRaster()->getLx();

		true_ly = saveBox.getLy() ? saveBox.getLy() : image->getRaster()->getLy();

	} else {

		true_lx = image->getRaster()->getLx();

		true_ly = image->getRaster()->getLy();

	}

	histo[255] += true_lx * true_ly - lx * ly;

	build_cum(histo, cum);

}

/*---------------------------------------------------------------------------*/

void build_gr_lut(int ref_cum[256], int cum[256], UCHAR lut[256])

{

	/* crea una lut tale che l'immagine con la distribuzione cumulativa cum

   venga mappata in un'immagine con la cumulativa di riferimento ref_cum

*/

	int i, j, n;

	j = 0;

	for (i = 0; i < 256; i++) {

		n = cum[i];

		while (ref_cum[j] < n)

			j++;

		lut[i] = j;

	}

}

/*===========================================================================*/

struct edge_config {

	const char *str;

	int val;

};

static struct edge_config Edge_base[] =

	{

		{"     "

		 "  X  "

		 "     ",

		 0},

		{"X    "

		 "  X  "

		 "     ",

		 0},

		{"  X  "

		 "  X  "

		 "     ",

		 0},

		{"X X  "

		 "  X  "

		 "     ",

		 5},

		{"X   X"

		 "  X  "

		 "     ",

		 20},

		{"X    "

		 "  X X"

		 "     ",

		 24},

		{"X    "

		 "  X  "

		 "    X",

		 28},

		{"  X  "

		 "  X X"

		 "     ",

		 7},

		{"  X  "

		 "  X  "

		 "  X  ",

		 20},

		{"X X X"

		 "  X  "

		 "     ",

		 10},

		{"X X  "

		 "  X X"

		 "     ",

		 12},

		{"X X  "

		 "  X  "

		 "    X",

		 26},

		{"X X  "

		 "  X  "

		 "  X  ",

		 22},

		{"X X  "

		 "  X  "

		 "X    ",

		 22},

		{"X X  "

		 "X X  "

		 "     ",

		 5},

		{"X   X"

		 "  X  "

		 "    X",

		 34},

		{"X   X"

		 "  X  "

		 "  X  ",

		 34},

		{"X    "

		 "  X X"

		 "  X  ",

		 24},

		{"  X  "

		 "  X X"

		 "  X  ",

		 10},

		{"X X X"

		 "  X X"

		 "     ",

		 12},

		{"X X X"

		 "  X  "

		 "    X",

		 24},

		{"X X X"

		 "  X  "

		 "  X  ",

		 24},

		{"X X  "

		 "  X X"

		 "    X",

		 14},

		{"X X  "

		 "  X X"

		 "  X  ",

		 12},

		{"X X  "

		 "  X X"

		 "X    ",

		 22},

		{"X X  "

		 "X X X"

		 "     ",

		 10},

		{"X X  "

		 "  X  "

		 "  X X",

		 24},

		{"X X  "

		 "  X  "

		 "X   X",

		 32},

		{"X X  "

		 "X X  "

		 "    X",

		 24},

		{"X X  "

		 "  X  "

		 "X X  ",

		 20},

		{"X   X"

		 "  X  "

		 "X   X",

		 40},

		{"  X  "

		 "X X X"

		 "  X  ",

		 0},

		{"X X X"

		 "X X X"

		 "     ",

		 10},

		{"X X X"

		 "X X  "

		 "    X",

		 22},

		{"X X  "

		 "X X X"

		 "    X",

		 12},

		{"X   X"

		 "X X X"

		 "    X",

		 22},

		{"  X X"

		 "X X X"

		 "    X",

		 12},

		{"X X X"

		 "  X X"

		 "    X",

		 14},

		{"X X  "

		 "X X X"

		 "  X  ",

		 0},

		{"X   X"

		 "X X X"

		 "  X  ",

		 10},

		{"X   X"

		 "X X  "

		 "  X X",

		 20},

		{"X   X"

		 "X X  "

		 "X   X",

		 30},

		{"X X X"

		 "X X X"

		 "    X",

		 12},

		{"X X X"

		 "X X X"

		 "  X  ",

		 0},

		{"X X X"

		 "X X  "

		 "  X X",

		 10},

		{"  X X"

		 "X X X"

		 "X X  ",

		 0},

		{"X X X"

		 "X X  "

		 "X   X",

		 20},

		{"X   X"

		 "X X X"

		 "X   X",

		 20},

		{"X X X"

		 "X X X"

		 "  X X",

		 0},

		{"X X X"

		 "X X X"

		 "X   X",

		 10},

		{"X X X"

		 "X X X"

		 "X X X",

		 0},

		{0, 0},

};

static int Edge_value[256];

static int Edge_init_done = 0;

static int edge_int(const char x[8]);

static void edge_rotate(char x[8]);

static void edge_mirror(char x[8]);

/*---------------------------------------------------------------------------*/

static void edge_init(void)

{

	int b;

	const char *str;

	int val;

	char x[8];

	for (b = 0; Edge_base[b].str; b++) {

		str = Edge_base[b].str;

		val = Edge_base[b].val;

		x[0] = str[0];

		x[1] = str[2];

		x[2] = str[4];

		x[3] = str[5];

		x[4] = str[9];

		x[5] = str[10];

		x[6] = str[12];

		x[7] = str[14];

		Edge_value[edge_int(x)] = val;

		edge_rotate(x);

		Edge_value[edge_int(x)] = val;

		edge_rotate(x);

		Edge_value[edge_int(x)] = val;

		edge_rotate(x);

		Edge_value[edge_int(x)] = val;

		edge_rotate(x);

		edge_mirror(x);

		Edge_value[edge_int(x)] = val;

		edge_rotate(x);

		Edge_value[edge_int(x)] = val;

		edge_rotate(x);

		Edge_value[edge_int(x)] = val;

		edge_rotate(x);

		Edge_value[edge_int(x)] = val;

	}

	Edge_init_done = 1;

}

/*---------------------------------------------------------------------------*/

static int edge_int(const char x[8])

{

	return (x[0] != ' ') << 7 |

		   (x[1] != ' ') << 6 |

		   (x[2] != ' ') << 5 |

		   (x[3] != ' ') << 4 |

		   (x[4] != ' ') << 3 |

		   (x[5] != ' ') << 2 |

		   (x[6] != ' ') << 1 |