#include "tfxparam.h"

#include "tparamset.h"

#include "stdfx.h"

#include "time.h"

#include "trop.h"

#include "trasterfx.h"

#include "ttzpimagefx.h"

#include "toonz/tdistort.h"

#include "texturefxP.h"

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

namespace

{

inline bool myIsEmpty(const TRectD &r)

{

	return r.x0 >= r.x1 || r.y0 >= r.y1;

}

}

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

class CornerPinFx : public TStandardRasterFx

{

	FX_PLUGIN_DECLARATION(CornerPinFx)

	enum { PERSPECTIVE,

		   BILINEAR };

public:

	CornerPinFx();

	~CornerPinFx();

	bool doGetBBox(double frame, TRectD &bBox, const TRenderSettings &info);

	void doCompute(TTile &tile, double frame, const TRenderSettings &ri);

	void doDryCompute(TRectD &rect, double frame, const TRenderSettings &info);

	int getMemoryRequirement(const TRectD &rect, double frame, const TRenderSettings &info);

	void onPortConnected(TFxPort *port);

	bool canHandle(const TRenderSettings &info, double frame) { return true; }

	bool allowUserCacheOnPort(int port) { return port != 0; }

	void transform(double frame,

				   int port,

				   const TRectD &rectOnOutput,

				   const TRenderSettings &infoOnOutput,

				   TRectD &rectOnInput,

				   TRenderSettings &infoOnInput);

	void safeTransform(

		double frame,

		int port,

		const TRectD &rectOnOutput,

		const TRenderSettings &infoOnOutput,

		TRectD &rectOnInput,

		TRenderSettings &infoOnInput,

		TRectD &inBBox);

private:

	TRasterFxPort m_input;

	TRasterFxPort m_texture;

	TIntEnumParamP m_distortType;

	TPointParamP m_p00_a;

	TPointParamP m_p00_b;

	TPointParamP m_p01_a;

	TPointParamP m_p01_b;

	TPointParamP m_p11_a;

	TPointParamP m_p11_b;

	TPointParamP m_p10_a;

	TPointParamP m_p10_b;

	TBoolParamP m_deactivate;

	TStringParamP m_string;

	TIntEnumParamP m_mode;

	TIntEnumParamP m_keep;

	TDoubleParamP m_value;

	TAffine getPort1Affine(double frame) const;

};

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

CornerPinFx::CornerPinFx()

	: m_distortType(new TIntEnumParam(PERSPECTIVE, "Perspective")), m_deactivate(false), m_string(L"1,2,3"), m_mode(new TIntEnumParam(SUBSTITUTE, "Texture")), m_keep(new TIntEnumParam(0, "Delete")), m_value(100)

{

	double ext = 400.;

	double inn = 400.;

	m_p00_a = TPointD(-ext, -ext);

	m_p00_b = TPointD(-inn, -inn);

	m_p01_a = TPointD(-ext, ext);

	m_p01_b = TPointD(-inn, inn);

	m_p11_a = TPointD(ext, ext);

	m_p11_b = TPointD(inn, inn);

	m_p10_a = TPointD(ext, -ext);

	m_p10_b = TPointD(inn, -inn);

	m_p00_b->getX()->setMeasureName("fxLength");

	m_p00_b->getY()->setMeasureName("fxLength");

	m_p10_b->getX()->setMeasureName("fxLength");

	m_p10_b->getY()->setMeasureName("fxLength");

	m_p01_b->getX()->setMeasureName("fxLength");

	m_p01_b->getY()->setMeasureName("fxLength");

	m_p11_b->getX()->setMeasureName("fxLength");

	m_p11_b->getY()->setMeasureName("fxLength");

	m_p00_a->getX()->setMeasureName("fxLength");

	m_p00_a->getY()->setMeasureName("fxLength");

	m_p10_a->getX()->setMeasureName("fxLength");

	m_p10_a->getY()->setMeasureName("fxLength");

	m_p01_a->getX()->setMeasureName("fxLength");

	m_p01_a->getY()->setMeasureName("fxLength");

	m_p11_a->getX()->setMeasureName("fxLength");

	m_p11_a->getY()->setMeasureName("fxLength");

	bindParam(this, "distort_type", m_distortType);

	bindParam(this, "bottom_left_b", m_p00_b);

	bindParam(this, "bottom_right_b", m_p10_b);

	bindParam(this, "top_left_b", m_p01_b);

	bindParam(this, "top_right_b", m_p11_b);

	bindParam(this, "bottom_left_a", m_p00_a);

	bindParam(this, "bottom_right_a", m_p10_a);

	bindParam(this, "top_left_a", m_p01_a);

	bindParam(this, "top_right_a", m_p11_a);

	bindParam(this, "deactivate", m_deactivate);

	bindParam(this, "indexes", m_string);

	bindParam(this, "mode", m_mode);

	bindParam(this, "keep", m_keep);

	bindParam(this, "value", m_value);

	addInputPort("source", m_input);

	addInputPort("Texture", m_texture);

	m_value->setValueRange(0, 100);

	m_keep->addItem(1, "Keep");

	m_mode->addItem(PATTERNTYPE, "Pattern");

	m_mode->addItem(ADD, "Add");

	m_mode->addItem(SUBTRACT, "Subtract");

	m_mode->addItem(MULTIPLY, "Multiply");

	m_mode->addItem(LIGHTEN, "Lighten");

	m_mode->addItem(DARKEN, "Darken");

	m_p00_a->getX()->setValueRange(-1000, 1000);

	m_p00_b->getX()->setValueRange(-1000, 1000);

	m_p00_a->getY()->setValueRange(-1000, 1000);

	m_p00_b->getY()->setValueRange(-1000, 1000);

	m_p01_a->getX()->setValueRange(-1000, 1000);

	m_p01_b->getX()->setValueRange(-1000, 1000);

	m_p01_a->getY()->setValueRange(-1000, 1000);

	m_p01_b->getY()->setValueRange(-1000, 1000);

	m_p11_a->getX()->setValueRange(-1000, 1000);

	m_p11_b->getX()->setValueRange(-1000, 1000);

	m_p11_a->getY()->setValueRange(-1000, 1000);

	m_p11_b->getY()->setValueRange(-1000, 1000);

	m_p10_a->getX()->setValueRange(-1000, 1000);

	m_p10_b->getX()->setValueRange(-1000, 1000);

	m_p10_a->getY()->setValueRange(-1000, 1000);

	m_p10_b->getY()->setValueRange(-1000, 1000);

	m_distortType->addItem(BILINEAR, "Bilinear");

}

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

CornerPinFx::~CornerPinFx()

{

}

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

bool CornerPinFx::doGetBBox(double frame, TRectD &bBox, const TRenderSettings &info)

{

	if (m_input.isConnected()) {

		bool ret = m_input->doGetBBox(frame, bBox, info);

		return ret;

	} else {

		bBox = TRectD();

		return false;

	}

}

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

TAffine CornerPinFx::getPort1Affine(double frame) const

{

	//Explanation: Fxs tree decomposition on n-ary fxs (n>1) works the following way.

	//Fxs on port 0 are considered 'column representants' - so affines found on them

	//must be passed throughout the tree hierarchy. Therefore, their inverses are multiplied

	//just below the other input ports in order to push the former affine above.

	//In other words:

	//  port  0:  A -|                  ---|

	//               +--   =>              + A --

	//  port >0:  B -|         B - (Ainv) -|

	//Retrieve the affine that lies just below texture's port.

	TGeometryFx *AinvFx = dynamic_cast<tgeometryfx *="">(m_texture.getFx());</tgeometryfx>

	if (!AinvFx)

		return TAffine();

	TGeometryFx *BFx = dynamic_cast<tgeometryfx *="">(AinvFx->getInputPort(0)->getFx());</tgeometryfx>

	if (!BFx)

		return AinvFx->getPlacement(frame);

	return AinvFx->getPlacement(frame) * BFx->getPlacement(frame);

}

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

void CornerPinFx::transform(

	double frame,

	int port,

	const TRectD &rectOnOutput,

	const TRenderSettings &infoOnOutput,

	TRectD &rectOnInput,

	TRenderSettings &infoOnInput)

{

	//Build the input affine

	infoOnInput = infoOnOutput;

	TPointD p00_b = m_p00_b->getValue(frame);

	TPointD p10_b = m_p10_b->getValue(frame);

	TPointD p01_b = m_p01_b->getValue(frame);

	TPointD p11_b = m_p11_b->getValue(frame);

	TPointD p00_a = m_p00_a->getValue(frame);

	TPointD p10_a = m_p10_a->getValue(frame);

	TPointD p01_a = m_p01_a->getValue(frame);

	TPointD p11_a = m_p11_a->getValue(frame);

	//NOTE 1: An appropriate scale factor is sent below in the schematic, depending

	//on the image distortion. For example, if the distortion brings a 2 scale factor,

	//we want the same factor applied on image levels, so that their detail is appropriate

	//(especially for vector images).

	double scale = 0;

	scale = tmax(scale, norm(p10_a - p00_a) / norm(p10_b - p00_b));

	scale = tmax(scale, norm(p01_a - p00_a) / norm(p01_b - p00_b));

	scale = tmax(scale, norm(p11_a - p10_a) / norm(p11_b - p10_b));

	scale = tmax(scale, norm(p11_a - p01_a) / norm(p11_b - p01_b));

	TAffine A_1B(getPort1Affine(frame));

	TAffine B(infoOnOutput.m_affine * A_1B);

	scale *= sqrt(fabs(B.det()));

	if (infoOnOutput.m_isSwatch) {

		//Swatch viewers work out a lite version of the distort: only contractions

		//are passed below in the schematic - so that input memory load is always at minimum.

		//This is allowed in order to make fx adjusts the less frustrating as possible.

		if (scale > 1)

			scale = 1;

	}

	//NOTE 2: We further include A_1B.inv() to be applied on the level. This is done to

	//counter the presence of A_1B just below this node - since it is preferable to place A_1B

	//directly in the distort.

	infoOnInput.m_affine = TScale(scale) * A_1B.inv();

	//rectOnInput = (TScale(scale) * B.inv()) * rectOnOutput;

	//NOTE 3: The original distortion points are intended on the source port *before* applying A.

	//But we want to have them on texture port *before* applying B; so, the following ref change arises:

	//  p_b = (TScale(scale) * A_1B.inv()) * p_b == infoOnInput.m_aff * p_b;

	//  p_a = (B * A_1B.inv()) * p_a == infoOnOutput.m_aff * p_a;

	//Observe that scale and B are here due to NOTES 1 and 2.

	//Build rectOnInput

	p00_a = infoOnOutput.m_affine * p00_a;

	p10_a = infoOnOutput.m_affine * p10_a;

	p01_a = infoOnOutput.m_affine * p01_a;

	p11_a = infoOnOutput.m_affine * p11_a;

	p00_b = infoOnInput.m_affine * p00_b;

	p10_b = infoOnInput.m_affine * p10_b;

	p01_b = infoOnInput.m_affine * p01_b;

	p11_b = infoOnInput.m_affine * p11_b;

	if (m_distortType->getValue() == PERSPECTIVE) {

		PerspectiveDistorter pd(

			p00_b, p10_b, p01_b, p11_b,

			p00_a, p10_a, p01_a, p11_a);

		rectOnInput = ((TQuadDistorter *)&pd)->invMap(rectOnOutput);

	} else {

		BilinearDistorter bd(

			p00_b, p10_b, p01_b, p11_b,

			p00_a, p10_a, p01_a, p11_a);

		rectOnInput = ((TQuadDistorter *)&bd)->invMap(rectOnOutput);

	}

	if (rectOnInput.x0 != TConsts::infiniteRectD.x0)

		rectOnInput.x0 = tfloor(rectOnInput.x0);

	if (rectOnInput.y0 != TConsts::infiniteRectD.y0)

		rectOnInput.y0 = tfloor(rectOnInput.y0);

	if (rectOnInput.x1 != TConsts::infiniteRectD.x1)

		rectOnInput.x1 = tceil(rectOnInput.x1);

	if (rectOnInput.y1 != TConsts::infiniteRectD.y1)

		rectOnInput.y1 = tceil(rectOnInput.y1);

}

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

void CornerPinFx::safeTransform(

	double frame,

	int port,

	const TRectD &rectOnOutput,

	const TRenderSettings &infoOnOutput,

	TRectD &rectOnInput,

	TRenderSettings &infoOnInput,

	TRectD &inBBox)

{

	assert(port == 1 && m_texture.isConnected());

	if (m_deactivate->getValue()) {

		infoOnInput = infoOnOutput;

		rectOnInput = rectOnOutput;

		m_texture->getBBox(frame, inBBox, infoOnInput);

		return;

	}

	//Avoid the singular matrix cases

	if (fabs(infoOnOutput.m_affine.det()) < 1.e-3) {

		infoOnInput = infoOnOutput;

		rectOnInput.empty();

		m_texture->getBBox(frame, inBBox, infoOnInput);

		return;

	}

	transform(frame, port, rectOnOutput, infoOnOutput, rectOnInput, infoOnInput);

	m_texture->getBBox(frame, inBBox, infoOnInput);

	//In case inBBox is infinite, such as with gradients, also intersect with the input quadrilateral's bbox

	if (inBBox == TConsts::infiniteRectD) {

		TPointD affP00_b(infoOnInput.m_affine * m_p00_b->getValue(frame));

		TPointD affP10_b(infoOnInput.m_affine * m_p10_b->getValue(frame));

		TPointD affP01_b(infoOnInput.m_affine * m_p01_b->getValue(frame));

		TPointD affP11_b(infoOnInput.m_affine * m_p11_b->getValue(frame));

		TRectD source;

		source.x0 = tmin(affP00_b.x, affP10_b.x, affP01_b.x, affP11_b.x);

		source.y0 = tmin(affP00_b.y, affP10_b.y, affP01_b.y, affP11_b.y);

		source.x1 = tmax(affP00_b.x, affP10_b.x, affP01_b.x, affP11_b.x);

		source.y1 = tmax(affP00_b.y, affP10_b.y, affP01_b.y, affP11_b.y);

		rectOnInput *= source;

	}

}

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

void CornerPinFx::doDryCompute(TRectD &rect, double frame, const TRenderSettings &ri)

{

	if (!m_input.isConnected())

		return;

	vector<string> items;</string>

	string indexes = toString(m_string->getValue());

	parseIndexes(indexes, items);

	TRenderSettings ri2(ri);

	PaletteFilterFxRenderData *PaletteFilterData = new PaletteFilterFxRenderData;

	TRasterFxRenderDataP smartP(PaletteFilterData);

	insertIndexes(items, PaletteFilterData);

	PaletteFilterData->m_keep = (m_keep->getValue() == 1);

	ri2.m_data.push_back(PaletteFilterData);

	ri2.m_userCachable = false;

	//First child compute: part of output that IS NOT texturized

	m_input->dryCompute(rect, frame, ri2);

	if (!m_texture.isConnected())

		return;

	bool isSwatch = ri2.m_isSwatch;

	if (isSwatch)

		ri2.m_isSwatch = false;

	PaletteFilterData->m_keep = !(m_keep->getValue() == 1);

	//Second child compute: part of output that IS to be texturized

	m_input->dryCompute(rect, frame, ri2);

	//Deal with the texture

	if (m_deactivate->getValue())

		m_texture->dryCompute(rect, frame, ri);

	else {

		TRectD inRect;

		TRenderSettings riNew;

		TRectD inBBox;

		safeTransform(frame, 1, rect, ri, inRect, riNew, inBBox);

		inRect *= inBBox;

		if (myIsEmpty(inRect))

			return;

		m_texture->dryCompute(inRect, frame, riNew);

	}

}

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

void CornerPinFx::doCompute(TTile &tile, double frame, const TRenderSettings &ri)

{

	if (!m_input.isConnected()) {

		tile.getRaster()->clear();

		return;

	}

	TTile invertMaskTile;

	//carico il vettore items con gli indici dei colori

	vector<string> items;</string>

	string indexes = toString(m_string->getValue());

	parseIndexes(indexes, items);

	//genero il tile il cui raster contiene l'immagine in input a cui sono stati tolti i pixel

	//colorati con gli indici contenuti nel vettore items

	TRenderSettings ri2(ri);

	PaletteFilterFxRenderData *PaletteFilterData = new PaletteFilterFxRenderData;

	TRasterFxRenderDataP smartP(PaletteFilterData);

	insertIndexes(items, PaletteFilterData);

	PaletteFilterData->m_keep = (m_keep->getValue() == 1);

	ri2.m_data.push_back(PaletteFilterData);

	ri2.m_userCachable = false;

	m_input->allocateAndCompute(invertMaskTile, tile.m_pos, tile.getRaster()->getSize(), tile.getRaster(), frame, ri2);

	if (!m_texture.isConnected()) {

		tile.getRaster()->copy(invertMaskTile.getRaster());

		return;

	}

	//genero il tile il cui raster contiene l'immagine in input a cui sono stati tolti i pixel

	//colorati con indici diversi da quelli contenuti nel vettore items

	bool isSwatch = ri2.m_isSwatch;

	if (isSwatch)

		ri2.m_isSwatch = false;

	PaletteFilterData->m_keep = !(m_keep->getValue() == 1);

	m_input->compute(tile, frame, ri2);

	if (isSwatch)

		ri2.m_isSwatch = true;

	//controllo se ho ottenuto quaclosa su cui si possa lavorare.

	TRect saveBox;

	TRop::computeBBox(tile.getRaster(), saveBox);

	if (saveBox.isEmpty()) {

		//I guess that this case should be wiped out...

		m_input->compute(tile, frame, ri); //Could the invertMask be copied??

		return;

	}

	//Then, generate the texture tile and make its distortion

	TTile textureTile;

	if (m_deactivate->getValue()) {

		TDimension size = tile.getRaster()->getSize();

		TPointD pos = tile.m_pos;

		m_texture->allocateAndCompute(textureTile, pos, size, tile.getRaster(), frame, ri);

	} else {

		//Build the interesting texture region

		TRasterP tileRas(tile.getRaster());

		TRectD tileRect(convert(tileRas->getBounds()) + tile.m_pos);

		TRectD inRect;

		TRenderSettings riNew;

		TRectD inBBox;

		safeTransform(frame, 1, tileRect, ri, inRect, riNew, inBBox);

		inRect *= inBBox;

		if (myIsEmpty(inRect))

			return;

		TDimension inRectSize(tceil(inRect.getLx()), tceil(inRect.getLy()));

		TTile inTile;

		m_texture->allocateAndCompute(inTile, inRect.getP00(), inRectSize, tileRas, frame, riNew);

		//Get the source quad

		TPointD p00_b = m_p00_b->getValue(frame);

		TPointD p10_b = m_p10_b->getValue(frame);

		TPointD p01_b = m_p01_b->getValue(frame);

		TPointD p11_b = m_p11_b->getValue(frame);

		//Get destination quad

		TPointD p00_a = m_p00_a->getValue(frame);

		TPointD p10_a = m_p10_a->getValue(frame);

		TPointD p01_a = m_p01_a->getValue(frame);

		TPointD p11_a = m_p11_a->getValue(frame);

		double scale = 0;

		scale = tmax(scale, norm(p10_a - p00_a) / norm(p10_b - p00_b));

		scale = tmax(scale, norm(p01_a - p00_a) / norm(p01_b - p00_b));

		scale = tmax(scale, norm(p11_a - p10_a) / norm(p11_b - p10_b));

		scale = tmax(scale, norm(p11_a - p01_a) / norm(p11_b - p01_b));

		TAffine A_1B(getPort1Affine(frame));

		TAffine B(ri.m_affine * A_1B);

		scale *= sqrt(fabs(B.det()));

		if (ri.m_isSwatch)

			if (scale > 1)

				scale = 1;

		p00_b = riNew.m_affine * p00_b;

		p10_b = riNew.m_affine * p10_b;

		p01_b = riNew.m_affine * p01_b;

		p11_b = riNew.m_affine * p11_b;

		p00_a = ri.m_affine * p00_a;

		p10_a = ri.m_affine * p10_a;

		p01_a = ri.m_affine * p01_a;

		p11_a = ri.m_affine * p11_a;

		PerspectiveDistorter perpDistorter(

			p00_b - inTile.m_pos, p10_b - inTile.m_pos, p01_b - inTile.m_pos, p11_b - inTile.m_pos,

			p00_a, p10_a, p01_a, p11_a);

		BilinearDistorter bilDistorter(

			p00_b - inTile.m_pos, p10_b - inTile.m_pos, p01_b - inTile.m_pos, p11_b - inTile.m_pos,

			p00_a, p10_a, p01_a, p11_a);

		TDistorter *distorter;

		if (m_distortType->getValue() == PERSPECTIVE)

			distorter = &perpDistorter;

		else if (m_distortType->getValue() == BILINEAR)

			distorter = &bilDistorter;

		else

			assert(0);

		TRasterP textureRas(tileRas->create(tileRas->getLx(), tileRas->getLy()));

		distort(textureRas, inTile.getRaster(), *distorter, convert(tile.m_pos), TRop::Bilinear);

		textureTile.m_pos = tile.m_pos;

		textureTile.setRaster(textureRas);

	}

	//Then, apply the texture

	double v = m_value->getValue(frame);

	if (ri.m_bpp == 32) {

		TRaster32P witheCard;

		myOver32(tile.getRaster(), invertMaskTile.getRaster(), &makeOpaque<tpixel32>, v);</tpixel32>

		switch (m_mode->getValue()) {

		case SUBSTITUTE:

			myOver32(tile.getRaster(), textureTile.getRaster(), &substitute<tpixel32>, v);</tpixel32>

			CASE PATTERNTYPE : witheCard = TRaster32P(textureTile.getRaster()->getSize());

			witheCard->fill(TPixel32::White);

			TRop::over(textureTile.getRaster(), witheCard, textureTile.getRaster());

			myOver32(tile.getRaster(), textureTile.getRaster(), &pattern32, v);

			CASE ADD : myOver32(tile.getRaster(), textureTile.getRaster(), &textureAdd<tpixel32>, v / 100.0);</tpixel32>

			CASE SUBTRACT : myOver32(tile.getRaster(), textureTile.getRaster(), &textureSub<tpixel32>, v / 100.0);</tpixel32>

			CASE MULTIPLY : myOver32(tile.getRaster(), textureTile.getRaster(), &textureMult<tpixel32>, v);</tpixel32>

			CASE DARKEN : myOver32(tile.getRaster(), textureTile.getRaster(), &textureDarken<tpixel32>, v);</tpixel32>

			CASE LIGHTEN : myOver32(tile.getRaster(), textureTile.getRaster(), &textureLighten<tpixel32>, v);</tpixel32>

		DEFAULT:

			assert(0);

		}

	} else {

		TRaster64P witheCard;

		myOver64(tile.getRaster(), invertMaskTile.getRaster(), &makeOpaque<tpixel64>, v);</tpixel64>

		switch (m_mode->getValue()) {

		case SUBSTITUTE:

			myOver64(tile.getRaster(), textureTile.getRaster(), &substitute<tpixel64>, v);</tpixel64>

			CASE PATTERNTYPE : witheCard = TRaster64P(textureTile.getRaster()->getSize());

			witheCard->fill(TPixel64::White);

			TRop::over(textureTile.getRaster(), witheCard, textureTile.getRaster());

			myOver64(tile.getRaster(), textureTile.getRaster(), &pattern64, v);

			CASE ADD : myOver64(tile.getRaster(), textureTile.getRaster(), &textureAdd<tpixel64>, v / 100.0);</tpixel64>

			CASE SUBTRACT : myOver64(tile.getRaster(), textureTile.getRaster(), &textureSub<tpixel64>, v / 100.0);</tpixel64>

			CASE MULTIPLY : myOver64(tile.getRaster(), textureTile.getRaster(), &textureMult<tpixel64>, v);</tpixel64>

			CASE DARKEN : myOver64(tile.getRaster(), textureTile.getRaster(), &textureDarken<tpixel64>, v);</tpixel64>

			CASE LIGHTEN : myOver64(tile.getRaster(), textureTile.getRaster(), &textureLighten<tpixel64>, v);</tpixel64>

		DEFAULT:

			assert(0);

		}

	}

	TRop::over(tile.getRaster(), invertMaskTile.getRaster());

}

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

int CornerPinFx::getMemoryRequirement(const TRectD &rect, double frame, const TRenderSettings &info)

{

	if (!m_texture.isConnected())

		return TRasterFx::memorySize(rect, info.m_bpp);

	TRectD inRect;

	TRenderSettings riNew;

	TRectD inBBox;

	safeTransform(frame, 1, rect, info, inRect, riNew, inBBox);

	inRect *= inBBox;

	return tmax(TRasterFx::memorySize(rect, info.m_bpp), TRasterFx::memorySize(inRect, riNew.m_bpp));

}

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

/*

TRectD CornerPinFx::getContainingBox(const FourPoints &points)

{

	if(points.m_p00==points.m_p01 && points.m_p01==points.m_p10 && points.m_p10==points.m_p11)

		return TRectD(points.m_p00,points.m_p00);

	double xMax=tmax(points.m_p00.x,points.m_p01.x,points.m_p10.x,points.m_p11.x);

	double yMax=tmax(points.m_p00.y,points.m_p01.y,points.m_p10.y,points.m_p11.y);

	double xMin=tmin(points.m_p00.x,points.m_p01.x,points.m_p10.x,points.m_p11.x);

	double yMin=tmin(points.m_p00.y,points.m_p01.y,points.m_p10.y,points.m_p11.y);

	return TRectD(xMin,yMin,xMax, yMax);

}

*/

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

FX_PLUGIN_IDENTIFIER(CornerPinFx, "cornerPinFx");