#include "tsystem.h"

#include <set></set>

#include "tropcm.h"

#include "tcolorstyles.h"

#include "tpixelutils.h"

#include "ttile.h"

#include "tpalette.h"

#include "timage_io.h"

#include "trasterimage.h"

//#include "tlevel.h"

//#include "ttoonzimage.h"

//#include "tgeometry.h"

//#include "timage_io.h"

extern "C" {

#include "toonz4.6/raster.h"

}

#ifdef _WIN32

#define USE_SSE2

#endif

#ifdef USE_SSE2

#include <emmintrin.h></emmintrin.h>

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

namespace

{

__declspec(align(16)) class TPixelFloat

{

public:

	TPixelFloat() : b(0), g(0), r(0), m(0) {}

	TPixelFloat(float rr, float gg, float bb, float mm)

		: b(bb), g(gg), r(rr), m(mm) {}

	TPixelFloat(const TPixel32 &pix)

		: b(pix.b), g(pix.g), r(pix.r), m(pix.m) {}

	float b, g, r, m;

};

} // anonymous namespace

#endif

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

bool renderRas32(const TTile &tileOut, const TTile &tileIn, const TPaletteP palette);

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

const TPixel32 c_transparencyCheckPaint = TPixel32(80, 80, 80, 255);

const TPixel32 c_transparencyCheckInk = TPixel32::Black;

void TRop::convert(const TRaster32P &rasOut,

				   const TRasterCM32P &rasIn,

				   const TPaletteP palette,

				   bool transparencyCheck)

{

	int count = palette->getStyleCount();

	int count2 = std::max({count, TPixelCM32::getMaxInk(), TPixelCM32::getMaxPaint()});

	// per poter utilizzare lo switch (piu' efficiente) si utilizza 255

	// anziche' TPixelCM32::getMaxTone()

	assert(TPixelCM32::getMaxTone() == 255);

	int rasLx = rasOut->getLx();

	int rasLy = rasOut->getLy();

	rasOut->lock();

	rasIn->lock();

#ifdef _WIN32

	if (TSystem::getCPUExtensions() & TSystem::CpuSupportsSse2) {

		__m128i zeros = _mm_setzero_si128();

		TPixelFloat *paints = (TPixelFloat *)_aligned_malloc(count2 * sizeof(TPixelFloat), 16);

		TPixelFloat *inks = (TPixelFloat *)_aligned_malloc(count2 * sizeof(TPixelFloat), 16);

		std::vector<tpixel32> paints2(count2);</tpixel32>

		std::vector<tpixel32> inks2(count2);</tpixel32>

		if (transparencyCheck) {

			for (int i = 0; i < palette->getStyleCount(); i++) {

				paints2[i] = c_transparencyCheckPaint;

				inks2[i] = c_transparencyCheckInk;

				paints[i] = TPixelFloat(paints2[i]);

				inks[i] = TPixelFloat(inks2[i]);

			}

			paints2[0] = TPixel32::Transparent;

			paints[0] = TPixelFloat(TPixel32::Transparent);

		}

		/*

   else if (true)

      {

			for(int i=0;i<palette->getStyleCount();i++)</palette->

        {

        paints2[i] = c_transparencyCheckPaint;

				inks2[i]   = c_transparencyCheckInk;

        paints[i]  = TPixelFloat(paints2[i]);

				inks[i]    = TPixelFloat(inks2[i]);

  			paints2[i] = TPixel32::Transparent;

	  		paints[i] = TPixelFloat(TPixel32::Transparent);

        }

			paints2[0] = TPixel32::Transparent;

			paints[0] = TPixelFloat(TPixel32::Transparent);

     }

     */

		else

			for (int i = 0; i < palette->getStyleCount(); i++) {

				TPixel32 color = ::premultiply(palette->getStyle(i)->getAverageColor());

				paints[i] = inks[i] = TPixelFloat(color);

				paints2[i] = inks2[i] = color;

			}

		float maxTone = (float)TPixelCM32::getMaxTone();

		__m128 den_packed = _mm_load1_ps(&maxTone);

		for (int y = 0; y < rasLy; ++y) {

			TPixel32 *pix32 = rasOut->pixels(y);

			TPixelCM32 *pixIn = rasIn->pixels(y);

			TPixelCM32 *endPixIn = pixIn + rasLx;

			while (pixIn < endPixIn) {

				int tt = pixIn->getTone();

				int p = pixIn->getPaint();

				int i = pixIn->getInk();

				switch (tt) {

				case 255:

					*pix32++ = paints2[p];

					break;

				case 0:

					*pix32++ = inks2[i];

					break;

				default: {

					float t = (float)tt;

					__m128 a_packed = _mm_load_ps((float *)&(inks[i]));

					__m128 b_packed = _mm_load_ps((float *)&(paints[p]));

					__m128 num_packed = _mm_load1_ps(&t);

					__m128 diff_packed = _mm_sub_ps(den_packed, num_packed);

					// calcola in modo vettoriale out = ((den-num)*a + num*b)/den

					__m128 outPix_packed = _mm_mul_ps(diff_packed, a_packed);

					__m128 tmpPix_packed = _mm_mul_ps(num_packed, b_packed);

					outPix_packed = _mm_add_ps(outPix_packed, tmpPix_packed);

					outPix_packed = _mm_div_ps(outPix_packed, den_packed);

					// converte i canali da float a char

					__m128i outPix_packed_i = _mm_cvtps_epi32(outPix_packed);

					outPix_packed_i = _mm_packs_epi32(outPix_packed_i, zeros);

					outPix_packed_i = _mm_packus_epi16(outPix_packed_i, zeros);

					*(DWORD *)(pix32) = _mm_cvtsi128_si32(outPix_packed_i);

					++pix32;

				}

				}

				++pixIn;

			}

		}

		_aligned_free(paints);

		_aligned_free(inks);

	} else // SSE2 not supported

#endif	 // _WIN32

	{

		std::vector<tpixel32> paints(count2, TPixel32(255, 0, 0));</tpixel32>

		std::vector<tpixel32> inks(count2, TPixel32(255, 0, 0));</tpixel32>

		if (transparencyCheck) {

			for (int i = 0; i < palette->getStyleCount(); i++) {

				paints[i] = c_transparencyCheckPaint;

				inks[i] = c_transparencyCheckInk;

			}

			paints[0] = TPixel32::Transparent;

		} else

			for (int i = 0; i < palette->getStyleCount(); i++)

				paints[i] = inks[i] = ::premultiply(palette->getStyle(i)->getAverageColor());

		for (int y = 0; y < rasLy; ++y) {

			TPixel32 *pix32 = rasOut->pixels(y);

			TPixelCM32 *pixIn = rasIn->pixels(y);

			TPixelCM32 *endPixIn = pixIn + rasLx;

			while (pixIn < endPixIn) {

				int t = pixIn->getTone();

				int p = pixIn->getPaint();

				int i = pixIn->getInk();

				if (t == TPixelCM32::getMaxTone())

					*pix32++ = paints[p];

				else if (t == 0)

					*pix32++ = inks[i];

				else

					*pix32++ = blend(inks[i], paints[p], t, TPixelCM32::getMaxTone());

				++pixIn;

			}

		}

	}

	rasOut->unlock();

	rasIn->unlock();

}

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

void do_convert(const TTile &dst, const TTile &src,

				const TPaletteP palette, bool transparencyCheck,

				bool applyFx)

{

	//assert(palette);

	//assert(_rasOut && _rasIn);

	//assert(rasOut->getSize() == rasIn->getSize());

	if (applyFx && renderRas32(dst, src, palette))

		return;

	TRaster32P rasOut;

	TRasterCM32P rasIn;

	if (dst.getRaster()->getSize() != src.getRaster()->getSize()) {

		TRect rect = TRect(convert(dst.m_pos), dst.getRaster()->getSize()) * TRect(convert(src.m_pos), src.getRaster()->getSize());

		TRect rectOut = rect - convert(dst.m_pos);

		rasOut = dst.getRaster()->extract(rectOut);

		TRect rectIn = rect - convert(src.m_pos);

		rasIn = src.getRaster()->extract(rectIn);

	} else {

		rasOut = dst.getRaster();

		rasIn = src.getRaster();

	}

	TRop::convert(rasOut, rasIn, palette, transparencyCheck);

}

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

void TRop::convert(const TRaster32P &rasOut,

				   const TRasterCM32P &rasIn,

				   TPaletteP palette,

				   const TRect &theClipRect, // il rect su cui e' applicata la conversione

				   bool transparencyCheck,

				   bool applyFx)

{

	assert(palette);

	assert(rasIn && rasOut);

	TRect clipRect(theClipRect);

	if (clipRect.isEmpty())

		clipRect = rasIn->getBounds();

	else {

		if (!clipRect.overlaps(rasIn->getBounds()))

			return;

		clipRect = clipRect * rasIn->getBounds();

	}

	if (clipRect.isEmpty())

		return;

	TRect clipRectIn, clipRectOut;

	if (applyFx && palette->getFxRects(clipRect, clipRectIn, clipRectOut)) {

		TRect rAux = clipRectIn;

		TRasterP rAuxIn = rasIn->extract(clipRectIn); //la extract modifica clipRectIn

		if (rAux != clipRectIn && rAux != rasIn->getBounds()) {

			TRasterCM32P rNew(rAux.getSize());

			TRect tmpRect = clipRectIn - rAux.getP00();

			rNew->extract(tmpRect)->copy(rAuxIn);

			rAuxIn = rNew;

			clipRectIn = rAux;

		}

		TTile tileIn(rAuxIn, ::convert(clipRectIn.getP00()));

		rAux = clipRectOut;

		TRasterP rAuxOut = rasOut->extract(clipRectOut); //la extract modifica clipRectOut

		TTile tileOut(rAuxOut, ::convert(clipRectOut.getP00()));

		TRop::convert(tileOut, tileIn, palette, transparencyCheck, true);

	} else {

		TRect clipRectIn = clipRect;

		TRect clipRectOut = clipRect;

		TRasterP _rasOut = rasOut->extract(clipRectOut);

		TRasterP _rasIn = rasIn->extract(clipRectIn);

		TTile t1(_rasOut, ::convert(clipRectOut.getP00()));

		TTile t2(_rasIn, ::convert(clipRectIn.getP00()));

		TRop::convert(t1, t2,

					  palette, transparencyCheck, false);

	}

}

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

void TRop::convert(const TTile &dst, const TTile &src, const TPaletteP plt, bool transparencyCheck, bool applyFxs)

{

	//if (dst->getSize() != src->getSize())

	//  throw TRopException("convert: size mismatch");

	//assert(plt);

	if ((TRaster32P)dst.getRaster())

		do_convert(dst, src, plt, transparencyCheck, applyFxs);

	else if ((TRaster64P)dst.getRaster()) {

		TRaster32P aux(dst.getRaster()->getLx(), dst.getRaster()->getLy());

		TTile taux(aux, dst.m_pos);

		do_convert(taux, src, plt, transparencyCheck, applyFxs);

		TRop::convert(dst.getRaster(), aux);

	} else

		throw TRopException("unsupported pixel type");

}

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

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

namespace

{

TRasterP putSinglePaintInRaster(TRasterCM32P &rasIn, int paintId, TPixel32 color)

{

	TRaster32P rasOut;

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

		TPixelCM32 *pixIn = rasIn->pixels(y);

		TPixelCM32 *endPix = pixIn + rasIn->getLx();

		TPixel32 *pixOut = 0;

		if (rasOut)

			pixOut = rasOut->pixels(y);

		while (pixIn < endPix) {

			if (pixIn->getPaint() == paintId) {

				if (!rasOut) {

					rasOut = TRaster32P(rasIn->getLx(), rasIn->getLy());

					rasOut->fill(TPixel32::Transparent);

					pixOut = rasOut->pixels(y) + (pixIn - rasIn->pixels(y));

				}

				if (!pixIn->isPureInk())

					*pixOut = color;

				/*else if (!pixIn->isPureInk())

			  {

				assert(TPixelCM32::getMaxTone()==0xff);

				pixOut->m = pixIn->getTone();

				pixOut->r = 255*color.r/pixOut->m;

				pixOut->g = 255*color.g/pixOut->m;

				pixOut->b = 255*color.b/pixOut->m;

        }*/

				pixIn->setPaint(0);

				//pixIn->setTone(0);

			}

			pixIn++;

			pixOut++;

		}

	}

	return rasOut;

}

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

TRasterP putSingleInkInRasterGR8(TRasterCM32P &rasIn, int inkId)

{

	TRasterGR8P rasOut;

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

		TPixelCM32 *pixIn = rasIn->pixels(y);

		TPixelCM32 *endPix = pixIn + rasIn->getLx();

		TPixelGR8 *pixOut;

		if (rasOut)

			pixOut = rasOut->pixels(y);

		while (pixIn < endPix) {

			if (pixIn->getInk() == inkId) {

				assert(TPixelCM32::getMaxTone() == 0xff);

				if (!rasOut) {

					rasOut = TRasterGR8P(rasIn->getLx(), rasIn->getLy());

					rasOut->fill(0);

					pixOut = rasOut->pixels(y) + (pixIn - rasIn->pixels(y));

				}

				*pixOut = 255 - pixIn->getTone();

				//pixIn->setInk(0);

				pixIn->setTone(TPixelCM32::getMaxTone());

			}

			pixIn++;

			pixOut++;

		}

	}

	return rasOut;

}

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

TRasterP putSingleInkInRasterRGBM(TRasterCM32P &rasIn, int inkId)

{

	TRaster32P rasOut;

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

		TPixelCM32 *pixIn = rasIn->pixels(y);

		TPixelCM32 *endPix = pixIn + rasIn->getLx();

		TPixel *pixOut;

		if (rasOut)

			pixOut = rasOut->pixels(y);

		while (pixIn < endPix) {

			if (pixIn->getInk() == inkId) {

				assert(TPixelCM32::getMaxTone() == 0xff);

				if (!rasOut) {

					rasOut = TRaster32P(rasIn->getLx(), rasIn->getLy());

					rasOut->fill(TPixel32::Transparent);

					pixOut = rasOut->pixels(y) + (pixIn - rasIn->pixels(y));

				}

				pixOut->r = pixOut->g = pixOut->b = pixOut->m = 255 - pixIn->getTone();

				//pixIn->setInk(0);

				pixIn->setTone(TPixelCM32::getMaxTone());

			}

			pixIn++;

			if (rasOut)

				pixOut++;

		}

	}

	return rasOut;

}

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

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

//filename!!

//interactive!!

bool computePaletteFx(const std::vector<std::pair<tcolorstyle *,="" int="">> &fx,</std::pair<tcolorstyle>

					  const TTile &tileOut, const TTile &tileIn, const TPaletteP plt)

{

	int i;

	TRasterCM32P rasIn = tileIn.getRaster();

	TRaster32P rAux32, rasOut = tileOut.getRaster();

	TRasterGR8P rAuxGR;

	int frame = plt->getFrame();

	std::vector<trasterp> paintLayers(fx.size());</trasterp>

	std::vector<trasterp> inkLayers(fx.size());</trasterp>

	//tolgo dal raster d'ingresso gli ink e i paint con gli effetti, mettendoli in dei raster layer

	for (i = 0; i < (int)fx.size(); i++) {

		TRasterStyleFx *rfx = fx[i].first->getRasterStyleFx();

		if (rfx->isPaintStyle())

			paintLayers[i] = putSinglePaintInRaster(rasIn, fx[i].second, fx[i].first->getMainColor());

		if (rfx->isInkStyle()) {

			if (rfx->inkFxNeedRGBMRaster())

				inkLayers[i] = putSingleInkInRasterRGBM(rasIn, fx[i].second);

			else

				inkLayers[i] = putSingleInkInRasterGR8(rasIn, fx[i].second);

		}

	}

	//raster d'ingresso senza i colori fx, viene renderizzato nel raster d'uscita

	do_convert(tileOut, tileIn, plt, false, false);

	//ogni layer viene "effettato".; se il risultato e' non nullo, viene sovrapposto sul raster d'uscita

	//prima vengono messi tutti i layer di paint, poi quelli di ink

	TRect rectOut = TRect(convert(tileOut.m_pos), tileOut.getRaster()->getSize()) - convert(tileIn.m_pos);

	for (i = 0; i < (int)fx.size(); i++)

		if (paintLayers[i]) {

			TRasterStyleFx::Params params(paintLayers[i], convert(tileIn.m_pos), rasIn, fx[i].second, frame);

			if (fx[i].first->getRasterStyleFx()->compute(params))

				TRop::over(rasOut, paintLayers[i]->extract(rectOut), rasOut);

		}

	for (i = 0; i < (int)fx.size(); i++)

		if (inkLayers[i]) {

			TRasterStyleFx *rfx = fx[i].first->getRasterStyleFx();

			TRasterStyleFx::Params params(inkLayers[i], convert(tileIn.m_pos), rasIn, fx[i].second, frame);

			if (rfx->compute(params)) {

				if (rfx->inkFxNeedRGBMRaster())

					TRop::over(rasOut, rasOut, inkLayers[i]->extract(rectOut));

				else

					TRop::over(rasOut, inkLayers[i]->extract(rectOut), fx[i].first->getMainColor());

			}

		}

	return true;

}

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

} //namespace

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

bool renderRas32(const TTile &tileOut, const TTile &tileIn, const TPaletteP palette)

{

	assert(TRect(convert(tileIn.m_pos), tileIn.getRaster()->getSize()).contains(TRect(convert(tileOut.m_pos), tileOut.getRaster()->getSize())));

	assert((TRasterCM32P)tileIn.getRaster());

	//Shrink = shrink;

	//INIT_TCM(rin)

	/* mark up are made apart */

	//computeMarkup(rasIn, palette);

	std::vector<std::pair<tcolorstyle *,="" int="">> fxArray;</std::pair<tcolorstyle>

	for (int i = 0; i < palette->getStyleCount(); i++)

		if (palette->getStyle(i)->isRasterStyle())

			fxArray.push_back(std::pair<tcolorstyle *,="" int="">(palette->getStyle(i), i));</tcolorstyle>

	if (fxArray.empty())

		return false;

	TTile _tileIn(tileIn.getRaster()->clone(), tileIn.m_pos);

	tileIn.getRaster()->lock();

	tileOut.getRaster()->lock();

	computePaletteFx(fxArray, tileOut, _tileIn, palette);

	tileIn.getRaster()->unlock();

	tileOut.getRaster()->unlock();

	return true;

}

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

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

namespace

{

void addColor(TPaletteP plt, int index, const TPaletteP &upPlt, std::map<int, int=""> &usedInks)</int,>

{

	TColorStyle *cs = upPlt->getStyle(index);

	if (cs && cs->getMainColor() == plt->getStyle(index)->getMainColor()) {

		usedInks[index] = index;

		return;

	}

	int firstStyleId = plt->getFirstUnpagedStyle();

	if (firstStyleId == -1)

		firstStyleId = plt->getStyleCount();

	usedInks[index] = firstStyleId;

	plt->getPage(0)->addStyle(TPixel32::Red);

}

void addColor(TPaletteP plt, int index, std::map<int, int=""> &usedInks)</int,>

{

	int firstStyleId = plt->getFirstUnpagedStyle();

	if (firstStyleId == -1)

		firstStyleId = plt->getStyleCount();

	usedInks[index] = firstStyleId;

	plt->getPage(0)->addStyle(TPixel32::Red);

}

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

//std::map<int,int>& usedInk  upInkId -> downInkId</int,int>

void doMergeCmapped(TRasterCM32P rasOut, const TRasterCM32P &rasUp, const TPaletteP &pltOut, bool onlyInks,

					int matchlinePrevalence, std::map<int, int=""> &usedInks)</int,>

{

	double val = matchlinePrevalence / 100.0; //matchlinePrevalence ==0 always ink down; matchlinePrevalence == 100 always ink up;

	assert(rasOut && rasUp);

	assert(rasOut->getSize() == rasUp->getSize());

	TPaletteP downPlt = pltOut->clone();

	std::map<int, int="">::iterator it;</int,>

	for (it = usedInks.begin(); it != usedInks.end(); it++)

		downPlt->getPage(0)->addStyle(TPixel32::Red);

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

		TPixelCM32 *pixDown = rasOut->pixels(y), *endPix = pixDown + rasOut->getLx();

		TPixelCM32 *pixUp = rasUp->pixels(y);

		while (pixDown < endPix) {

			//there is lines in matchline

			if (!pixUp->isPurePaint()) {

				int toneDown = pixDown->getTone();

				int toneUp = pixUp->getTone();

				if (usedInks.find(pixUp->getInk()) == usedInks.end())

					addColor(downPlt, pixUp->getInk(), usedInks);

				if (val == 1) { //Matchline is on top, with gap

					pixDown->setTone(toneUp);

					pixDown->setInk(usedInks[pixUp->getInk()]);

				} else if (val == 0) { //Matchline is on bottom, with gap

					if (pixDown->isPurePaint()) {

						pixDown->setTone(toneUp);

						pixDown->setInk(usedInks[pixUp->getInk()]);

					} else {

						//*pixOut = *pixDown;

					}

				} else {

					if ((val > 0 && toneUp < toneDown) || (val == 0 && toneDown == 255)) //(toneUp

						pixDown->setTone(toneUp);

					if ((255 - toneDown) * (1 - val) <= val * (255 - toneUp - 1)) //val==0 -> if (toneDown== 255)....

						//val==0.5 -> if (toneup

						//val==1 -> if (toneup<255)...

						pixDown->setInk(usedInks[pixUp->getInk()]);

				}

			}

			int paintIndex;

			if (!onlyInks && (paintIndex = pixUp->getPaint()) > 0) {

				if (usedInks.find(paintIndex) == usedInks.end())

					addColor(downPlt, paintIndex, usedInks);

				pixDown->setPaint(usedInks[paintIndex]);

			}

			pixUp++;

			pixDown++;

			//pixOut++;

		}

	}

}

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

void addColors(const TPixelCM32 &color, TPaletteP plt, const TPaletteP &upPlt, std::map<int, int=""> &usedColors)</int,>

{

	if (usedColors.find(color.getInk()) == usedColors.end())

		addColor(plt, color.getInk(), upPlt, usedColors);

	if (usedColors.find(color.getPaint()) == usedColors.end())

		addColor(plt, color.getPaint(), upPlt, usedColors);

}

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

void addColors(const TPixelCM32 &color, TPaletteP plt, std::map<int, int=""> &usedColors)</int,>

{

	if (usedColors.find(color.getInk()) == usedColors.end())

		addColor(plt, color.getInk(), usedColors);

	if (usedColors.find(color.getPaint()) == usedColors.end())

		addColor(plt, color.getPaint(), usedColors);

}

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

void doApplyMatchLines(TRasterCM32P rasOut, const TRasterCM32P &rasUp, int inkIndex, int matchlinePrevalence)

{

	double val = matchlinePrevalence / 100.0; //matchlinePrevalence ==0->always ink down; matchlinePrevalence == 100 always ink up;

	assert(rasOut && rasUp);

	assert(rasOut->getSize() == rasUp->getSize());

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

		TPixelCM32 *pixDown = rasOut->pixels(y), *endPix = pixDown + rasOut->getLx();

		TPixelCM32 *pixUp = rasUp->pixels(y);

		while (pixDown < endPix) {

			if (!pixUp->isPurePaint()) {

				int toneDown = pixDown->getTone();

				int toneUp = pixUp->getTone();

				if (val == 1) { //Matchline is on top, with gap

					pixDown->setTone(toneUp);

					pixDown->setInk(inkIndex);

				} else if (val == 0) { //Matchline is on bottom, with gap

					if (pixDown->isPurePaint()) {

						pixDown->setTone(toneUp);

						pixDown->setInk(inkIndex);

					} else {

					}

					//*pixOut = *pixDown;

				}

				if ((val > 0 && toneUp < toneDown) || (val == 0 && toneDown == 255))

					pixDown->setTone(toneUp);

				if ((255 - toneDown) * (1 - val) <= val * (255 - toneUp - 1)) //val==0 -> if (toneDown == 255)....

																			  //val==0.5 -> if (toneup

																			  //val==1 -> if (toneup<255)...

					pixDown->setInk(inkIndex);

			}

			pixUp++;

			pixDown++;

		}

	}

}

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

} //namespace

#ifdef LEVO

void TRop::eraseColors(TRasterCM32P ras, vector<int> &colorIds, bool eraseInks, bool keepColor)</int>

{

	assert(ras);

	vector<int> curColorIds;</int>

	std::sort(colorIds.begin(), colorIds.end());

	if (!keepColor)

		curColorIds = colorIds;

	else {

		//prendo tutti i colori ECCETTO quelli nel vettore colorIds

		unsigned int count1 = 0, count2 = 0;

		int size = eraseInks ? TPixelCM32::getMaxInk() : TPixelCM32::getMaxPaint();

		curColorIds.resize(size + 1 - colorIds.size());

		for (int i = 0; i < size; i++)

			if (count1 < colorIds.size() && colorIds[count1] == i)

				count1++;

			else

				curColorIds[count2++] = i;

	}

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

		TPixelCM32 *pix = ras->pixels(y), *endPix = pix + ras->getLx();

		while (pix < endPix) {

			unsigned int i;

			int color = eraseInks ? pix->getInk() : pix->getPaint();

			if (color != 0)

				for (i = 0; i < curColorIds.size() && curColorIds[i] <= color; i++)

					if (color == curColorIds[i]) {

						*pix = eraseInks ? TPixelCM32(0, pix->getPaint(), TPixelCM32::getMaxTone()) : TPixelCM32(pix->getInk(), 0, pix->getTone());

						break;

					}

			pix++;

		}

	}

}

#endif

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

void TRop::eraseColors(TRasterCM32P ras, std::vector<int> *colorIds, bool eraseInks)</int>

{

	if (colorIds)

		std::sort(colorIds->begin(), colorIds->end());

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

		TPixelCM32 *pix = ras->pixels(y), *endPix = pix + ras->getLx();

		for (; pix < endPix; pix++) {

			unsigned int i = 0;

			int color = eraseInks ? pix->getInk() : pix->getPaint();

			if (color == 0)

				continue;

			if (colorIds) {

				while (i < colorIds->size() && (*colorIds)[i] < color)

					i++;

				if (i == colorIds->size() || color != (*colorIds)[i])

					continue;

			}

			if (eraseInks) {

				pix->setInk(0);

				pix->setTone(TPixelCM32::getMaxTone());

			} else

				pix->setPaint(0);

		}

	}

}

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

/*

void TRop::overaCmapped(TRasterCM32P rasOut, const TRasterCM32P& rasUp, const TPaletteP &pltOut, int matchlinePrevalence, std::map<int,int>& usedColors)</int,int>

{

doMergeCmapped(rasOut, rasUp, pltOut, false, matchlinePrevalence, usedColors);

}

*/

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

void TRop::applyMatchLines(TRasterCM32P rasOut, const TRasterCM32P &rasUp, const TPaletteP &pltOut, int inkIndex, int matchlinePrevalence, std::map<int, int=""> &usedInks)</int,>

{

	assert(matchlinePrevalence >= 0);

	if (inkIndex == -1)

		doMergeCmapped(rasOut, rasUp, pltOut, true, matchlinePrevalence, usedInks);

	else

		doApplyMatchLines(rasOut, rasUp, inkIndex, matchlinePrevalence);

}

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

void TRop::eraseStyleIds(TToonzImage *image, const std::vector<int> styleIds)</int>

{

	assert(image);

	TRasterCM32P ras = image->getRaster();

	int i;

	for (i = 0; i < (int)styleIds.size(); i++) {

		int styleId = styleIds[i];

		ras->lock();

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

			TPixelCM32 *pix = ras->pixels(y), *endPix = pix + ras->getLx();

			while (pix < endPix) {

				bool isPaint = (pix->getPaint() == styleId);

				bool isInk = (pix->getInk() == styleId);

				if (!isPaint && !isInk) {

					pix++;

					continue;

				} else if (isPaint && !isInk)

					*pix = TPixelCM32(pix->getInk(), 0, pix->getTone());

				else if (!isPaint && isInk)

					*pix = TPixelCM32(0, pix->getPaint(), TPixelCM32::getMaxTone());

				else if (isPaint && isInk)

					*pix = TPixelCM32(0, 0, pix->getTone());

				else

					assert(0);

				pix++;

			}

		}

		ras->unlock();

	}

}

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

inline bool isTransparent(TPixelCM32 *pix)

{

	return (((*((ULONG *)pix)) & 0x000fffff) == 0xff);

}

void TRop::overlayCmapped(TRasterCM32P rasOut, const TRasterCM32P &rasUp, const TPaletteP &pltOut, const TPaletteP &upPlt, std::map<int, int=""> &usedColors)</int,>

{

	assert(rasOut && rasUp);

	assert(rasOut->getSize() == rasUp->getSize());

	TPaletteP downPlt = pltOut->clone();

	std::map<int, int="">::iterator it;</int,>

	for (it = usedColors.begin(); it != usedColors.end(); it++)

		downPlt->getPage(0)->addStyle(TPixel32::Red);

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

		TPixelCM32 *pixDown = rasOut->pixels(y);

		TPixelCM32 *pixUp = rasUp->pixels(y);

		for (int x = 0; x < rasOut->getLx(); x++, pixUp++, pixDown++) {

			if (isTransparent(pixUp)) //WARNING! cannot check transparent pixels with *pixup==TPixelCM32() since also 0x183000ff i.e., is a valid transparent value

				continue;

			int tone = pixUp->getTone();

			if (isTransparent(pixDown) || tone == 255 || tone == 0 || pixUp->getPaint() != 0) //up e' punto interno, o esterno non antialiasato

			{

				addColors(*pixUp, downPlt, upPlt, usedColors);

				pixDown->setInk(usedColors[pixUp->getInk()]);

				pixDown->setPaint(usedColors[pixUp->getPaint()]);

				pixDown->setTone(tone);

			} else if (tone <= pixDown->getTone() || tone < 128) //up e' bordo esterno antialiasato piu' opaco di down

			{

				int ink = pixUp->getInk();

				if (usedColors.find(ink) == usedColors.end())

					addColor(downPlt, ink, upPlt, usedColors);

				pixDown->setInk(usedColors[ink]);

				pixDown->setTone(tone < 128 ? 0 : tone);

			}

		}

	}

}

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

namespace

{

#define MAGICFAC (257U * 256U + 1U)

/*

#define PIX_CM32_PENMAP_IDX(PIX) ((PIX)>>12 & 0xfff00 | (PIX) & 0xff)

#define PIX_CM32_COLMAP_IDX(PIX) ((PIX) & 0xfffff)

#define PIX_CM32_PENMAP_COLMAP_TO_RGBM(PIX,PENMAP,COLMAP,RES) \

  { \

  ULONG _r = (PIX); \

  ULONG _s = ((ULONG *)(PENMAP))[MY_PIX_CM32_PENMAP_IDX(_r)] + \

             ((ULONG *)(COLMAP))[MY_PIX_CM32_COLMAP_IDX(_r)]; \

  (RES) = *(LPIXEL *)(&_s); \