#include "toonz/toonzimageutils.h"

#include "tstroke.h"

#include "tpalette.h"

#include "tofflinegl.h"

#include "tvectorrenderdata.h"

#include "tvectorgl.h"

#include "trop.h"

#include "toonz/ttileset.h"

#include "toonz/tcenterlinevectorizer.h"

#include "tregion.h"

#include "trasterimage.h"

#include "ttoonzimage.h"

#include "ttzpimagefx.h"

#include "tlevel_io.h"

#include "tsystem.h"

#include "tstream.h"

#include "tsimplecolorstyles.h"

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

namespace

{

const int BackgroundStyle = 0;

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

TRect rasterizeStroke(TOfflineGL *&gl, const TRect &rasBounds, TStroke *stroke,

					  TPalette *palette, const TRectD &clip, bool doAntialias)

{

	TRectD bbox = clip * stroke->getBBox();

	TRect rect = convert(bbox).enlarge(1) * rasBounds;

	if (rect.getLx() <= 0 || rect.getLy() <= 0)

		return TRect();

	gl = new TOfflineGL(rect.getSize());

	gl->makeCurrent();

	gl->clear(TPixel32::White);

	TPaletteP plt = palette->clone();

	int styleId = stroke->getStyle();

	TColorStyleP style = plt->getStyle(styleId);

	assert(style);

	style->setMainColor(TPixel32::Black);

	TTranslation affine(-convert(rect.getP00()));

	TVectorRenderData rd(affine, gl->getBounds(), plt.getPointer(), 0, false, doAntialias);

	tglDraw(rd, stroke);

	glFinish();

	return rect;

}

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

TRect rasterizeStroke(TOfflineGL *&gl, TRect rasBounds, TStroke *stroke, TRectD clip, bool filled = false)

{

	TDimension d = rasBounds.getSize();

	TPointD offset(d.lx * 0.5, d.ly * 0.5);

	TTranslation offsetMatrix(offset);

	TRectD strokeBBox = stroke->getBBox().enlarge(2);

	if (!clip.isEmpty())

		strokeBBox = offsetMatrix * (strokeBBox * clip);

	else

		strokeBBox = offsetMatrix * strokeBBox;

	TRect rect = ToonzImageUtils::convertWorldToRaster(strokeBBox, 0) * rasBounds;

	if (!rect.isEmpty()) {

		gl = new TOfflineGL(rect.getSize());

		gl->makeCurrent();

		glClearColor(1, 1, 1, 1);

		glClear(GL_COLOR_BUFFER_BIT);

		TPalette *palette = new TPalette();

		TTranslation affine(-strokeBBox.getP00() + offset);

		TVectorRenderData rd(affine, gl->getBounds(), palette, 0, false, true);

		int oldStyle = stroke->getStyle();

		stroke->setStyle(1);

		if (filled) {

			TVectorImage vi;

			vi.addStroke(new TStroke(*stroke));

			vi.findRegions();

			vi.selectFill(vi.getBBox().enlarge(2), 0, 1, false, true, false);

			tglDraw(rd, &vi);

		} else

			tglDraw(rd, stroke);

		delete palette;

		stroke->setStyle(oldStyle);

		glFinish();

	}

	return rect;

}

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

TRect rasterizeRegion(TOfflineGL *&gl, TRect rasBounds, TRegion *region, TRectD clip)

{

	TRectD regionBBox = region->getBBox();

	if (!clip.isEmpty())

		regionBBox = regionBBox * clip;

	TRect rect = convert(regionBBox) * rasBounds;

	if (!rect.isEmpty()) {

		gl = new TOfflineGL(rect.getSize());

		gl->makeCurrent();

		gl->clear(TPixel32::White);

		glPushAttrib(GL_ALL_ATTRIB_BITS);

		glEnable(GL_ALPHA_TEST);

		glAlphaFunc(GL_GREATER, 0);

		TPalette *palette = new TPalette();

		TTranslation affine(-convert(rect.getP00()));

		TVectorRenderData rd(affine, gl->getBounds(), palette, 0, true, true);

		int oldStyle = region->getStyle();

		region->setStyle(1);

		tglDraw(rd, region);

		glDisable(GL_ALPHA_TEST);

		glPopAttrib();

		region->setStyle(oldStyle);

		glFinish();

		delete palette;

	}

	return rect;

}

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

void fastAddPaintRegion(const TToonzImageP &ti, TRegion *region,

						int newPaintId, int maxStyleId, TRectD clip = TRectD())

{

	TRasterCM32P ras = ti->getRaster();

	TOfflineGL *gl;

	TRect rect = rasterizeRegion(gl, ras->getBounds(), region, clip);

	if (rect.isEmpty())

		return;

	TRaster32P glRas = gl->getRaster();

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

	ras->lock();

	glRas->lock();

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

		TPixel32 *inPix = glRas->pixels(y - rect.y0);

		TPixelCM32 *outPix = ras->pixels(y) + rect.x0;

		TPixel32 *inEndPix = inPix + rect.x1 - rect.x0 + 1;

		for (; inPix < inEndPix; ++outPix, ++inPix)

			if (inPix->r < 128) {

				outPix->setPaint(newPaintId);

				outPix->setTone(255);

			}

	}

	ras->unlock();

	glRas->unlock();

	delete gl;

	TRegion *subregion;

	UINT i = 0;

	for (; i < region->getSubregionCount(); ++i) {

		subregion = region->getSubregion(i);

		fastAddPaintRegion(ti, subregion, tmin(maxStyleId, subregion->getStyle()), maxStyleId);

	}

}

}

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

TRect ToonzImageUtils::convertWorldToRaster(const TRectD area, const TToonzImageP ti)

{

	if (area.isEmpty())

		return TRect();

	if (!ti || !ti->getRaster())

		return TRect(tfloor(area.x0), tfloor(area.y0), tfloor(area.x1) - 1, tfloor(area.y1) - 1);

	TRasterCM32P ras = ti->getRaster();

	TRectD rect(area + ras->getCenterD());

	return TRect(tfloor(rect.x0), tfloor(rect.y0), tceil(rect.x1) - 1, tceil(rect.y1) - 1);

}

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

TRectD ToonzImageUtils::convertRasterToWorld(const TRect area, const TToonzImageP ti)

{

	if (area.isEmpty())

		return TRectD();

	TRectD rect(area.x0, area.y0, area.x1 + 1, area.y1 + 1);

	if (ti && ti->getRaster())

		rect = rect - ti->getRaster()->getCenterD();

	return rect;

}

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

//clip in coordinate world (cioe' della stroke)

//overlaying inks, blend inks always "lose" on normal inks

TRect fastAddInkStroke(const TToonzImageP &ti, TStroke *stroke, int inkId, bool selective,

					   bool filled, TRectD clip, bool doAntialiasing = true, const set<int> &blendInks = set<int>())</int></int>

{

	TRasterCM32P ras = ti->getRaster();

	TOfflineGL *gl = 0;

	TRect rectRender = rasterizeStroke(gl, ras->getBounds(), stroke, ti->getPalette(), clip, doAntialiasing);

	if (!gl)

		return TRect();

	TRaster32P glRas = gl->getRaster();

	TRasterCM32P outRas = ras->extract(rectRender);

	assert(glRas->getSize() == outRas->getSize());

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

	outRas->lock();

	glRas->lock();

	bool isBlendInkUp = (blendInks.find(inkId) != blendInks.end());

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

		TPixel32 *inPix = glRas->pixels(y);

		TPixelCM32 *outPix = outRas->pixels(y);

		for (int x = 0; x < outRas->getLx(); ++outPix, ++inPix, ++x) {

			int upTone = inPix->r;

			int dnTone = outPix->getTone();

			if (doAntialiasing) {

				//overlaying inks, blend inks always "lose" on normal inks

				bool isBlendInkDn = (blendInks.find(outPix->getInk()) != blendInks.end());

				if (isBlendInkUp && !isBlendInkDn && dnTone < 255)

					continue;

				if (isBlendInkDn && !isBlendInkUp && upTone < 255) {

					*outPix = TPixelCM32(inkId, outPix->getPaint(), upTone);

					continue;

				}

				//The upper pixel replaces the lower one, *if*

				//  a) It's more opaque

				//  b) If the ink id id not the same, ink is not completely transparent

				//  c)  ...

				if ((upTone <= dnTone) &&

					((outPix->getInk() == inkId) || (upTone != 255)) &&

					(!selective || !outPix->isPureInk()))

					*outPix = TPixelCM32(inkId, outPix->getPaint(), upTone);

			} else {

				if (!selective || !outPix->isPureInk()) {

					//if(upTone<=192 && upTone<=dnTone)

					if (upTone == 0)

						*outPix = TPixelCM32(inkId, outPix->getPaint(), 0);

				}

			}

		}

	}

	outRas->unlock();

	glRas->unlock();

	delete gl;

	return rectRender;

}

//clip in coordinate world (cioe' della stroke)

TRect ToonzImageUtils::addInkStroke(const TToonzImageP &ti, TStroke *stroke, int inkId, bool selective,

									bool filled, TRectD clip, bool doAntialiasing)

{

	TStroke *s = new TStroke(*stroke);

	TPoint tiCenter = ti->getRaster()->getCenter();

	s->transform(TTranslation(tiCenter.x, tiCenter.y));

	TRect rect = fastAddInkStroke(ti, s, inkId, selective, filled, clip, doAntialiasing);

	rect -= tiCenter;

	return rect;

}

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

TRect ToonzImageUtils::changeColorStroke(const TToonzImageP &ti, const ChangeColorStrokeSettings &settings)

{

	if (!settings.changeInk && !settings.changePaint)

		return TRect();

	TRasterCM32P ras = ti->getRaster();

	TOfflineGL *gl;

	TRect rect = rasterizeStroke(gl, ras->getBounds(), settings.stroke, settings.clip);

	if (rect.isEmpty()) {

		return rect;

	}

	TRaster32P glRas = gl->getRaster();

	ras->lock();

	glRas->lock();

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

		TPixel32 *inPix = glRas->pixels(y - rect.y0);

		TPixelCM32 *outPix = ras->pixels(y) + rect.x0;

		TPixel32 *inEndPix = inPix + rect.x1 - rect.x0 + 1;

		for (; inPix < inEndPix; ++outPix, ++inPix) {

			if (inPix->r < 128 && settings.changeInk && !outPix->isPurePaint())

				outPix->setInk(settings.colorId);

			if (inPix->r < 128 && settings.changePaint &&

				(settings.maskPaintId == -1 || outPix->getPaint() == settings.maskPaintId))

				outPix->setPaint(settings.colorId);

		}

	}

	delete gl;

	ras->unlock();

	glRas->unlock();

	return rect;

}

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

TRect ToonzImageUtils::eraseRect(const TToonzImageP &ti, const TRectD &area, int maskId, bool onInk, bool onPaint)

{

	assert(onInk || onPaint);

	TRasterCM32P ras = ti->getRaster();

	TRect rect = convertWorldToRaster(area, ti) * ras->getBounds();

	if (rect.isEmpty())

		return rect;

	ras->lock();

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

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

		TPixelCM32 *endPix = ras->pixels(y) + rect.x1 + 1;

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

			if (onPaint && (maskId == -1 || maskId == pix->getPaint()))

				pix->setPaint(BackgroundStyle);

			if (onInk && (maskId == -1 || maskId == pix->getInk()))

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

		}

	}

	ras->unlock();

	return rect;

}

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

std::vector<trect> ToonzImageUtils::paste(const TToonzImageP &ti, const TTileSetCM32 *tileSet)</trect>

{

	std::vector<trect> rects;</trect>

	TRasterCM32P raster = ti->getRaster();

	//for(int i=0;i<tileset->getTileCount();i++)</tileset->

	for (int i = tileSet->getTileCount() - 1; i >= 0; i--) {

		const TTileSetCM32::Tile *tile = tileSet->getTile(i);

		TRasterCM32P rasCM32;

		tile->getRaster(rasCM32);

		assert(!!rasCM32);

		raster->copy(rasCM32, tile->m_rasterBounds.getP00());

		rects.push_back(tile->m_rasterBounds);

	}

	return rects;

}

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

// DA RIFARE

// e' lenta da far schifo

//!Converts a TVectorImage into a TToonzImage. The input vector image

//!is transformed through the passed affine \b aff, and put into a

//!TToonzImage strictly covering the bounding box of the transformed

//!vector image. The output image has its lower-left position in the

//!world reference specified by the \b pos parameter, which is granted to

//!be an integer displacement of the passed value. Additional parameters

//!include an integer \b enlarge by which the output image is enlarged with

//!respect to the transformed image's bbox, and the bool \b transformThickness

//!to specify whether the transformation should involve strokes' thickensses

//!or not.

TToonzImageP ToonzImageUtils::vectorToToonzImage(

	const TVectorImageP &vimage, const TAffine &aff, TPalette *palette,

	const TPointD &outputPos, const TDimension &outputSize,

	const std::vector<trasterfxrenderdatap> *fxs, bool transformThickness)</trasterfxrenderdatap>

{

	if (!vimage || !palette)

		return 0;

	//Transform the vector image through aff

	TVectorImageP vi = vimage->clone();

	vi->transform(aff, transformThickness);

	//Allocate the output ToonzImage

	TRasterCM32P raster(outputSize.lx, outputSize.ly);

	raster->clear();

	TToonzImageP ti(raster, raster->getBounds());

	ti->setPalette(palette->clone());

	//Shift outputPos to the origin

	vi->transform(TTranslation(-outputPos));

	int strokeCount = vi->getStrokeCount();

	std::vector<int> strokeIndex(strokeCount);</int>

	std::vector<tstroke *=""> strokes(strokeCount);</tstroke>

	int maxStyleId = palette->getStyleCount() - 1;

	int i;

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

		strokeIndex[i] = i;

		strokes[i] = vi->getStroke(i);

	}

	vi->notifyChangedStrokes(strokeIndex, strokes);

	int regionCount = vi->getRegionCount();

	//In such reference, the clip for rendering strokes is the output size

	TRectD clip(TDimensionD(outputSize.lx, outputSize.ly));

	set<int> colors;</int>

	if (fxs) {

		for (i = 0; i < (int)fxs->size(); i++) {

			SandorFxRenderData *sandorData = dynamic_cast<sandorfxrenderdata *="">((*fxs)[i].getPointer());</sandorfxrenderdata>

			if (sandorData && sandorData->m_type == BlendTz) {

				std::string indexes = toString(sandorData->m_blendParams.m_colorIndex);

				std::vector<std::string> items;</std::string>

				parseIndexes(indexes, items);

				PaletteFilterFxRenderData paletteFilterData;

				insertIndexes(items, &paletteFilterData);

				colors.insert(paletteFilterData.m_colors.begin(), paletteFilterData.m_colors.end());

			}

		}

	}

	int k, l;

	for (i = 0; i < strokeCount;) {

		//Draw all regions which have the same group.

		for (k = 0; k < regionCount; ++k)

			if (vi->areDifferentGroup(i, false, k, true) == -1) {

				TRegion *region = vi->getRegion(k);

				fastAddPaintRegion(ti, region, tmin(maxStyleId, region->getStyle()), maxStyleId);

			}

		//Find the first stroke which does not belong to the group

		for (k = i; k < strokeCount && vi->areDifferentGroup(i, false, k, false) == -1; ++k)

			;

		//Draw all found strokes

		for (l = i; l < k; ++l) {

			TStroke *stroke = vi->getStroke(l);

			bool visible = false;

			int styleId = stroke->getStyle();

			TColorStyleP style = palette->getStyle(styleId);

			assert(style);

			int colorCount = style->getColorParamCount();

			if (colorCount == 0)

				visible = true;

			else {

				visible = false;

				for (int j = 0; j < style->getColorParamCount() && !visible; j++) {

					TPixel32 color = style->getColorParamValue(j);

					if (color.m != 0)

						visible = true;

				}

			}

			if (visible)

				fastAddInkStroke(ti, stroke, tmin(maxStyleId, stroke->getStyle()), false, false, clip, true, colors);

		}

		i = k;

	}

	return ti;

}

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

TPalette *ToonzImageUtils::loadTzPalette(const TFilePath &pltFile)

{

	TImageP pltImg;

	TImageReader loader(pltFile);

	pltImg = loader.load();

	TRasterImageP pltRasImg(pltImg);

	if (!pltRasImg)

		return 0;

	TRaster32P rasPlt = pltRasImg->getRaster();

	if (!rasPlt)

		return 0;

	std::map<int, std::pair<std::string,="" std::string="">> pltColorNames;</int,>

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

	loader.getTzpPaletteColorNames(pltColorNames);

	TPalette *palette = new TPalette();

	const int offset = 0;

	assert(rasPlt->getLy() == 2);

	rasPlt->lock();

	TPixel32 *pixelRow = rasPlt->pixels(0);

	int x = 0;

	int count = palette->getStyleCount();

	for (; x < rasPlt->getLx(); ++x) {

		TSolidColorStyle *style = new TSolidColorStyle(pixelRow[x]);

		if ((it = pltColorNames.find(x)) != pltColorNames.end()) {

			std::string styleName = it->second.second;

			style->setName(toWideString(styleName));

		}

		if (x < count)

			palette->setStyle(x, style);

		//palette->setStyle(x, pixelRow[x]);

		else

			palette->addStyle(style);

	}

	// aggiungo solo i colori usati (salvo il BG)

	TPalette::Page *page = palette->getPage(0);

	// nella pagina c'e' gia' lo sfondo e il colore 1:

	// tolgo quest'ultimo

	page->removeStyle(1);

	// aggiungo gli altri

	std::map<std::wstring, int=""> pages;</std::wstring,>

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

	pixelRow = rasPlt->pixels(1);

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

		if ((it = pltColorNames.find(x)) != pltColorNames.end()) {

			std::wstring pageName;

			pageName = toWideString(it->second.first);

			if (x == 0) {

				page = palette->getPage(0);

				page->setName(pageName);

				pages[pageName] = 0;

			} else if ((itpage = pages.find(pageName)) != pages.end())

				page = palette->getPage(itpage->second);

			else {

				page = palette->addPage(pageName);

				pages[pageName] = page->getIndex();

			}

		} else

			page = palette->getPage(0);

		if (pixelRow[x].r == 255)

			page->addStyle(offset + x);

	}

	rasPlt->unlock();

	return palette;

}

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

void ToonzImageUtils::getUsedStyles(std::set<int> &styles, const TToonzImageP &ti)</int>

{

	TRasterCM32P ras = ti->getRaster();

	if (!ras)

		return;

	int lx = ras->getLx();

	int ly = ras->getLy();

	ras->lock();

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

		TPixelCM32 *pix = ras->pixels(y);

		TPixelCM32 *endPix = pix + lx;

		while (pix < endPix) {

			styles.insert(pix->getInk());

			styles.insert(pix->getPaint());

			++pix;

		}

	}

	ras->unlock();

}

void ToonzImageUtils::scrambleStyles(const TToonzImageP &ti, std::map<int, int=""> styleTable)</int,>

{

	TRasterCM32P ras = ti->getRaster();

	if (!ras)

		return;

	if (styleTable.empty())

		return;

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

	std::vector<int> lut(4096, -1);</int>

	bool isIdentity = true;

	for (it = styleTable.begin(); it != styleTable.end(); ++it) {

		int j = it->first, k = it->second;

		assert(j >= 0);

		assert(j < 1000000);

		if (j >= (int)lut.size())

			lut.resize(j + 1, -1);

		lut[j] = k;

		if (j != k)

			isIdentity = false;

	}

	if (isIdentity)

		return;

	int m = lut.size();

	int lx = ras->getLx();

	int ly = ras->getLy();

	ras->lock();

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

		TPixelCM32 *pix = ras->pixels(y);

		TPixelCM32 *endPix = pix + lx;

		while (pix < endPix) {

			int ink = pix->getInk();

			if (0 <= ink && ink < m && lut[ink] >= 0)

				ink = lut[ink];

			int paint = pix->getPaint();

			if (0 <= paint && paint < m && lut[paint] >= 0)

				paint = lut[paint];

			if (ink != pix->getInk() || paint != pix->getPaint()) {

				*pix = TPixelCM32(ink, paint, pix->getTone());

			}

			++pix;

		}

	}

	ras->unlock();

}

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

#ifdef LEVO

bool ToonzImageUtils::convertToTlv(const TFilePath &levelPathIn)

{

	try {

		TFilePath levelPathOut = levelPathIn.getParentDir() + TFilePath(levelPathIn.getWideName() + L".tlv");

		TLevelReaderP lr(levelPathIn);

		TLevelP level = lr->loadInfo();

		TLevelWriterP lw(levelPathOut, 0);

		TPalette *plt = new TPalette();

		TLevel::Iterator it = level->begin();

		TLevel::Iterator end = level->end();

		for (; it != level->end(); ++it) {

			try {

				TImageReaderP ir = lr->getFrameReader(it->first);

				TRasterImageP img = ir->load();

				double dpix, dpiy;

				img->getDpi(dpix, dpiy);

				TRasterCM32P raster(convert(img->getBBox()).getSize());

				TRop::convert(raster, img->getRaster());

				TImageWriterP iw = lw->getFrameWriter(it->first);

				TToonzImageP outimg(raster, raster->getBounds());

				outimg->setDpi(dpix, dpiy);

				outimg->setPalette(plt);

				iw->save(outimg);

			} catch (...) {

				return false;

				//string msg="Frame "+toString(it->first.getNumber())+": conversion failed!";

				//cout << msg << endl;

			}

		}

		TFilePath pltPath = lw->getFilePath().withNoFrame().withType("tpl");

		if (TSystem::touchParentDir(pltPath)) {

			if (TSystem::doesExistFileOrLevel(pltPath))

				TSystem::removeFileOrLevel(pltPath);

			TOStream os(pltPath);

			os << plt;

		}

		lr = TLevelReaderP();

		lw = TLevelWriterP();

		//delete plt;

		return true;

	} catch (...) {

		return false;

	}

}

#endif

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

void ToonzImageUtils::eraseImage(const TToonzImageP &ti, const TRaster32P &image, const TPoint &pos,

								 bool invert, bool eraseInk, bool erasePaint, bool selective, int styleId)

{

	TRect rasBounds = ti->getRaster()->getBounds();

	TRect imageBounds = image->getBounds() + pos;

	if (invert) {

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

	  	┌───┬─┐

	  	│③　　│②│

	  	├─┬─┤　│

	  	│④│★│　│

	  	│　├─┴─┤

	  	│　│①　　│

	  	└─┴───┘

	   ★はFreeHandで囲んだ領域のバウンディングボックス

	   外側のワクはラスタ画像のフチ

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

		TRect rect;

		/*- ①の部分を消す -*/

		if (rasBounds.y0 != imageBounds.y0) {

			rect = TRect(imageBounds.x0, rasBounds.y0, rasBounds.x1, imageBounds.y0);

			ToonzImageUtils::eraseRect(ti, ToonzImageUtils::convertRasterToWorld(rect, ti),

									   selective ? styleId : -1, eraseInk, erasePaint);

		}

		/*- ②の部分を消す -*/

		if (imageBounds.x1 != rasBounds.x1) {

			rect = TRect(imageBounds.x1, imageBounds.y0, rasBounds.x1, rasBounds.y1);

			ToonzImageUtils::eraseRect(ti, ToonzImageUtils::convertRasterToWorld(rect, ti),

									   selective ? styleId : -1, eraseInk, erasePaint);

		}

		/*- ③の部分を消す -*/

		if (imageBounds.y1 != rasBounds.y1) {

			rect = TRect(rasBounds.x0, imageBounds.y1, imageBounds.x1, rasBounds.y1);

			ToonzImageUtils::eraseRect(ti, ToonzImageUtils::convertRasterToWorld(rect, ti),

									   selective ? styleId : -1, eraseInk, erasePaint);

		}

		/*- ④の部分を消す -*/

		if (rasBounds.x0 != imageBounds.x0) {

			rect = TRect(rasBounds.x0, rasBounds.y0, imageBounds.x0, imageBounds.y1);

			ToonzImageUtils::eraseRect(ti, ToonzImageUtils::convertRasterToWorld(rect, ti),

									   selective ? styleId : -1, eraseInk, erasePaint);

		}

	}

	TRasterCM32P workRas = ti->getRaster()->extract(imageBounds);

	int y;

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

		TPixelCM32 *outPix = workRas->pixels(y);

		TPixelCM32 *outEndPix = outPix + workRas->getLx();

		TPixel32 *inPix = image->pixels(y);

		for (outPix; outPix != outEndPix; outPix++, inPix++) {

			bool canEraseInk = !selective || (selective && styleId == outPix->getInk());

			bool canErasePaint = !selective || (selective && styleId == outPix->getPaint());

			int paint, tone;

			if (!invert) {

				paint = inPix->m > 0 && erasePaint && canErasePaint ? 0 : outPix->getPaint();

				tone = inPix->m > 0 && eraseInk && canEraseInk ? tmax(outPix->getTone(), (int)inPix->m) : outPix->getTone();

			} else {

				paint = inPix->m < 255 && erasePaint && canErasePaint ? 0 : outPix->getPaint();

				tone = inPix->m < 255 && eraseInk && canEraseInk ? tmax(outPix->getTone(), 255 - (int)inPix->m) : outPix->getTone();

			}

			*outPix = TPixelCM32(outPix->getInk(), paint, tone);

		}

	}

}

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

std::string ToonzImageUtils::premultiply(const TFilePath &levelPath)

{

	assert(0);

	/*

if (levelPath==TFilePath())

  return "";

if(!TSystem::doesExistFileOrLevel(levelPath))

  return string("Can't find level")+toString(levelPath.getWideString());

TFileType::Type type = TFileType::getInfo(levelPath);

if(type == TFileType::CMAPPED_LEVEL)

  return "Cannot premultiply the selected file.";

if (type == TFileType::VECTOR_LEVEL || type == TFileType::VECTOR_IMAGE)

  return "Cannot premultiply a vector-based level.";

if (type != TFileType::RASTER_LEVEL && type != TFileType::RASTER_IMAGE)

  return "Cannot premultiply the selected file.";

try 

  {

  TLevelReaderP lr = TLevelReaderP(levelPath);

  if (!lr) return "";    

  TLevelP level =  lr->loadInfo();

  if(!level || level->getFrameCount()==0) return "";

  string format = levelPath.getType();

  TPropertyGroup* prop = 

    TApplication::instance()

    ->getCurrentScene()

    ->getProperties()

    ->getOutputProperties()

    ->getFileFormatProperties(format)

    ->clone();

  assert(prop);

  TEnumProperty *p = (TEnumProperty*)prop->getProperty("Bits Per Pixel");

  int bpp = p?atoi((toString(p->getValue()).c_str())):32; 

  if (bpp!=32 && bpp!=64) //non ha senso premoltiplicare senza il canale alpha...

    {

    if (bpp<32)

      p->setValue(L"32(RGBM)");

    else 

      p->setValue(L"64(RGBM)");

    }

  bool isMovie = (format=="mov" || format=="avi" || format=="3gp");

  TLevelWriterP lw;

  if (!isMovie)

    {

    lw = TLevelWriterP(levelPath, prop);

    if (!lw) return "";

    }

  int count = 0;

  TLevel::Iterator it = level->begin();

  for (;it!=level->end(); ++it)

    {  

    TImageReaderP ir = lr->getFrameReader(it->first);

    TRasterImageP rimg = (TRasterImageP)ir->load();

    if (!rimg)

      continue;

    TRop::premultiply(rimg->getRaster());

    ir = 0;

    if (isMovie)

      level->setFrame(it->first, rimg);

    else

      {

      TImageWriterP iw = lw->getFrameWriter(it->first);	 

      iw->save(rimg);

      iw = 0;

      }

    }

  lr = TLevelReaderP();

  if (isMovie)

    {

    TSystem::deleteFile(levelPath);

    lw = TLevelWriterP(levelPath, prop);

    if (!lw) return "";

    lw->save(level);

    }

  if (prop)

    delete prop;

  }catch(...) 

    {

	return "Cannot premultiply the selected file.";

    }  

    */

	return "";

}