#include "autopos.h"

#include "cleanupcommon.h"

using namespace CleanupTypes;

/*

guardare DAFARE

guardare assumo

autoalign rgb ->ora viene chiamata con un buffer rgbm ! modificare opportunamente

fare resize e realloc size dello stack a 65000 unita' 

*/

#if defined(MACOSX) || defined(LINUX)

#define TRUE 1

#define FALSE 0

#endif

#define SECURITY_MARGIN_MM 4.0

static int Debug_flag = FALSE;

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

/*

     AUTOALIGNMENT 

*/

#define AUTOAL_BLACK_COLS 2

#define AUTOAL_WHITE_COLS 2

#define AUTOAL_THRESHOLD 160

static int autoalign_gr8(UCHAR *buffer_gr8,

						 int wrap, int lx, int ly, int pix_origin,

						 int dpix_dx, int dpix_dy, int strip_width)

{

	int first_x[2], dx_dcol[2], target[2];

	int i, x, y, cols;

	int col_value, threshold;

	int consec_black_cols, consec_white_cols, black_strip_edge;

	UCHAR *pix, *origin;

	int delta_x, delta_pix;

	origin = buffer_gr8 + pix_origin;

	first_x[0] = 0;

	dx_dcol[0] = 1;

	target[0] = strip_width / 2;

	first_x[1] = lx - 1;

	dx_dcol[1] = -1;

	target[1] = lx - 1 - strip_width / 2;

	threshold = AUTOAL_THRESHOLD * ly;

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

		consec_black_cols = 0;

		consec_white_cols = 0;

		black_strip_edge = 0;

		for (x = first_x[i], cols = 0; cols < strip_width; x += dx_dcol[i], cols++) {

			col_value = 0;

			pix = origin + x * dpix_dx;

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

				col_value += *pix;

				pix += dpix_dy;

			}

			if (col_value < threshold) {

				consec_white_cols = 0;

				consec_black_cols++;

				if (consec_black_cols >= AUTOAL_BLACK_COLS)

					black_strip_edge = x;

			} else {

				consec_black_cols = 0;

				consec_white_cols++;

				if (consec_white_cols >= AUTOAL_WHITE_COLS && black_strip_edge)

					goto found;

			}

		}

	}

	return FALSE;

found:

	for (x = first_x[i], cols = 0; cols < strip_width; x += dx_dcol[i], cols++) {

		pix = origin + x * dpix_dx;

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

			*pix = 255;

			pix += dpix_dy;

		}

	}

	delta_x = target[i] - black_strip_edge;

	delta_pix = delta_x * dpix_dx;

	if (delta_x > 0) {

		for (x = lx - 1 - delta_x; x >= 0; x--) {

			pix = origin + x * dpix_dx;

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

				*(pix + delta_pix) = *pix;

				pix += dpix_dy;

			}

		}

		for (x = lx - delta_x; x < lx; x++) {

			pix = origin + x * dpix_dx;

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

				*pix = 255;

				pix += dpix_dy;

			}

		}

	} else if (delta_x < 0) {

		for (x = -delta_x; x < lx; x++) {

			pix = origin + x * dpix_dx;

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

				*(pix + delta_pix) = *pix;

				pix += dpix_dy;

			}

		}

		for (x = 0; x < -delta_x; x++) {

			pix = origin + x * dpix_dx;

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

				*pix = 255;

				pix += dpix_dy;

			}

		}

	}

	return TRUE;

}

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

static int autoalign_rgb(TPixel32 *buffer_rgb,

						 int wrap, int lx, int ly, int pix_origin,

						 int dpix_dx, int dpix_dy, int strip_width)

{

	int first_x[2], dx_dcol[2], target[2];

	int i, x, y, cols;

	int col_value, threshold;

	int consec_black_cols, consec_white_cols, black_strip_edge;

	TPixel32 *pix, *origin;

	int delta_x, delta_pix;

	origin = buffer_rgb + pix_origin;

	first_x[0] = 0;

	dx_dcol[0] = 1;

	target[0] = strip_width / 2;

	first_x[1] = lx - 1;

	dx_dcol[1] = -1;

	target[1] = lx - 1 - strip_width / 2;

	threshold = AUTOAL_THRESHOLD * ly;

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

		consec_black_cols = 0;

		consec_white_cols = 0;

		black_strip_edge = 0;

		for (x = first_x[i], cols = 0; cols < strip_width; x += dx_dcol[i], cols++) {

			col_value = 0;

			pix = origin + x * dpix_dx;

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

				col_value += (pix->r * 2 + pix->g * 5 + pix->b) >> 3;

				pix += dpix_dy;

			}

			if (col_value < threshold) {

				consec_white_cols = 0;

				consec_black_cols++;

				if (consec_black_cols >= AUTOAL_BLACK_COLS)

					black_strip_edge = x;

			} else {

				consec_black_cols = 0;

				consec_white_cols++;

				if (consec_white_cols >= AUTOAL_WHITE_COLS && black_strip_edge)

					goto found;

			}

		}

	}

	return FALSE;

found:

	for (x = first_x[i], cols = 0; cols < strip_width; x += dx_dcol[i], cols++) {

		pix = origin + x * dpix_dx;

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

			pix->r = pix->g = pix->b = 255;

			pix += dpix_dy;

		}

	}

	delta_x = target[i] - black_strip_edge;

	delta_pix = delta_x * dpix_dx;

	if (delta_x > 0) {

		for (x = lx - 1 - delta_x; x >= 0; x--) {

			pix = origin + x * dpix_dx;

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

				(pix + delta_pix)->r = pix->r;

				(pix + delta_pix)->g = pix->g;

				(pix + delta_pix)->b = pix->b;

				pix += dpix_dy;

			}

		}

		for (x = lx - delta_x; x < lx; x++) {

			pix = origin + x * dpix_dx;

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

				pix->r = pix->g = pix->b = 255;

				pix += dpix_dy;

			}

		}

	} else if (delta_x < 0) {

		for (x = -delta_x; x < lx; x++) {

			pix = origin + x * dpix_dx;

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

				(pix + delta_pix)->r = pix->r;

				(pix + delta_pix)->g = pix->g;

				(pix + delta_pix)->b = pix->b;

				pix += dpix_dy;

			}

		}

		for (x = 0; x < -delta_x; x++) {

			pix = origin + x * dpix_dx;

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

				pix->r = pix->g = pix->b = 255;

				pix += dpix_dy;

			}

		}

	}

	return TRUE;

}

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

//static void make_bitcount (int b[256], int count_zeros)

//{

//int i, j, xorValue;

//xorValue = count_zeros ? 0xff : 0;

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

//  {

//  b[i] = 0;

//  for (j = i ^ xorValue; j; j &= j - 1)

//    b[i]++;

//  }

//}

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

//static int autoalign_bw (UCHAR *buffer_bw, bool isWB /*true se WB, false se BW*/,

//                         int wrap, int lx, int ly, int pix_origin,

//			 int dpix_dx, int dpix_dy, int strip_width)

//{

/* SOLTANTO PER MAIN SCAN VERTICALE */

/* LA PARTE DOPO found FUNZIONA SOLO PER ly MULTIPLO DI 8 */

/* LA PARTE PRIMA BUTTA VIA I BYTE FRAZIONARI */

/*

int first_x[2], dx_dcol[2], target[2];

int i, x, y, cols;

int col_value, threshold;

int consec_black_cols, consec_white_cols, black_strip_edge;

UCHAR *byte, *origin, white;

int delta_x, delta_bytes;

int ly_bytes, dbytes_dx, dbytes_dybytes;

int bitcount[256];

make_bitcount (bitcount, isWB);

ly_bytes = ly / 8;

dbytes_dx = dpix_dx / 8;

dbytes_dybytes = dpix_dy;

if (dpix_dy > 0 && (pix_origin & 7) != 0)

  pix_origin = (pix_origin | 7) + 1;

if (dpix_dy < 0 && (pix_origin & 7) != 7)

  pix_origin = (pix_origin & ~7) - 1;

origin = buffer_bw + (pix_origin + 7) / 8;

first_x[0] =      0; dx_dcol[0] =  1; target[0] =          strip_width / 2;

first_x[1] = lx - 1; dx_dcol[1] = -1; target[1] = lx - 1 - strip_width / 2;

threshold = ly / 2;

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

  {

  consec_black_cols = 0;

  consec_white_cols = 0;

  black_strip_edge  = 0;

  for (x = first_x[i], cols = 0; cols < strip_width; x += dx_dcol[i], cols++)

    {

    col_value = 0;

    byte = origin + x * dbytes_dx;

    for (y = 0; y < ly_bytes; y++)

      {

      col_value += bitcount[*byte];

      byte += dbytes_dybytes;

      }

    if (col_value < threshold)

      {

      consec_white_cols = 0;

      consec_black_cols++;

      if (consec_black_cols >= AUTOAL_BLACK_COLS)

	black_strip_edge = x;

      }

    else

      {

      consec_black_cols = 0;

      consec_white_cols++;

      if (consec_white_cols >= AUTOAL_WHITE_COLS && black_strip_edge)

	goto found;

      }

    }

  }

return FALSE;

found:

white = isWB ? 0 : 255;

for (x = first_x[i], cols = 0; cols < strip_width; x += dx_dcol[i], cols++)

  {

  byte = origin + x * dbytes_dx;

  for (y = 0; y < ly_bytes; y++)

    {

    *byte = white;

    byte += dbytes_dybytes;

    }

  }

delta_x = target[i] - black_strip_edge;

delta_bytes = delta_x * dbytes_dx;

if (delta_x > 0)

  {

  for (x = lx - 1 - delta_x; x >= 0; x--)

    {

    byte = origin + x * dbytes_dx;

    for (y = 0; y < ly_bytes; y++)

      {

      *(byte + delta_bytes) = *byte;

      byte += dbytes_dybytes;

      }

    }

  for (x = lx - delta_x; x < lx; x++)

    {

    byte = origin + x * dbytes_dx;

    for (y = 0; y < ly_bytes; y++)

      {

      *byte = white;

      byte += dbytes_dybytes;

      }

    }

  }

else if (delta_x < 0)

  {

  for (x = -delta_x; x < lx; x++)

    {

    byte = origin + x * dbytes_dx;

    for (y = 0; y < ly_bytes; y++)

      {

      *(byte + delta_bytes) = *byte;

      byte += dbytes_dybytes;

      }

    }

  for (x = 0; x < -delta_x; x++)

    {

    byte = origin + x * dbytes_dx;

    for (y = 0; y < ly_bytes; y++)

      {

      *byte = white;

      byte += dbytes_dybytes;

      }

    }

  }

return TRUE;

}

*/

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

int do_autoalign(const TRasterImageP &image)

{

	int wrap, lx, ly, mx, my;

	int pix_origin, dpix_dx, dpix_dy;

	int strip_width;

	/*

Non viene presa in considerazione una eventuale savebox

*/

	/*

Per adesso non scrivo l'algo per wb con primary scan orizzontale, quindi:

assert (image->orientation == TOR_LEFTBOT  ||

        image->orientation == TOR_RIGHTBOT ||

        image->orientation == TOR_LEFTTOP  ||

        image->orientation == TOR_RIGHTTOP    );

*/

	/* DAFARE

if (    image->orientation != TOR_LEFTBOT  &&

        image->orientation != TOR_RIGHTBOT &&

        image->orientation != TOR_LEFTTOP  &&

        image->orientation != TOR_RIGHTTOP    )

 {

  tmsg_error(" autoalign error: bad image orientation");

  return FALSE;

 }

*/

	// assumo che sia sempre orientata nel modo corretto

	TRasterP ras = image->getRaster();

	wrap = ras->getWrap();

	assert(TRaster32P(ras) || TRasterGR8P(ras)); //per ricordare di gestire le img bw!

	/* DAFARE

if (rop_pixbits (image->ras.type) < 8 && rop_fillerbits (image->ras.type))

  wrap = (wrap + 7) / 8 * 8;

*/

	/* DAFARE

switch (image->orientation)

  {

  CASE TOR_BOTLEFT:__OR TOR_BOTRIGHT:__OR TOR_TOPLEFT:__OR TOR_TOPRIGHT:

    strip_width = mmToPixel (5.0, image->x_dpi);

    lx = image->ras.lx;

    ly = image->ras.ly;

  CASE TOR_LEFTBOT:__OR TOR_RIGHTBOT:__OR TOR_LEFTTOP:__OR TOR_RIGHTTOP:

    strip_width = mmToPixel (5.0, image->y_dpi);

    lx = image->ras.ly;

    ly = image->ras.lx;

  DEFAULT: assert (FALSE);lx=ly=strip_width=0;

  }

*/

	//assumo TOR_BOTLEFT:__OR TOR_BOTRIGHT:__OR TOR_TOPLEFT:__OR TOR_TOPRIGHT:

	double dpix, dpiy;

	image->getDpi(dpix, dpiy);

	strip_width = (int)mmToPixel(5.0, dpix);

	lx = ras->getLx();

	ly = ras->getLy();

	mx = lx - 1;

	my = ly - 1;

	/* DAFARE

switch (image->orientation)

  {

  CASE TOR_BOTLEFT:

    pix_origin = 0;

    dpix_dx =  1;

    dpix_dy =  wrap;

  CASE TOR_BOTRIGHT:

    pix_origin = mx;

    dpix_dx = -1;

    dpix_dy =  wrap;

  CASE TOR_TOPLEFT:

    pix_origin = my * wrap;

    dpix_dx =  1;

    dpix_dy = -wrap;

  CASE TOR_TOPRIGHT:

    pix_origin = mx + my * wrap;

    dpix_dx = -1;

    dpix_dy = -wrap;

  CASE TOR_LEFTBOT:

    pix_origin = 0;

    dpix_dx =  wrap;

    dpix_dy =  1;

  CASE TOR_RIGHTBOT:

    pix_origin = mx * wrap;

    dpix_dx = -wrap;

    dpix_dy =  1;

  CASE TOR_LEFTTOP:

    pix_origin = my;

    dpix_dx =  wrap;

    dpix_dy = -1;

  CASE TOR_RIGHTTOP:

    pix_origin = my + mx * wrap;

    dpix_dx = -wrap;

    dpix_dy = -1;

  DEFAULT: assert(FALSE); pix_origin=dpix_dx=dpix_dy=0;

  }

*/

	//assumo  CASE TOR_BOTLEFT:

	pix_origin = 0;

	dpix_dx = 1;

	dpix_dy = wrap;

	TRasterGR8P ras8(ras);

	TRaster32P ras32(ras);

	ras->lock();

	int ret = FALSE;

	if (ras8)

		ret = autoalign_gr8(ras8->getRawData(), wrap, lx, ly, pix_origin,

							dpix_dx, dpix_dy, strip_width);

	else if (ras32)

		ret = autoalign_rgb(ras32->pixels(), wrap, lx, ly, pix_origin,

							dpix_dx, dpix_dy, strip_width);

	else

		assert(!"Unsupported pixel type");

	ras->unlock();

	/*

  CASE RAS_WB:

  __OR RAS_BW:

    assert ( !image->ras.bit_offs);

    return autoalign_bw (image->ras.buffer, image->ras.type,

                         wrap, lx, ly, pix_origin,

		         dpix_dx, dpix_dy, strip_width);

  DEFAULT: assert (!"Unsupported alignment\n");

  }

*/

	return FALSE;

}

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

/*

     AUTOCENTERING

*/

/*

 * Calcoli in millimetri per questa funzione che alla fine restituisce un 

 * valore per la striscia di ricerca direttamente in pixel

 */

int compute_strip_pixel(FDG_INFO *fdg, double dpi)

{

	int i, strip_size_pix;

	double half_size, max_half_size, strip_size_mm;

	max_half_size = -1.0;

	for (i = 0; i < (int)fdg->dots.size(); i++) {

		half_size = (double)fdg->dots[i].lx * 0.5;

		if (max_half_size < half_size)

			max_half_size = half_size;

	}

	strip_size_mm = fdg->dist_ctr_hole_to_edge +

					max_half_size +

					SECURITY_MARGIN_MM;

	strip_size_pix = (int)mmToPixel(strip_size_mm, dpi);

	if (Debug_flag)

		printf("Controllo una striscia larga %g mm e %d pixels\n",

			   strip_size_mm, strip_size_pix);

	return strip_size_pix;

}

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

#define SQMM_TO_SQPIXEL(area, x_res, y_res) \

	((double)((x_res) * (y_res)) * (double)(area) * ((1.0 / 25.4) * (1.0 / 25.4)))

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

void convert_dots_mm_to_pixel(DOT *dots, int nd, double x_res, double y_res)

{

	int i;

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

		dots[i].x1 = troundp(mmToPixel(dots[i].x1, x_res));

		dots[i].y1 = troundp(mmToPixel(dots[i].y1, y_res));

		dots[i].x2 = troundp(mmToPixel(dots[i].x2, x_res));

		dots[i].y2 = troundp(mmToPixel(dots[i].y2, y_res));

		dots[i].x = (float)mmToPixel(dots[i].x, x_res);

		dots[i].y = (float)mmToPixel(dots[i].y, y_res);

		dots[i].lx = troundp(mmToPixel(dots[i].lx, x_res));

		dots[i].ly = troundp(mmToPixel(dots[i].ly, y_res));

		dots[i].area = troundp(SQMM_TO_SQPIXEL(dots[i].area, x_res, y_res));

	}

	return;

}

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

static char *Done = 0;

static int Done_rowsize = 0;

static int Done_colsize = 0;

#define DONE_MASK(I, J) (1 << (((I) + (J)*Done_rowsize) & 7))

#define DONE_BYTE(I, J) (((I) + (J)*Done_rowsize) >> 3)

#define SET_DONE(I, J) (Done[DONE_BYTE(I, J)] |= DONE_MASK(I, J))

#define NOT_DONE(I, J) (!(Done[DONE_BYTE(I, J)] & DONE_MASK(I, J)))

static int Pix_ystep = 0;

typedef struct big {

	unsigned lo, hi;

} BIG;

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

#define ADDBIG(B, X) ((B).lo += (unsigned)(X), \

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

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

#define IS_BLACK_GR8(PIX) (*(PIX) < 110)

#define IS_VERY_BLACK_GR8(PIX) (*(PIX) < 30)

#define BLACK_WEIGHT_GR8(PIX) (256 - *(PIX))

#define RGBR(PIX) ((PIX)->r << 1)

#define RGBG(PIX) ((PIX)->g << 2)

#define RGBB(PIX) ((PIX)->b)

#define RGBVAL(PIX) (RGBR(PIX) + RGBG(PIX) + RGBB(PIX))

#define IS_BLACK_RGB(PIX) (RGBVAL(PIX) < 110 * 7)

#define IS_VERY_BLACK_RGB(PIX) (RGBVAL(PIX) < 30 * 7)

#define BLACK_WEIGHT_RGB(PIX) ((256 * 7 - RGBVAL(PIX)) >> 3)

static BIG Xsum, Ysum, Weightsum;

static int Xmin, Xmax, Ymin, Ymax, Npix;

#ifdef RECURSIVE_VERSION

static int Level, Max_level;

#endif

static int Very_black_found;

#ifdef DAFARE

#ifdef RECURSIVE_VERSION

static int Black_pixel = 0;

#endif

#endif

#ifdef DAFARE

static int find_dots_bw(const TRasterP &img, int strip_width, PEGS_SIDE pegs_side,

						DOT dotarray[], int dotarray_size, int max_area);

#endif

static int find_dots_gr8(const TRasterGR8P &img, int strip_width, PEGS_SIDE pegs_side,

						 DOT dotarray[], int dotarray_size, int max_area);

static int find_dots_rgb(const TRaster32P &img, int strip_width, PEGS_SIDE pegs_side,

						 DOT dotarray[], int dotarray_size, int max_area);

static void

#ifdef DAFARE

visit_bw(int i, int j, int x, int y, int bit, UCHAR *byte),

#endif

	visit_gr8(int i, int j, int x, int y, UCHAR *pix),

	visit_rgb(int i, int j, int x, int y, TPixel32 *pix),

	stampa_dot(DOT *dot);

static int

compare_dots(DOT dots[], int *ndots, DOT reference[], int ref_dot);

#define REVERSE(byte, bit)  \

	{                       \

		unsigned char mask; \

		mask = 1 << (bit);  \

		*(byte) ^= mask;    \

	}

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

typedef struct

	{

	short ret, bit;

	int x, y, i, j;

	void *ptr;

} STACK_INFO;

static STACK_INFO *Stack = 0;

static int Stack_alloc_size = 0;

static int Stack_size = 0;

#define CREATE_STACK                                                         \

	{                                                                        \

		assert(!Stack);                                                      \

		Stack_alloc_size = 65500;                                            \

		Stack_size = 0;                                                      \

		Stack = (STACK_INFO *)malloc(Stack_alloc_size * sizeof(STACK_INFO)); \

		if (!Stack)                                                          \

			return FALSE;                                                    \

	}

#define DESTROY_STACK         \

	{                         \

		Stack_alloc_size = 0; \

		Stack_size = 0;       \

		free(Stack);          \

		Stack = 0;            \

	}

#define STACK_IS_EMPTY (!Stack_size)

#define PUSH_ONTO_STACK(RET, X, Y, I, J, BIT, PTR)                                       \

	{                                                                                    \

		if (Stack_size >= Stack_alloc_size) {                                            \

			Stack_alloc_size += 65500;                                                   \

			Stack = (STACK_INFO *)realloc(Stack, Stack_alloc_size * sizeof(STACK_INFO)); \

			if (!Stack)                                                                  \

				return;                                                                  \

		}                                                                                \

		Stack[Stack_size].ret = (RET);                                                   \

		Stack[Stack_size].x = (X);                                                       \

		Stack[Stack_size].y = (Y);                                                       \

		Stack[Stack_size].i = (I);                                                       \

		Stack[Stack_size].j = (J);                                                       \

		Stack[Stack_size].bit = (BIT);                                                   \

		Stack[Stack_size].ptr = (PTR);                                                   \

		Stack_size++;                                                                    \

	}

#define POP_FROM_STACK_U(RET, X, Y, I, J, BIT, PTR) \

	{                                               \

		Stack_size--;                               \

		(RET) = Stack[Stack_size].ret;              \

		(X) = Stack[Stack_size].x;                  \

		(Y) = Stack[Stack_size].y;                  \

		(I) = Stack[Stack_size].i;                  \

		(J) = Stack[Stack_size].j;                  \

		(BIT) = Stack[Stack_size].bit;              \

		(PTR) = (UCHAR *)Stack[Stack_size].ptr;     \

	}

#define POP_FROM_STACK_TPIXEL32(RET, X, Y, I, J, BIT, PTR) \

	{                                                      \

		Stack_size--;                                      \

		(RET) = Stack[Stack_size].ret;                     \

		(X) = Stack[Stack_size].x;                         \

		(Y) = Stack[Stack_size].y;                         \

		(I) = Stack[Stack_size].i;                         \

		(J) = Stack[Stack_size].j;                         \

		(BIT) = Stack[Stack_size].bit;                     \

		(PTR) = (TPixel32 *)Stack[Stack_size].ptr;         \

	}

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

static int find_dots(const TRasterP &img, int strip_width, PEGS_SIDE pegs_side,

					 DOT dotarray[], int dotarray_size, int max_area)

{

	TRaster32P ras32(img);

	if (ras32)

		return find_dots_rgb(ras32, strip_width, pegs_side, dotarray, dotarray_size,

							 max_area);

	TRasterGR8P ras8(img);

	if (ras8)

		return find_dots_gr8(ras8, strip_width, pegs_side, dotarray, dotarray_size,

							 max_area);

	assert(!"Unsupported pixel type");

	/* DAFARE

  CASE RAS_BW:

  __OR RAS_WB:

    return find_dots_bw (img, strip_width, pegs_side, dotarray, dotarray_size,

                              max_area);

*/

	return 0;

}

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

#ifdef DAFARE

static int find_dots_bw(const TRasterP &img, int strip_width, PEGS_SIDE pegs_side,

						DOT dotarray[], int dotarray_size, int max_area)

{

	int n_dots, ins, shift;

	int x, y; // coords in img coord system

	int i, j; // coords in done coord system

	int x0, y0, xsize, ysize, xlast, ylast, bit;

	UCHAR *byte, *buffer;

	int dot_lx, dot_ly;

	float dot_x, dot_y;

	int vertical;

	if (img->type == RAS_WB)

		Black_pixel = 1;

	else if (img->type == RAS_BW)

		Black_pixel = 0;

	else {

		TERROR("find dots error: bad image type");

		return 0;

	}

	switch (pegs_side) {

		CASE PEGS_BOTTOM : __OR PEGS_TOP : x0 = 0;

		y0 = pegs_side == PEGS_BOTTOM ? 0 : img->ly - strip_width;

		xsize = img->lx;

		ysize = strip_width;

		vertical = FALSE;

		CASE PEGS_LEFT : __OR PEGS_RIGHT : x0 = pegs_side == PEGS_LEFT ? 0 : img->lx - strip_width;

		y0 = 0;

		xsize = strip_width;

		ysize = img->ly;

		vertical = TRUE;

	DEFAULT : {

		ostrstream os;

		os << "find dots internal error: pegs_side = " << std::hex << pegs_side << '\0';

		os.freeze(false);

		throw TCleanupException(os.str());

		x0 = y0 = xsize = ysize = vertical = 0;

	}

	}

	xlast = x0 + xsize - 1;

	ylast = y0 + ysize - 1;

	n_dots = 0;

	Done_rowsize = xsize + 2;

	Done_colsize = ysize + 2;

	Done = (char *)calloc((size_t)((Done_rowsize * Done_colsize + 7) >> 3), sizeof(char));

	if (!Done) {

		throw TCleanupException("find_dots: out of memory");

	}

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

		SET_DONE(i, 0);

		SET_DONE(i, Done_colsize - 1);

	}

	for (j = 0; j < Done_colsize; j++) {

		SET_DONE(0, j);

		SET_DONE(Done_rowsize - 1, j);

	}

	buffer = (UCHAR *)img->buffer;

	Pix_ystep = (img->wrap + 7) >> 3;

	if (Debug_flag) {

		printf("Zona di scansione: (%d,%d) -- (%d,%d)\n",

			   x0, y0, xlast, ylast);

		printf("wrap: %d\n", img->wrap);

	}

#ifdef RECURSIVE_VERSION

	Max_level = max_area * 6 / 5;

#endif

	CREATE_STACK

	for (j = 1, y = y0; y <= ylast; j++, y++) {

		bit = 7 - (x0 & 7);

		byte = buffer + (x0 >> 3) + y * Pix_ystep;

		for (i = 1, x = x0; x <= xlast; i++, x++) {

			if (NOT_DONE(i, j) && ((*byte >> bit) & 1) == Black_pixel) {

				CLEARBIG(Xsum);

				CLEARBIG(Ysum);

				CLEARBIG(Weightsum);

				Xmin = Xmax = x;

				Ymin = Ymax = y;

				Npix = 0;

#ifdef RECURSIVE_VERSION

				Level = 0;

#endif

				visit_bw(i, j, x, y, bit, byte);

				dot_lx = Xmax - Xmin + 1;

				dot_ly = Ymax - Ymin + 1;

				if (Npix < max_area * 3 / 2 &&

					dot_lx > 3 && dot_lx < (xsize >> 1) &&

					dot_ly > 3 && dot_ly < (ysize >> 1) &&

					Xmin > x0 && Xmax < xlast &&

					Ymin > y0 && Ymax < ylast) {

					dot_x = BIG_TO_DOUBLE(Xsum) / BIG_TO_DOUBLE(Weightsum);

					dot_y = BIG_TO_DOUBLE(Ysum) / BIG_TO_DOUBLE(Weightsum);

					if (vertical) {

						for (ins = 0; ins < n_dots; ins++)

							if (dotarray[ins].y > dot_y)

								break;

					} else {

						for (ins = 0; ins < n_dots; ins++)

							if (dotarray[ins].x > dot_x)

								break;

					}

					for (shift = n_dots - 1; shift >= ins; shift--)

						dotarray[shift + 1] = dotarray[shift];

					n_dots++;

					dotarray[ins].x1 = Xmin;

					dotarray[ins].x2 = Xmax;

					dotarray[ins].y1 = Ymin;

					dotarray[ins].y2 = Ymax;

					dotarray[ins].lx = dot_lx;

					dotarray[ins].ly = dot_ly;

					dotarray[ins].area = Npix;

					dotarray[ins].x = dot_x;

					dotarray[ins].y = dot_y;

					if (n_dots >= dotarray_size)

						goto end_loop;

				}

			}

			if (bit == 0) {

				bit = 7;

				byte++;

			} else

				bit--;

		}

	}

end_loop:

	DESTROY_STACK

	free(Done);

	Done = NIL;

	return n_dots;

}

#endif