#include "trastercm.h"

#include "toonz/fill.h"

#include "tregion.h"

#include "tstroke.h"

#include "tvectorimage.h"

#include "toonz/ttileset.h"

#include "toonz/ttilesaver.h"

#include "toonz/toonzimageutils.h"

#include "skeletonlut.h"

#include "tpixelutils.h"

#include <stack></stack>

using namespace SkeletonLut;

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

namespace

{ // Utility Function

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

void computeSeeds(const TRasterCM32P &r, TStroke *stroke,

				  std::vector<std::pair<tpoint, int="">> &seeds)</std::pair<tpoint,>

{

	int length = (int)stroke->getLength();

	TRect bbox = r->getBounds();

	TPoint oldP;

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

		TPoint p = convert(stroke->getPointAtLength(i));

		if (p == oldP || !bbox.contains(p))

			continue;

		seeds.push_back(std::pair<tpoint, int="">(p, (r->pixels(p.y) + p.x)->getPaint()));</tpoint,>

		oldP = p;

	}

}

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

void fillArea(const TRasterCM32P &ras, TRegion *r, int colorId,

			  bool onlyUnfilled, bool fillPaints, bool fillInks)

{

	TRect bbox = convert(r->getBBox());

	bbox *= ras->getBounds();

	ras->lock();

	for (int i = bbox.y0; i <= bbox.y1; i++) {

		TPixelCM32 *line = ras->pixels(i);

		std::vector<double> intersections;</double>

		r->computeScanlineIntersections(i, intersections);

		assert(!(intersections.size() & 0x1));

		for (UINT j = 0; j < intersections.size(); j += 2) {

			if (intersections[j] == intersections[j + 1])

				continue;

			int from = std::max(tfloor(intersections[j]), bbox.x0);

			int to = std::min(tceil(intersections[j + 1]), bbox.x1);

			TPixelCM32 *pix = line + from;

			for (int k = from; k < to; k++, pix++) {

				if (fillPaints && (!onlyUnfilled || pix->getPaint() == 0))

					pix->setPaint(colorId);

				if (fillInks)

					pix->setInk(colorId);

			}

		}

	}

	ras->unlock();

}

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

void restoreColors(const TRasterCM32P &r, const std::vector<std::pair<tpoint, int="">> &seeds)</std::pair<tpoint,>

{

	FillParameters params;

	for (UINT i = 0; i < seeds.size(); i++) {

		params.m_p = seeds[i].first;

		params.m_styleId = seeds[i].second;

		fill(r, params);

	}

}

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

/*!

  Return true if all \b pixels in \b rect are pure paint; otherwise return false.

*/

bool areRectPixelsPurePaint(TPixelCM32 *pixels, TRect rect, int wrap)

{

	int dx = rect.x1 - rect.x0;

	TPixelCM32 *pix = pixels + rect.y0 * wrap + rect.x0;

	int x, y;

	for (y = rect.y0; y <= rect.y1; y++, pix += wrap - dx - 1)

		for (x = rect.x0; x <= rect.x1; x++, pix++)

			if (!pix->isPurePaint())

				return false;

	return true;

}

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

/*!

  Return true if all \b pixels in \b rect are transparent; otherwise return false.

*/

bool areRectPixelsTransparent(TPixel32 *pixels, TRect rect, int wrap)

{

	int dx = rect.x1 - rect.x0;

	TPixel32 *pix = pixels + rect.y0 * wrap + rect.x0;

	int x, y;

	for (y = rect.y0; y <= rect.y1; y++, pix += wrap - dx - 1)

		for (x = rect.x0; x <= rect.x1; x++, pix++)

			if (pix->m <= 0)

				return false;

	return true;

}

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

} //namespace

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

//=============================================================================

// AreaFiller

AreaFiller::AreaFiller(const TRasterCM32P &ras)

	: m_ras(ras), m_bounds(ras->getBounds()), m_pixels(ras->pixels()), m_wrap(ras->getWrap()), m_color(0)

{

	m_ras->lock();

}

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

AreaFiller::~AreaFiller()

{

	m_ras->unlock();

}

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

// questa funzione viene chiamata dopo il fill rect delle aree, e colora gli inchiostri di tipo "autoink"

// che confinano con le aree appena fillate con il rect. rbefore e' il rect del raster prima del rectfill.

void fillautoInks(TRasterCM32P &rin, TRect &rect, const TRasterCM32P &rbefore, TPalette *plt)

{

	assert(plt);

	TRasterCM32P r = rin->extract(rect);

	assert(r->getSize() == rbefore->getSize());

	int i, j;

	for (i = 0; i < r->getLy(); i++) {

		TPixelCM32 *pix = r->pixels(i);

		TPixelCM32 *pixb = rbefore->pixels(i);

		for (j = 0; j < r->getLx(); j++, pix++, pixb++) {

			int paint = pix->getPaint();

			int tone = pix->getTone();

			int ink = pix->getInk();

			if (paint != pixb->getPaint() && tone > 0 && tone < 255 && ink != paint && plt->getStyle(ink)->getFlags() != 0)

				inkFill(rin, TPoint(j, i) + rect.getP00(), paint, 0, NULL, &rect);

		}

	}

}

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

void AreaFiller::rectFill(const TRect &rect, int color,

						  bool onlyUnfilled, bool fillPaints, bool fillInks)

{

	//Viene trattato il caso fillInks

	/*- FillInkのみの場合 -*/

	if (!fillPaints) {

		assert(fillInks);

		assert(m_ras->getBounds().contains(rect));

		for (int y = rect.y0; y <= rect.y1; y++) {

			TPixelCM32 *pix = m_ras->pixels(y) + rect.x0;

			for (int x = rect.x0; x <= rect.x1; x++, pix++)

				pix->setInk(color);

		}

		return;

	}

	TRect r = m_bounds * rect;

	int dx = r.x1 - r.x0;

	int dy = (r.y1 - r.y0) * m_wrap;

	if (dx < 2 || dy < 2) //rect degenere(area contenuta nulla), skippo.

		return;

	std::vector<int> frameSeed(2 * (r.getLx() + r.getLy() - 2));</int>

	int x, y, count1, count2;

	/*- ptrをRect範囲のスタート地点に移動 -*/

	Pixel *ptr = m_pixels + r.y0 * m_wrap + r.x0;

	count1 = 0;

	count2 = r.y1 - r.y0 + 1;

	//Se il rettangolo non contiene il bordo del raster e se tutti i pixels

	//contenuti nel rettangolo sono pure paint non deve fare nulla!

	if (!rect.contains(m_bounds) &&

		areRectPixelsPurePaint(m_pixels, r, m_wrap))

		return;

	//Viene riempito frameSeed con tutti i paint delle varie aree del rettangolo di contorno.

	//Viene verificato se i pixels del rettangolo sono tutti pure paint.

	/*- 輪郭のPaintのIDをframeseed内に格納 -*/

	for (y = r.y0; y <= r.y1; y++, ptr += m_wrap, count1++, count2++) {

		if (r.x0 > 0)

			frameSeed[count1] = ptr->getPaint();

		if (r.x1 < m_ras->getLx() - 1)

			frameSeed[count2] = (ptr + dx)->getPaint();

	}

	ptr = m_pixels + r.y0 * m_wrap + r.x0 + 1;

	count1 = count2;

	count2 = count1 + r.x1 - r.x0 - 1;

	for (x = r.x0 + 1; x < r.x1; x++, ptr++, count1++, count2++) {

		if (r.y0 > 0)

			frameSeed[count1] = ptr->getPaint();

		if (r.y1 < m_ras->getLy() - 1)

			frameSeed[count2] = (ptr + dy)->getPaint();

	}

	assert(count2 == 2 * (r.getLx() + r.getLy() - 2));

	//Viene fillato l'interno e il bordo del rettangolo rect con color

	Pixel *pix = m_pixels + r.y0 * m_wrap + r.x0;

	if (onlyUnfilled)

		for (y = r.y0; y <= r.y1; y++, pix += m_wrap - dx - 1) {

			for (x = r.x0; x <= r.x1; x++, pix++) {

				if (pix->getPaint() == 0) // BackgroundStyle

					pix->setPaint(color);

				if (fillInks)

					pix->setInk(color);

			}

		}

	else

		for (y = r.y0; y <= r.y1; y++, pix += m_wrap - dx - 1) {

			for (x = r.x0; x <= r.x1; x++, pix++) {

				pix->setPaint(color);

				if (fillInks)

					pix->setInk(color);

			}

		}

	//Vengono fillati i pixel del rettangolo con i paint (mantenuti in frameSeed) che

	//c'erano prima di fillare l'intero rettangolo, in questo modo si riportano

	//al colore originale le aree che non sono chiuse e non dovevano essere fillate.

	count1 = 0;

	FillParameters params;

	if (r.x0 > 0)

		for (y = r.y0; y <= r.y1; y++) {

			params.m_p = TPoint(r.x0, y);

			params.m_styleId = frameSeed[count1++];

			fill(m_ras, params);

		}

	else

		count1 += r.y1 - r.y0 + 1;

	if (r.x1 < m_ras->getLx() - 1)

		for (y = r.y0; y <= r.y1; y++) {

			params.m_p = TPoint(r.x1, y);

			params.m_styleId = frameSeed[count1++];

			fill(m_ras, params);

		}

	else

		count1 += r.y1 - r.y0 + 1;

	if (r.y0 > 0)

		for (x = r.x0 + 1; x < r.x1; x++) {

			params.m_p = TPoint(x, r.y0);

			params.m_styleId = frameSeed[count1++];

			fill(m_ras, params);

		}

	else

		count1 += r.x1 - r.x0 - 1;

	if (r.y1 < m_ras->getLy() - 1)

		for (x = r.x0 + 1; x < r.x1; x++) {

			params.m_p = TPoint(x, r.y1);

			params.m_styleId = frameSeed[count1++];

			fill(m_ras, params);

		}

}

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

void AreaFiller::strokeFill(TStroke *stroke, int colorId,

							bool onlyUnfilled, bool fillPaints, bool fillInks)

{

	stroke->transform(TTranslation(convert(m_ras->getCenter())));

	m_ras->lock();

	std::vector<std::pair<tpoint, int="">> seeds;</std::pair<tpoint,>

	computeSeeds(m_ras, stroke, seeds);

	TVectorImage app;

	app.addStroke(stroke);

	app.findRegions();

	for (UINT i = 0; i < app.getRegionCount(); i++)

		fillArea(m_ras, app.getRegion(i), colorId, onlyUnfilled, fillPaints, fillInks);

	app.removeStroke(0);

	stroke->transform(TTranslation(convert(-m_ras->getCenter())));

	restoreColors(m_ras, seeds);

	m_ras->unlock();

}

//=============================================================================

// FullColorAreaFiller

FullColorAreaFiller::FullColorAreaFiller(const TRaster32P &ras)

	: m_ras(ras), m_bounds(ras->getBounds()), m_pixels(ras->pixels()), m_wrap(ras->getWrap()), m_color(0)

{

	m_ras->lock();

}

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

FullColorAreaFiller::~FullColorAreaFiller()

{

	m_ras->unlock();

}

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

void FullColorAreaFiller::rectFill(const TRect &rect, const FillParameters ¶ms, bool onlyUnfilled)

{

	TRect bbox = m_ras->getBounds();

	TRect r = rect * bbox;

	if (r.isEmpty())

		return;

	TRaster32P workRas = m_ras->extract(r);

	TRaster32P copy = workRas->clone();

	TPixel32 color = params.m_palette->getStyle(params.m_styleId)->getMainColor();

	//Fillo tutto il quadaratino con color

	int x, y;

	for (y = 0; y < workRas->getLy(); y++) {

		TPixel32 *line = workRas->pixels(y);

		for (x = 0; x < workRas->getLx(); x++)

			*(line + x) = overPix(color, workRas->pixels(y)[x]);

	}

	FillParameters paramsApp = params;

	TPixel32 refColor;

	for (y = 0; y < workRas->getLy(); y++) {

		paramsApp.m_p = TPoint(0, y);

		if (y == 0 || refColor != workRas->pixels(paramsApp.m_p.y)[paramsApp.m_p.x]) {

			fill(workRas, copy, paramsApp);

			refColor = workRas->pixels(paramsApp.m_p.y)[paramsApp.m_p.x];

		}

	}

	for (y = 0; y < workRas->getLy(); y++) {

		paramsApp.m_p = TPoint(workRas->getLx() - 1, y);

		if (y == 0 || refColor != workRas->pixels(paramsApp.m_p.y)[paramsApp.m_p.x]) {

			fill(workRas, copy, paramsApp);

			refColor = workRas->pixels(paramsApp.m_p.y)[paramsApp.m_p.x];

		}

	}

	for (x = 0; x < workRas->getLx(); x++) {

		paramsApp.m_p = TPoint(x, 0);

		if (x == 0 || refColor != workRas->pixels(paramsApp.m_p.y)[paramsApp.m_p.x]) {

			fill(workRas, copy, paramsApp);

			refColor = workRas->pixels(paramsApp.m_p.y)[paramsApp.m_p.x];

		}

	}

	for (x = 0; x < workRas->getLx(); x++) {

		paramsApp.m_p = TPoint(x, workRas->getLy() - 1);

		if (x == 0 || refColor != workRas->pixels(paramsApp.m_p.y)[paramsApp.m_p.x]) {

			fill(workRas, copy, paramsApp);

			refColor = workRas->pixels(paramsApp.m_p.y)[paramsApp.m_p.x];

		}

	}

}

//=============================================================================

// InkSegmenter

const int damInk = 3;

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

#define GROW_FACTOR 2.51

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

class InkSegmenter

{

	int m_lx, m_ly, m_wrap;

	int m_displaceVector[8];

	TPixelCM32 *m_buf;

	TRect m_bBox;

	TRasterCM32P m_r;

	TTileSaverCM32 *m_saver;

	float m_growFactor;

public:

	InkSegmenter(const TRasterCM32P &r, float growFactor, TTileSaverCM32 *saver)

		: m_r(r), m_lx(r->getLx()), m_ly(r->getLy()), m_wrap(r->getWrap()), m_buf((TPixelCM32 *)r->getRawData()), m_bBox(r->getBounds()), m_saver(saver), m_growFactor(growFactor)

	{

		m_displaceVector[0] = -m_wrap - 1;

		m_displaceVector[1] = -m_wrap;

		m_displaceVector[2] = -m_wrap + 1;

		m_displaceVector[3] = -1;

		m_displaceVector[4] = +1;

		m_displaceVector[5] = m_wrap - 1;

		m_displaceVector[6] = m_wrap;

		m_displaceVector[7] = m_wrap + 1;

	}

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

	bool compute(const TPoint &pin, int ink, bool isSelective)

	{

		TPixelCM32 *pix;

		int distance;

		TPixelCM32 *master;

		TPoint mp, sp;

		TPixelCM32 *slave;

		TPixelCM32 *d11, *d12, *d21, *d22;

		TPoint d1p1, d1p2, d2p1, d2p2;

		TPoint p = pin;

		if (!m_bBox.contains(p))

			return false;

		if ((m_buf + p.y * m_wrap + p.x)->isPurePaint() && ((p = nearestInk(p, 2)) == TPoint(-1, -1)))

			return false;

		pix = m_buf + p.y * m_wrap + p.x;

		/*-- 同じインクの場合はreturn --*/

		if (pix->getInk() == ink)

			return false;

		if (!ConnectionTable[neighboursCode(pix, p)]) {

			master = slave = pix;

			mp = sp = p;

			distance = 0;

		} else

			distance = findTwinPoints(pix, p, master, mp, slave, sp);

		if (distance == -1)

			return false;

		if (!findDam(master, mp, slave, sp, distance,

					 d11, d1p1, d12, d1p2))

			d11 = d12 = d21 = d22 = 0;

		else

			findDamRev(master, mp, slave, sp, distance,

					   d21, d2p1, d22, d2p2);

		//vector<pair<tpixelcm32*, int=""> > oldInks;</pair<tpixelcm32*,>

		drawSegment(d1p1, d1p2, damInk, m_saver);

		drawSegment(d2p1, d2p2, damInk, m_saver);

		inkSegmentFill(p, ink, isSelective, m_saver);

		//UINT i;

		drawSegment(d1p1, d1p2, ink, m_saver);

		drawSegment(d2p1, d2p2, ink, m_saver);

		/*	for (i=0; i

		(oldInks[i].first)->setInk(ink);*/

		return true;

	}

private:

	void drawSegment(const TPoint &p0, const TPoint &p1, int ink,

					 /*vector<pair<tpixelcm32*, int=""> >& oldInks,*/ TTileSaverCM32 *saver);</pair<tpixelcm32*,>

	int findTwinPoints(TPixelCM32 *pix, const TPoint &p,

					   TPixelCM32 *&master, TPoint &mp,

					   TPixelCM32 *&slave, TPoint &sp);

	int searchForNearestSlave(TPixelCM32 *pix1, TPixelCM32 *pix2,

							  const TPoint &p1, TPoint &p2,

							  TPixelCM32 *&slave, TPoint &sp);

	int rearrangePoints(TPixelCM32 *&master, TPoint &mp,

						TPixelCM32 *&slave, int s_prewalker,

						TPoint &sp, int walk);

	int rearrangePointsRev(TPixelCM32 *&master, TPoint &mp,

						   TPixelCM32 *&slave, int s_prewalker,

						   TPoint &sp, int walk);

	int dragSlave(TPoint mp, TPixelCM32 *&slave, int &s_prewalker, TPoint &sp);

	int dragSlaveRev(TPoint mp, TPixelCM32 *&slave, int &s_prewalker,

					 TPoint &sp, TPixelCM32 *first_slave);

	bool findDam(TPixelCM32 *master, TPoint mp,

				 TPixelCM32 *slave, TPoint sp, int distance,

				 TPixelCM32 *&d11, TPoint &d1p1,

				 TPixelCM32 *&d12, TPoint &d1p2);

	void findDamRev(TPixelCM32 *master, TPoint mp,

					TPixelCM32 *slave, TPoint sp, int distance,

					TPixelCM32 *&d11, TPoint &d1p1,

					TPixelCM32 *&d12, TPoint &d1p2);

	int nextPointIsGoodRev(TPoint mp, TPoint sp,

						   TPixelCM32 *slave, int s_prewalker, int distance);

	int nextPointIsGood(TPoint mp, TPoint sp,

						TPixelCM32 *slave, int s_prewalker, int distance);

	void inkSegmentFill(const TPoint &p, int ink, bool isSelective, TTileSaverCM32 *saver);

	TPoint nearestInk(const TPoint &p, int ray);

	inline int stepReversed(TPixelCM32 *walker, int prewalker, int &distance,

							const TPoint &p1, TPoint &p2);

	inline int stepForward(TPixelCM32 *walker, int prewalker, int &distance,

						   const TPoint &p1, TPoint &p2);

	TPixelCM32 *ePix(TPixelCM32 *br) { return (br + 1); }

	TPixelCM32 *wPix(TPixelCM32 *br) { return (br - 1); }

	TPixelCM32 *nPix(TPixelCM32 *br) { return (br + m_wrap); }

	TPixelCM32 *sPix(TPixelCM32 *br) { return (br - m_wrap); }

	TPixelCM32 *swPix(TPixelCM32 *br) { return (br - m_wrap - 1); }

	TPixelCM32 *nwPix(TPixelCM32 *br) { return (br + m_wrap - 1); }

	TPixelCM32 *nePix(TPixelCM32 *br) { return (br + m_wrap + 1); }

	TPixelCM32 *sePix(TPixelCM32 *br) { return (br - m_wrap + 1); }

	UCHAR neighboursCode(TPixelCM32 *seed, const TPoint &p)

	{

		//assert(p == TPoint((seed-m_buf)%m_wrap, (seed-m_buf)/m_wrap));

		bool w = (p.x > 0), e = (p.x < m_lx - 1), s = (p.y > 0), n = (p.y < m_ly - 1);

		return (((s && w) ? ((!swPix(seed)->isPurePaint())) : 0) |

				((s) ? ((!sPix(seed)->isPurePaint()) << 1) : 0) |

				((s && e) ? ((!sePix(seed)->isPurePaint()) << 2) : 0) |

				((w) ? ((!wPix(seed)->isPurePaint()) << 3) : 0) |

				((e) ? ((!ePix(seed)->isPurePaint()) << 4) : 0) |

				((n && w) ? ((!nwPix(seed)->isPurePaint()) << 5) : 0) |

				((n) ? ((!nPix(seed)->isPurePaint()) << 6) : 0) |

				((n && e) ? ((!nePix(seed)->isPurePaint()) << 7) : 0));

	}

};

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

#define DRAW_SEGMENT(a, b, da, db, istr1, istr2, block) \

	{                                                   \

		d = 2 * db - da;                                \

		incr_1 = 2 * db;                                \

		incr_2 = 2 * (db - da);                         \

		while (a < da) {                                \

			if (d <= 0) {                               \

				d += incr_1;                            \

				a++;                                    \

				istr1;                                  \

			} else {                                    \

				d += incr_2;                            \

				a++;                                    \

				b++;                                    \

				istr2;                                  \

			}                                           \

			block;                                      \

		}                                               \

	}

#define SET_INK                                                              \

	{                                                                        \

		if (saver)                                                           \

			saver->save(TPoint(x1 + x, y1 + y));                             \

		/*if (buf->getInk()!=damInk)*/                                       \

		/*  oldInks.push_back(pair<tpixelcm32*, int="">(buf, buf->getInk()));*/ \</tpixelcm32*,>

		buf->setInk(ink);                                                    \

	}

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

void InkSegmenter::drawSegment(const TPoint &p0, const TPoint &p1, int ink,

							   /*vector<pair<tpixelcm32*, int=""> >& oldInks,*/ TTileSaverCM32 *saver)</pair<tpixelcm32*,>

{

	int x, y, dx, dy, d, incr_1, incr_2;

	int x1 = p0.x;

	int y1 = p0.y;

	int x2 = p1.x;

	int y2 = p1.y;

	if (x1 > x2) {

		tswap(x1, x2);

		tswap(y1, y2);

	}

	TPixelCM32 *buf = m_r->pixels() + y1 * m_wrap + x1;

	/*if (buf->getInk()!=damInk) 

		oldInks.push_back(pair<tpixelcm32*, int="">(buf, buf->getInk()));</tpixelcm32*,>

	if ((m_r->pixels() + y2*m_wrap + x2)->getInk()!=damInk) 

		oldInks.push_back(pair<tpixelcm32*, int="">(m_r->pixels() + y2*m_wrap + x2, (m_r->pixels() + y2*m_wrap + x2)->getInk()));*/</tpixelcm32*,>

	if (saver) {

		saver->save(p0);

		saver->save(p1);

	}

	buf->setInk(ink);

	(m_r->pixels() + y2 * m_wrap + x2)->setInk(ink);

	dx = x2 - x1;

	dy = y2 - y1;

	x = y = 0;

	if (dy >= 0) {

		if (dy <= dx)

			DRAW_SEGMENT(x, y, dx, dy, (buf++), (buf += m_wrap + 1), SET_INK)

		else

			DRAW_SEGMENT(y, x, dy, dx, (buf += m_wrap), (buf += m_wrap + 1), SET_INK)

	} else {

		dy = -dy;

		if (dy <= dx)

			DRAW_SEGMENT(x, y, dx, dy, (buf++), (buf -= (m_wrap - 1)), SET_INK)

		else

			DRAW_SEGMENT(y, x, dy, dx, (buf -= m_wrap), (buf -= (m_wrap - 1)), SET_INK)

	}

}

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

void InkSegmenter::inkSegmentFill(const TPoint &p, int ink, bool isSelective, TTileSaverCM32 *saver)

{

	int x = p.x, y = p.y;

	int lx = m_r->getLx();

	int ly = m_r->getLy();

	TPixelCM32 *pixels = (TPixelCM32 *)m_r->getRawData();

	TPixelCM32 *pix = pixels + p.y * m_wrap + x;

	int oldInk;

	if (pix->isPurePaint() || pix->getInk() == ink)

		return;

	if (isSelective)

		oldInk = pix->getInk();

	std::stack<tpoint> seeds;</tpoint>

	seeds.push(p);

	while (!seeds.empty()) {

		TPoint seed = seeds.top();

		seeds.pop();

		//if(!m_r->getBounds().contains(seed)) continue;

		x = seed.x;

		y = seed.y;

		TPixelCM32 *pix = pixels + (y * m_wrap + x);

		if (pix->isPurePaint() || pix->getInk() == ink || pix->getInk() == damInk || (isSelective && pix->getInk() != oldInk))

			continue;

		if (saver)

			saver->save(seed);

		pix->setInk(ink);

		if (x > 0)

			seeds.push(TPoint(x - 1, y));

		if (y > 0)

			seeds.push(TPoint(x, y - 1));

		if (y < ly - 1)

			seeds.push(TPoint(x, y + 1));

		if (x < lx - 1)

			seeds.push(TPoint(x + 1, y));

		if (x == lx - 1 || x == 0 || y == ly - 1 || y == 0)

			continue;

		if (ePix(pix)->getInk() == damInk ||

			wPix(pix)->getInk() == damInk ||

			sPix(pix)->getInk() == damInk ||

			nPix(pix)->getInk() == damInk ||

			nePix(pix)->getInk() == damInk ||

			sePix(pix)->getInk() == damInk ||

			swPix(pix)->getInk() == damInk ||

			nwPix(pix)->getInk() == damInk)

			continue;

		seeds.push(TPoint(x - 1, y - 1));

		seeds.push(TPoint(x - 1, y + 1));

		seeds.push(TPoint(x + 1, y - 1));

		seeds.push(TPoint(x + 1, y + 1));

	}

}

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

TPoint InkSegmenter::nearestInk(const TPoint &p, int ray)

{

	int i, j;

	for (j = std::max(p.y - ray, 0); j <= std::min(p.y + ray, m_ly - 1); j++)

		for (i = std::max(p.x - ray, 0); i <= std::min(p.x + ray, m_lx - 1); i++)

			if (!(m_buf + j * m_wrap + i)->isPurePaint())

				return TPoint(i, j);

	return TPoint(-1, -1);

}

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

int InkSegmenter::findTwinPoints(TPixelCM32 *pix, const TPoint &p,

								 TPixelCM32 *&master, TPoint &mp,

								 TPixelCM32 *&slave, TPoint &sp)

{

	TPixelCM32 *row_p1, *col_p1, *row_p2, *col_p2;

	int distance;

	int row_x1, row_x2, col_y1, col_y2;

	row_p1 = pix - 1;

	row_x1 = p.x - 1;

	while (row_x1 + 1 < m_lx && !(row_p1 + 1)->isPurePaint()) {

		row_p1++;

		row_x1++;

	}

	row_p2 = pix + 1;

	row_x2 = p.x + 1;

	while (row_x2 - 1 > 0 && !(row_p2 - 1)->isPurePaint()) {

		row_p2--;

		row_x2--;

	}

	master = row_p1;

	mp.x = row_x1;

	mp.y = p.y;

	col_p1 = pix - m_wrap;

	col_y1 = p.y - 1;

	while (col_y1 + 1 < m_ly && !(col_p1 + m_wrap)->isPurePaint()) {

		col_p1 += m_wrap;

		col_y1++;

	}

	col_p2 = pix + m_wrap;

	col_y2 = p.y + 1;

	while (col_y2 - 1 > 0 && !(col_p2 - 1)->isPurePaint()) {

		col_p2 -= m_wrap;

		col_y2--;

	}

	if (row_x1 - row_x2 <= col_y1 - col_y2) {

		master = row_p1;

		mp = TPoint(row_x1, p.y);

		TPoint auxp(row_x2, p.y);

		if ((distance = searchForNearestSlave(row_p1, row_p2, mp, auxp, slave, sp)) != 0)

			return distance;

		master = col_p1;

		mp = TPoint(p.x, col_y1);

		auxp = TPoint(p.x, col_y2);

		if ((distance = searchForNearestSlave(col_p1, col_p2, mp, auxp, slave, sp)) == 0 /*&& !is_connecting(p1)*/)

			return -1;

	} else {

		master = col_p1;

		mp = TPoint(p.x, col_y1);

		TPoint auxp(p.x, col_y2);

		if ((distance = searchForNearestSlave(col_p1, col_p2, mp, auxp, slave, sp)) != 0)

			return distance;

		master = row_p1;

		mp = TPoint(row_x1, p.y);

		auxp = TPoint(row_x2, p.y);

		if ((distance = searchForNearestSlave(row_p1, row_p2, mp, auxp, slave, sp)) == 0 /*&& !is_connecting(p1)*/)

			return -1;

	}

	return distance;

}

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

inline void newP(int next, TPoint &p)

{

	switch (next) {

	case 0:

	case 3:

	case 5:

		p.x -= 1;

		break;

	case 2:

	case 4:

	case 7:

		p.x += 1;

		break;

	}

	switch (next) {

	case 0:

	case 1:

	case 2:

		p.y -= 1;

		break;

	case 5:

	case 6:

	case 7:

		p.y += 1;

		break;

	}

}

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

inline int InkSegmenter::stepReversed(TPixelCM32 *walker, int prewalker, int &distance,

									  const TPoint &p1, TPoint &p2)

{

	int next = NextPointTableRev[(neighboursCode(walker, p2) << 3) | prewalker];

	newP(next, p2);

	distance = norm2(p1 - p2);

	return next;

}

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

inline int InkSegmenter::stepForward(TPixelCM32 *walker, int prewalker, int &distance,

									 const TPoint &p1, TPoint &p2)

{

	int next = NextPointTable[(neighboursCode(walker, p2) << 3) | prewalker];

	newP(next, p2);

	distance = norm2(p1 - p2);

	return next;

}

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

int InkSegmenter::searchForNearestSlave(TPixelCM32 *pix1, TPixelCM32 *pix2,

										const TPoint &p1, TPoint &p2,

										TPixelCM32 *&slave, TPoint &sp)

{

	int curr_distance, new_distance;

	UCHAR prewalker, next;

	TPixelCM32 *walker;

	TPoint currp2;

	currp2 = p2;

	curr_distance = norm2(p1 - p2);

	walker = pix2;

	slave = pix2;

	sp = p2;

	prewalker = FirstPreseedTable[neighboursCode(walker, p2)];

	next = stepForward(walker, prewalker, new_distance, p1, p2);

	if (curr_distance != 0 && new_distance < curr_distance) {

		while (p2.x > 0 && p2.x < m_lx - 1 && p2.y > 0 && p2.y < m_ly - 1 &&

			   new_distance < curr_distance && new_distance != 0) {

			curr_distance = new_distance;

			sp.x = p2.x;

			sp.y = p2.y;

			walker = walker + m_displaceVector[next];

			slave = walker;

			prewalker = (~next) & 0x7;

			next = stepForward(walker, prewalker, new_distance, p1, p2);

		}

		if (new_distance != 0)

			return curr_distance;

	}

	curr_distance = norm2(p1 - p2);

	walker = pix2;

	p2 = currp2;

	UCHAR code = neighboursCode(walker, p2);

	next = FirstPreseedTable[code];

	next = NextPointTable[(code << 3) | next];

	prewalker = next;

	next = stepReversed(walker, prewalker, new_distance, p1, p2);

	if (p2.x > 0 && p2.x < m_lx - 1 && p2.y > 0 && p2.y < m_ly - 1 &&

		curr_distance != 0 && new_distance < curr_distance) {

		while (new_distance < curr_distance && new_distance > 0) {

			curr_distance = new_distance;

			sp = p2;

			walker = walker + m_displaceVector[next];

			slave = walker;

			prewalker = (~next) & 0x7;