#include "texception.h"

#include "tfxparam.h"

#include "stdfx.h"

namespace

{

template <typename pixel="" t,="" typename=""></typename>

void prepare_lut(double max, int edge, std::vector<t> &lut)</t>

{

	double aux = (double)PIXEL::maxChannelValue;

	int i = 0;

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

		lut[i] = (int)((max / edge) * i);

	}

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

		lut[i] = (int)((max / (edge - aux)) * (i - aux));

	}

}

}

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

class SolarizeFx : public TStandardRasterFx

{

	FX_PLUGIN_DECLARATION(SolarizeFx)

	TRasterFxPort m_input;

	TDoubleParamP m_maximum;

	TDoubleParamP m_edge;

public:

	SolarizeFx()

		: m_maximum(1.0), m_edge(128.0)

	{

		bindParam(this, "maximum", m_maximum);

		bindParam(this, "peak_edge", m_edge);

		addInputPort("Source", m_input);

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

		m_maximum->setValueRange(0.0, 10.0);

		m_edge->setValueRange(0.0, 255.0);

	}

	~SolarizeFx(){};

	bool 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;

		}

	}

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

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

};

namespace

{

template <typename t=""></typename>

void update_param(T ¶m, TRaster32P ras)

{

	return;

}

template <typename t=""></typename>

void update_param(T ¶m, TRaster64P ras)

{

	param = param * 257;

	return;

}

}

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

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

void doSolarize(TRasterPT<pixel> ras, double max, int edge)</pixel>

{

	std::vector<channel_type> solarize_lut(PIXEL::maxChannelValue + 1);</channel_type>

	update_param(max, ras);

	update_param(edge, ras);

	prepare_lut<channel_type, pixel="">(max, edge, solarize_lut);</channel_type,>

	int j;

	ras->lock();

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

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

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

		while (pix < endPix) {

			pix->r = (CHANNEL_TYPE)(solarize_lut[(int)(pix->r)]);

			pix->g = (CHANNEL_TYPE)(solarize_lut[(int)(pix->g)]);

			pix->b = (CHANNEL_TYPE)(solarize_lut[(int)(pix->b)]);

			*pix++;

		}

	}

	ras->unlock();

}

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

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

{

	if (!m_input.isConnected())

		return;

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

	double min, max, step;

	m_maximum->getValueRange(min, max, step);

	double maxValue = 128 * tcrop(m_maximum->getValue(frame), min, max);

	m_edge->getValueRange(min, max, step);

	int edge = (int)tcrop(m_edge->getValue(frame), min, max);

	TRaster32P raster32 = tile.getRaster();

	if (raster32)

		doSolarize<tpixel32, uchar="">(raster32, maxValue, edge);</tpixel32,>

	else {

		TRaster64P raster64 = tile.getRaster();

		if (raster64)

			doSolarize<tpixel64, ushort="">(raster64, maxValue, edge);</tpixel64,>

		else

			throw TException("SolarizeFx: unsupported Pixel Type");

	}

}

FX_PLUGIN_IDENTIFIER(SolarizeFx, "solarizeFx");