// EraseContour.cpp: implementation of the CEraseContour class.

//

//////////////////////////////////////////////////////////////////////

#include <stdlib.h></stdlib.h>

#include <search.h></search.h>

#include <math.h></math.h>

//#include "myetc.h"

#include "EraseContour.h"

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

CEraseContour::~CEraseContour()

{

	null();

}

void CEraseContour::null()

{

	m_lX = m_lY = 0;

	m_picUC = 0;

	m_picUS = 0;

	m_sel = 0;

	m_ras = 0;

	m_cil.m_nb = 0;

}

int CEraseContour::makeSelectionCMAP32()

{

	UCHAR *pSel = m_sel;

	int xy = 0, nbSel = 0;

	for (int y = 0; y < m_lY; y++)

		for (int x = 0; x < m_lX; x++, xy++, pSel++) {

			int xyRas = y * m_ras->wrap + x;

			UD44_CMAPINDEX32 ci32 = *((UD44_CMAPINDEX32 *)(m_ras->buffer) + xyRas);

			if ((ci32 & 0x000000ff) == 0xff) {

				// Paint color, if transparent 0

				*pSel = (UCHAR)3;

			} else if ((ci32 & 0x000000ff) == 0x0) {

				// Ink color

				if (m_cil.isIn((int)((ci32 >> 20) & 0x00000fff))) {

					*pSel = (UCHAR)1;

					nbSel++;

				}

			} else {

				// Tone color ( antialiasing pixel )

				if (m_cil.isIn((int)((ci32 >> 20) & 0x00000fff))) {

					*pSel = (UCHAR)1;

					nbSel++;

					//					*pSel=(UCHAR)2;

				}

			}

		}

	return nbSel;

}

//  Makes the selection of ink and antialiasing pixels.

//	0 - 0 matte (transparent) OR ink color which is not in m_cil

//  1 - ink pixel, which is in the m_cil

//  1 - antialiasing pixel

//  3 - paint color

int CEraseContour::makeSelection(const CCIL &iil)

{

	int nb = 0;

	m_cil = iil;

	if (m_cil.m_nb <= 0)

		return 0;

	if (m_lX <= 0 || m_lY <= 0 || !m_sel || !m_ras || !(m_picUC || m_picUS))

		return 0;

	memset(m_sel, 0, m_lX * m_lY);

	if (m_ras->type == RAS_CM32)

		nb = makeSelectionCMAP32();

	if (nb > 0)

		sel0123To01();

	return nb;

}

//  Makes the selection of ink and antialiasing pixels.

//  m_cil has been prepared!!

//  0 - 0 matte (transparent) OR ink color which is not in m_cil

//  1 - ink pixel, which is in the m_cil

//  1 - antialiasing pixel

//  3 - paint color

int CEraseContour::makeSelection()

{

	memset(m_sel, 0, m_lX * m_lY);

	if (m_ras->type == RAS_CM32)

		return makeSelectionCMAP32();

	return 0;

}

int CEraseContour::doIt(const CCIL &iil)

{

	int nb = 0;

	m_cil = iil;

	if (m_cil.m_nb <= 0)

		return 0;

	if (m_lX <= 0 || m_lY <= 0 || !m_sel || !m_ras || !(m_picUC || m_picUS))

		return 0;

	nb = makeSelection();

	if (nb > 0) {

		eraseInkColors();

		sel0123To01();

	}

	return nb;

}

void CEraseContour::sel0123To01()

{

	int xy = m_lX * m_lY;

	UCHAR *pSel = m_sel;

	for (int i = 0; i < xy; i++, pSel++)

		*pSel = *(pSel) == (UCHAR)1 ? (UCHAR)1 : (UCHAR)0;

}

void CEraseContour::eraseInkColors()

{

	UCHAR *pSel = m_sel;

	prepareNeighbours();

	for (int y = 0; y < m_lY; y++)

		for (int x = 0; x < m_lX; x++, pSel++)

			if (*pSel == (UCHAR)1 || *pSel == (UCHAR)2) {

				I_PIXEL ip = {0, 0, 0, 0};

				if (findClosestPaint(x, y, ip)) {

					if (m_picUC) {

						UC_PIXEL *uc = m_picUC + y * m_lX + x;

						uc->r = (UCHAR)ip.r;

						uc->g = (UCHAR)ip.g;

						uc->b = (UCHAR)ip.b;

						uc->m = (UCHAR)ip.m;

					} else {

						US_PIXEL *us = m_picUS + y * m_lX + x;

						us->r = (USHORT)ip.r;

						us->g = (USHORT)ip.g;

						us->b = (USHORT)ip.b;

						us->m = (USHORT)ip.m;

					}

				}

			}

}

int erasecontour_xydwCompare(const void *a, const void *b)

{

	SXYDW *aa = (SXYDW *)a;

	SXYDW *bb = (SXYDW *)b;

	if (aa->w < bb->w)

		return -1;

	if (aa->w > bb->w)

		return 1;

	return 0;

}

void CEraseContour::prepareNeighbours()

{

	int q = ((int)sqrt((double)MAXNB_NEIGHBOURS) - 1) / 2;

	m_nbNeighbours = 0;

	for (int y = -q; y <= q; y++)

		for (int x = -q; x <= q; x++) {

			m_neighbours[m_nbNeighbours].x = x;

			m_neighbours[m_nbNeighbours].y = y;

			m_neighbours[m_nbNeighbours].w = sqrt((double)(x * x + y * y));

			m_nbNeighbours++;

		}

	qsort(m_neighbours, m_nbNeighbours, sizeof(SXYDW), erasecontour_xydwCompare);

}

bool CEraseContour::findClosestPaint(const int xx, const int yy, I_PIXEL &ip)

{

	for (int i = 0; i < m_nbNeighbours; i++) {

		int x = xx + m_neighbours[i].x;

		int y = yy + m_neighbours[i].y;

		if (x >= 0 && y >= 0 && x < m_lX && y < m_lY)

			if (*(m_sel + y * m_lX + x) == (UCHAR)3) {

				if (m_picUC) {

					UC_PIXEL *uc = m_picUC + y * m_lX + x;

					ip.r = (int)uc->r;

					ip.g = (int)uc->g;

					ip.b = (int)uc->b;

					ip.m = (int)uc->m;

				} else {

					US_PIXEL *us = m_picUS + y * m_lX + x;

					ip.r = (int)us->r;

					ip.g = (int)us->g;

					ip.b = (int)us->b;

					ip.m = (int)us->m;

				}

				return true;

			}

	}

	ip.r = ip.g = ip.b = ip.m = 0;

	return false;

}