#include "texception.h"

#include "tfxparam.h"

#include "trop.h"

#include "stdfx.h"

#include "trasterfx.h"

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

class BlurFx : public TStandardRasterFx

{

	FX_PLUGIN_DECLARATION(BlurFx)

	TRasterFxPort m_input;

	TDoubleParamP m_value;

	TBoolParamP m_useSSE;

public:

	BlurFx() : m_value(20), m_useSSE(true)

	{

		m_value->setMeasureName("fxLength");

		bindParam(this, "value", m_value);

		bindParam(this, "useSSE", m_useSSE, true);

		addInputPort("Source", m_input);

		m_value->setValueRange(0, std::numeric_limits<double>::max());

	}

	~BlurFx(){};

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

	{

		if (m_input.isConnected()) {

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

			double blur = fabs(m_value->getValue(frame));

			int brad = tceil(blur);

			bBox = bBox.enlarge(brad);

			return ret;

		} else {

			bBox = TRectD();

			return false;

		}

	}

	void enlarge(const TRectD &bbox, TRectD &requestedRect, int blur);

	void transform(

		double frame,

		int port,

		const TRectD &rectOnOutput,

		const TRenderSettings &infoOnOutput,

		TRectD &rectOnInput,

		TRenderSettings &infoOnInput);

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

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

	bool canHandle(const TRenderSettings &info, double frame)

	{

		if (m_value->getValue(frame) == 0)

			return true;

		return (isAlmostIsotropic(info.m_affine));

	}

};

FX_PLUGIN_IDENTIFIER(BlurFx, "blurFx")

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

//!Calculates the geometry we need for this node computation, given

//!the known input data (bbox), the requested output (requestedRect) and the blur factor.

void BlurFx::enlarge(const TRectD &bbox, TRectD &requestedRect, int blur)

{

	if (bbox.isEmpty() || requestedRect.isEmpty()) {

		requestedRect.empty();

		return;

	}

	//We are to find out the geometry that is useful for the fx computation.

	//There are some rules to follow:

	//  a) First, the interesting output we can generate is bounded by both

	//     the requestedRect and the blurred bbox (i.e. enlarged by the blur radius).

	//  b) Pixels contributing to any output are necessarily part of bbox - and only

	//     those which are blurrable into the requestedRect are useful to us

	//     (i.e. pixels contained in its enlargement by the blur radius).

	TRectD enlargedBBox(bbox.enlarge(blur));

	TRectD enlargedOut(requestedRect.enlarge(blur));

	TPointD originalP00(requestedRect.getP00());

	requestedRect = (enlargedOut * bbox) + (enlargedBBox * requestedRect);

	//Finally, make sure that the result is coherent with the original P00

	requestedRect -= originalP00;

	requestedRect.x0 = tfloor(requestedRect.x0);

	requestedRect.y0 = tfloor(requestedRect.y0);

	requestedRect.x1 = tceil(requestedRect.x1);

	requestedRect.y1 = tceil(requestedRect.y1);

	requestedRect += originalP00;

}

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

void BlurFx::transform(

	double frame,

	int port,

	const TRectD &rectOnOutput,

	const TRenderSettings &infoOnOutput,

	TRectD &rectOnInput,

	TRenderSettings &infoOnInput)

{

	infoOnInput = infoOnOutput;

	rectOnInput = rectOnOutput;

	double blur = fabs(m_value->getValue(frame) * sqrt(fabs(infoOnOutput.m_affine.det())));

	if (blur == 0) {

		rectOnInput = rectOnOutput;

		return;

	}

	int brad = tceil(blur);

	TRectD bbox;

	m_input->getBBox(frame, bbox, infoOnInput);

	enlarge(bbox, rectOnInput, brad);

}

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

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

{

	double blurValue = fabs(m_value->getValue(frame) * sqrt(fabs(info.m_affine.det())));

	if (blurValue == 0.0)

		return 0;

	int brad = tceil(blurValue);

	//Trop::blur is quite inefficient at the moment - it has to allocate a whole

	//raster of the same size of the input/output made of FLOAT QUADRUPLES...!

	return TRasterFx::memorySize(rect.enlarge(brad), sizeof(float) << 5);

}

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

void BlurFx::doCompute(

	TTile &tile,

	double frame,

	const TRenderSettings &renderSettings)

{

	if (!m_input.isConnected())

		return;

	double shrink = 0.5 * (renderSettings.m_shrinkX + renderSettings.m_shrinkY);

	// Note: shrink is obsolete. It should be always = 1

	double blurValue = fabs(m_value->getValue(frame) * sqrt(fabs(renderSettings.m_affine.det())) / shrink);

	if (blurValue == 0) {

		//No blur will be done. The underlying fx may pass by.

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

		return;

	}

	int brad = tceil(blurValue);

	//Get the requested tile's geometry

	TRectD rectIn, rectOut;

	rectOut = TRectD(

		tile.m_pos, TDimensionD(tile.getRaster()->getLx(), tile.getRaster()->getLy()));

	//Retrieve the input interesting geometry - and ensure that something actually has

	//to be computed

	if (!m_input->getBBox(frame, rectIn, renderSettings) || rectOut.isEmpty())

		return;

	enlarge(rectIn, rectOut, brad);

	if (rectOut.isEmpty())

		return;

	//Finally, allocate and compute the blur argument

	TTile tileIn;

	m_input->allocateAndCompute(

		tileIn, rectOut.getP00(), TDimension(rectOut.getLx(), rectOut.getLy()),

		tile.getRaster(), frame, renderSettings);

	TPointD displacement(rectOut.getP00() - tile.m_pos);

	TRop::blur(tile.getRaster(), tileIn.getRaster(), blurValue, displacement.x, displacement.y, false);

}