#include "stdfx.h"
#include "tfxparam.h"

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

template <class T>
void ropSharpen(const TRasterPT<T> &rin, TRasterPT<T> &rout, int sharpen_max_corr)
{
	T *bufin, *east, *northeast, *southeast;
	T *bufout, *pixout;
	int lx, ly, wrapin, wrapout, x, y, count;
	int cntr_r, east_r, col_west_r, col_cntr_r, col_east_r;
	int cntr_g, east_g, col_west_g, col_cntr_g, col_east_g;
	int cntr_b, east_b, col_west_b, col_cntr_b, col_east_b;
	int cntr_m, east_m, col_west_m, col_cntr_m, col_east_m;

	int lapl, out;

#define SET_PIXOUT(X)                                                                     \
	{                                                                                     \
		lapl = (cntr_##X << 3) + cntr_##X - (col_west_##X + col_cntr_##X + col_east_##X); \
		if (lapl < 0) {                                                                   \
			out = cntr_##X - ((256 * 4 - lapl * sharpen_max_corr) >> (8 + 3));            \
			pixout->X = (out <= 0) ? 0 : out;                                             \
		} else {                                                                          \
			out = cntr_##X + ((256 * 4 + lapl * sharpen_max_corr) >> (8 + 3));            \
			pixout->X = (out >= maxChanVal) ? maxChanVal : out;                           \
		}                                                                                 \
	}
	rin->lock();
	rout->lock();
	bufin = (T *)rin->getRawData();
	bufout = (T *)rout->getRawData();
	lx = std::min(rin->getLx(), rout->getLx());
	ly = std::min(rin->getLy(), rout->getLy());
	wrapin = rin->getWrap();
	wrapout = rout->getWrap();
	int maxChanVal = T::maxChannelValue;

	if (lx <= 1 || ly <= 1) {
		for (y = 0; y < ly; y++)
			for (x = 0; x < lx; x++)
				bufout[x + y * wrapout] = bufin[x + y * wrapin];
		return;
	}
	east = bufin;
	northeast = east + wrapin;
	east_r = east->r;
	east_g = east->g;
	east_b = east->b;
	east_m = east->m;
	col_east_r = 2 * east_r + northeast->r;
	col_east_g = 2 * east_g + northeast->g;
	col_east_b = 2 * east_b + northeast->b;
	col_east_m = 2 * east_m + northeast->m;
	col_cntr_r = col_east_r;
	col_cntr_g = col_east_g;
	col_cntr_b = col_east_b;
	col_cntr_m = col_east_m;
	east++;
	northeast++;
	pixout = bufout;
	for (count = lx - 1;
		 count > 0;
		 count--, east++, northeast++, pixout++) {
		cntr_r = east_r;
		east_r = east->r;
		col_west_r = col_cntr_r;
		col_cntr_r = col_east_r;
		col_east_r = 2 * east_r + northeast->r;
		SET_PIXOUT(r)
		cntr_g = east_g;
		east_g = east->g;
		col_west_g = col_cntr_g;
		col_cntr_g = col_east_g;
		col_east_g = 2 * east_g + northeast->g;
		SET_PIXOUT(g)
		cntr_b = east_b;
		east_b = east->b;
		col_west_b = col_cntr_b;
		col_cntr_b = col_east_b;
		col_east_b = 2 * east_b + northeast->b;
		SET_PIXOUT(b)
		cntr_m = east_m;
		east_m = east->m;
		col_west_m = col_cntr_m;
		col_cntr_m = col_east_m;
		col_east_m = 2 * east_m + northeast->m;
		SET_PIXOUT(m)
	}
	cntr_r = east_r;
	col_west_r = col_cntr_r;
	col_cntr_r = col_east_r;
	SET_PIXOUT(r)
	cntr_g = east_g;
	col_west_g = col_cntr_g;
	col_cntr_g = col_east_g;
	SET_PIXOUT(g)
	cntr_b = east_b;
	col_west_b = col_cntr_b;
	col_cntr_b = col_east_b;
	SET_PIXOUT(b)
	cntr_m = east_m;
	col_west_m = col_cntr_m;
	col_cntr_m = col_east_m;
	SET_PIXOUT(m)
	for (y = 1; y < ly - 1; y++) {
		east = bufin + y * wrapin;
		northeast = east + wrapin;
		southeast = east - wrapin;
		east_r = east->r;
		east_g = east->g;
		east_b = east->b;
		east_m = east->m;
		col_east_r = east_r + northeast->r + southeast->r;
		col_east_g = east_g + northeast->g + southeast->g;
		col_east_b = east_b + northeast->b + southeast->b;
		col_east_m = east_m + northeast->m + southeast->m;
		col_cntr_r = col_east_r;
		col_cntr_g = col_east_g;
		col_cntr_b = col_east_b;
		col_cntr_m = col_east_m;
		east++;
		northeast++;
		southeast++;
		pixout = bufout + y * wrapout;
		for (count = lx - 1;
			 count > 0;
			 count--, east++, northeast++, southeast++, pixout++) {
			cntr_r = east_r;
			east_r = east->r;
			col_west_r = col_cntr_r;
			col_cntr_r = col_east_r;
			col_east_r = east_r + northeast->r + southeast->r;
			SET_PIXOUT(r)
			cntr_g = east_g;
			east_g = east->g;
			col_west_g = col_cntr_g;
			col_cntr_g = col_east_g;
			col_east_g = east_g + northeast->g + southeast->g;
			SET_PIXOUT(g)
			cntr_b = east_b;
			east_b = east->b;
			col_west_b = col_cntr_b;
			col_cntr_b = col_east_b;
			col_east_b = east_b + northeast->b + southeast->b;
			SET_PIXOUT(b)
			cntr_m = east_m;
			east_m = east->m;
			col_west_m = col_cntr_m;
			col_cntr_m = col_east_m;
			col_east_m = east_m + northeast->m + southeast->m;
			SET_PIXOUT(m)
		}
		cntr_r = east_r;
		col_west_r = col_cntr_r;
		col_cntr_r = col_east_r;
		SET_PIXOUT(r)
		cntr_g = east_g;
		col_west_g = col_cntr_g;
		col_cntr_g = col_east_g;
		SET_PIXOUT(g)
		cntr_b = east_b;
		col_west_b = col_cntr_b;
		col_cntr_b = col_east_b;
		SET_PIXOUT(b)
		cntr_m = east_m;
		col_west_m = col_cntr_m;
		col_cntr_m = col_east_m;
		SET_PIXOUT(m)
	}
	east = bufin + y * wrapin;
	southeast = east - wrapin;
	east_r = east->r;
	east_g = east->g;
	east_b = east->b;
	east_m = east->m;
	col_east_r = 2 * east_r + southeast->r;
	col_east_g = 2 * east_g + southeast->g;
	col_east_b = 2 * east_b + southeast->b;
	col_east_m = 2 * east_m + southeast->m;
	col_cntr_r = col_east_r;
	col_cntr_g = col_east_g;
	col_cntr_b = col_east_b;
	col_cntr_m = col_east_m;
	east++;
	southeast++;
	pixout = bufout + y * wrapout;
	for (count = lx - 1;
		 count > 0;
		 count--, east++, southeast++, pixout++) {
		cntr_r = east_r;
		east_r = east->r;
		col_west_r = col_cntr_r;
		col_cntr_r = col_east_r;
		col_east_r = 2 * east_r + southeast->r;
		SET_PIXOUT(r)
		cntr_g = east_g;
		east_g = east->g;
		col_west_g = col_cntr_g;
		col_cntr_g = col_east_g;
		col_east_g = 2 * east_g + southeast->g;
		SET_PIXOUT(g)
		cntr_b = east_b;
		east_b = east->b;
		col_west_b = col_cntr_b;
		col_cntr_b = col_east_b;
		col_east_b = 2 * east_b + southeast->b;
		SET_PIXOUT(b)
		cntr_m = east_m;
		east_m = east->m;
		col_west_m = col_cntr_m;
		col_cntr_m = col_east_m;
		col_east_m = 2 * east_m + southeast->m;
		SET_PIXOUT(m)
	}
	cntr_r = east_r;
	col_west_r = col_cntr_r;
	col_cntr_r = col_east_r;
	SET_PIXOUT(r)
	cntr_g = east_g;
	col_west_g = col_cntr_g;
	col_cntr_g = col_east_g;
	SET_PIXOUT(g)
	cntr_b = east_b;
	col_west_b = col_cntr_b;
	col_cntr_b = col_east_b;
	SET_PIXOUT(b)
	cntr_m = east_m;
	col_west_m = col_cntr_m;
	col_cntr_m = col_east_m;
	SET_PIXOUT(m)

	rin->unlock();
	rout->unlock();
}

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

class SharpenFx : public TStandardRasterFx
{
	FX_PLUGIN_DECLARATION(SharpenFx)

	TRasterFxPort m_input;
	TDoubleParamP m_intensity;

public:
	SharpenFx()
		: m_intensity(50)

	{
		bindParam(this, "intensity", m_intensity);
		addInputPort("Source", m_input);
		m_intensity->setValueRange(0.0, 999999, 1);
	}

	~SharpenFx(){};

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

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

void SharpenFx::doCompute(TTile &tile, double frame, const TRenderSettings &ri)
{
	if (!m_input.isConnected())
		return;

	int intensity = troundp(m_intensity->getValue(frame));

	TRasterP srcRas = tile.getRaster()->create(tile.getRaster()->getLx(), tile.getRaster()->getLy());
	//TRaster32P srcRas(tile.getRaster()->getLx() + border*2, tile.getRaster()->getLy() + border*2);
	TTile srcTile(srcRas, tile.m_pos);

	m_input->compute(srcTile, frame, ri);
	TRaster32P raster32 = tile.getRaster();
	TRaster32P srcraster32 = srcTile.getRaster();

	if (raster32)
		ropSharpen<TPixel32>(srcraster32, raster32, intensity);
	//doEmboss<TPixel32, TPixelGR8, UCHAR>(raster32, srcraster32, azimuth, elevation, intensity, border);
	else {
		TRaster64P raster64 = tile.getRaster();
		TRaster64P srcraster64 = srcTile.getRaster();
		if (raster64)
			ropSharpen<TPixel64>(srcraster64, raster64, intensity);
		else
			throw TException("sharpen: unsupported Pixel Type");
	}
}

FX_PLUGIN_IDENTIFIER(SharpenFx, "sharpenFx");