#include "trandom.h"

#include "tfxparam.h"

#include "stdfx.h"

class NoiseFx : public TStandardRasterFx

{

	FX_PLUGIN_DECLARATION(NoiseFx)

	TRasterFxPort m_input;

	TDoubleParamP m_value;

	TBoolParamP m_Red;

	TBoolParamP m_Green;

	TBoolParamP m_Blue;

	TBoolParamP m_BW;

	TBoolParamP m_Animate;

public:

	NoiseFx()

		: m_value(100.0), m_Red(1.0), m_Green(1.0), m_Blue(1.0), m_BW(0.0), m_Animate(0.0)

	{

		bindParam(this, "Intensity", m_value);

		bindParam(this, "Red", m_Red);

		bindParam(this, "Green", m_Green);

		bindParam(this, "Blue", m_Blue);

		bindParam(this, "Black_White", m_BW);

		bindParam(this, "Animate", m_Animate);

		addInputPort("Source", m_input);

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

	}

	~NoiseFx(){};

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

	{

		if (m_input.isConnected())

			return m_input->doGetBBox(frame, bBox, info);

		else {

			bBox = TRectD();

			return false;

		}

	}

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

	std::string getAlias(double frame, const TRenderSettings &info) const;

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

};

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

namespace

{

template <class pixel=""></class>

class RayleighNoise

{

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

public:

	RayleighNoise(double sigma, int seed = 0)

	{

		noise_buf.resize(PIXEL::maxChannelValue + 1);

		TRandom random(seed);

		sigma = log(sigma * 0.07 + 1);

		if (PIXEL::maxChannelValue == 255)

			sigma = 2.0 * sigma * sigma * sigma * sigma;

		else

			sigma = 257.0 * 2.0 * sigma * sigma * sigma * sigma;

		for (int i = 0; i < PIXEL::maxChannelValue + 1; i++) {

			noise_buf[i] = sigma * sqrt(-log(1.0 - random.getFloat())) *

						   cos(TConsts::pi * (2.0 * random.getFloat() - 1.0));

		}

	}

	double get_value(int index)

	{

		tcrop(index, 0, PIXEL::maxChannelValue);

		return noise_buf[index];

	}

};

}

template <typename channel_type="" pixel,="" pixelgray,="" typename=""></typename>

void doNoise(TRasterPT<pixel> &ras, double sigma, bool bw, bool red, bool green, bool blue,</pixel>

			 bool animate, double frame)

{

	RayleighNoise<pixel> noise(sigma);</pixel>

	TRandom random;

	if (animate)

		random.setSeed(frame);

	int j;

	ras->lock();

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

		PIXEL *pix = ras->pixels(j);

		PIXEL *endPix = pix + ras->getLx();

		while (pix < endPix) {

			if (bw) {

				double index;

				double value;

				index = random.getFloat() * pix->m; //PIXEL::maxChannelValue;

				value = noise.get_value(tfloor(index));

				//value = (value<pix->m)?((value>0)?(int)value:0):PIXEL::maxChannelValue;</pix->

				//if(value)

				//{

				int reference;

				reference = PIXELGRAY::from(*pix).value;

				pix->r = tcrop<int>(value + reference, 0, pix->m);</int>

				pix->g = tcrop<int>(value + reference, 0, pix->m);</int>

				pix->b = tcrop<int>(value + reference, 0, pix->m);</int>

				//}

			} else {

				double r, g, b, index;

				if (red) {

					index = random.getFloat() * pix->m; //PIXEL::maxChannelValue;

					r = noise.get_value(tfloor(index)) + pix->r;

					pix->r = tcrop<int>(r, 0, pix->m);</int>

				}

				if (green) {

					index = random.getFloat() * pix->m; //PIXEL::maxChannelValue;

					g = noise.get_value(tfloor(index)) + pix->g;

					pix->g = tcrop<int>(g, 0, pix->m);</int>

				}

				if (blue) {

					index = random.getFloat() * pix->m; //PIXEL::maxChannelValue;

					b = noise.get_value(tfloor(index)) + pix->b;

					pix->b = tcrop<int>(b, 0, pix->m);</int>

				}

			}

			*pix++;

		}

	}

	ras->unlock();

}

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

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

{

	if (!m_input.isConnected())

		return;

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

	double sigma = m_value->getValue(frame);

	bool bw = m_BW->getValue();

	bool red = m_Red->getValue();

	bool green = m_Green->getValue();

	bool blue = m_Blue->getValue();

	bool animate = m_Animate->getValue();

	if (sigma == 0.0)

		return;

	TRaster32P raster32 = tile.getRaster();

	if (raster32)

		doNoise<tpixel32, tpixelgr8,="" uchar="">(raster32, sigma, bw, red, green, blue, animate, frame);</tpixel32,>

	else {

		TRaster64P raster64 = tile.getRaster();

		if (raster64)

			doNoise<tpixel64, tpixelgr16,="" ushort="">(raster64, sigma, bw, red, green, blue, animate, frame);</tpixel64,>

		else

			throw TException("Brightness&Contrast: unsupported Pixel Type");

	}

}

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

std::string NoiseFx::getAlias(double frame, const TRenderSettings &info) const

{

	std::string alias = getFxType();

	alias += "[";

	// alias degli effetti connessi alle porte di input separati da virgole

	// una porta non connessa da luogo a un alias vuoto (stringa vuota)

	int i = 0;

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

		TFxPort *port = getInputPort(i);

		if (port->isConnected()) {

			TRasterFxP ifx = port->getFx();

			assert(ifx);

			alias += ifx->getAlias(frame, info);

		}

		alias += ",";

	}

	bool addframe = 0;

	std::string paramalias("");

	for (i = 0; i < getParams()->getParamCount(); i++) {

		TParam *param = getParams()->getParam(i);

		paramalias += param->getName() + "=" + param->getValueAlias(frame, 3);

		if (param->getName() == "Animate" && param->getValueAlias(frame, 0) == "1")

			addframe = true;

	}

	if (addframe)

		alias += toString(frame) + ",";

	alias += paramalias + "]";

	return alias;

}

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

FX_PLUGIN_IDENTIFIER(NoiseFx, "noiseFx")