#include "rasterstyles.h"

#include "trop.h"

#include "tvectorimage.h"

#include "traster.h"

#include "trastercm.h"

#include "tlevel_io.h"

#include "tenv.h"

//#include "tpixelutils.h"

//*************************************************************************************

//    TAirbrushRasterStyle  implementation

//*************************************************************************************

void TAirbrushRasterStyle::loadData(TInputStreamInterface &is)

{

	is >> m_blur;

}

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

void TAirbrushRasterStyle::saveData(TOutputStreamInterface &os) const

{

	os << m_blur;

}

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

bool TAirbrushRasterStyle::compute(const Params ¶ms) const

{

	if (m_blur > 0.0)

		TRop::blur(params.m_r, params.m_r, m_blur, 0, 0, true);

	return true;

}

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

TColorStyle *TAirbrushRasterStyle::clone() const

{

	TColorStyle *cs = new TAirbrushRasterStyle(*this);

	cs->assignNames(this);

	return cs;

}

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

void TAirbrushRasterStyle::makeIcon(const TDimension &d)

{

	TFilePath dir = TEnv::getStuffDir() + "pixmaps";

	static TRasterP normalIc;

	if (normalIc == TRasterP())

		TImageReader::load(dir + "airbrush.bmp", normalIc);

	arrangeIcon(d, normalIc);

}

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

void TAirbrushRasterStyle::arrangeIcon(const TDimension &d,

									   const TRasterP &normalIc)

{

	if (normalIc == TRasterP()) {

		m_icon = TRaster32P(d);

		m_icon->fill(TPixel32::Red);

		return;

	}

	m_icon = TRasterP();

	if (d == TDimension(52, 52))

		m_icon = normalIc->clone();

	else {

		m_icon = TRaster32P(d);

		TRop::resample(m_icon, normalIc, TScale(d.lx / 52.0, d.ly / 52.0));

	}

	m_icon->lock();

	TPixel *buf = (TPixel *)m_icon->getRawData();

	TPixel color = getMainColor();

	double rd = (color.r - color.m) / 255.0;

	double gd = (color.g - color.m) / 255.0;

	double bd = (color.b - color.m) / 255.0;

	assert(m_icon->getWrap() == m_icon->getSize().lx);

	for (int i = 0; i < m_icon->getSize().lx * m_icon->getSize().ly; i++, buf++) {

		assert(buf->r == buf->g && buf->r == buf->b);

		if (buf->r < 255) {

			if (buf->r == 0)

				*buf = color;

			else {

				int val = 255 - buf->r;

				buf->r = (UCHAR)(val * rd + 255);

				buf->g = (UCHAR)(val * gd + 255);

				buf->b = (UCHAR)(val * bd + 255);

			}

		}

	}

	m_icon->unlock();

}

//*************************************************************************************

//    TBlendRasterStyle  implementation

//*************************************************************************************

TColorStyle *TBlendRasterStyle::clone() const

{

	return new TBlendRasterStyle(*this);

}

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

bool TBlendRasterStyle::compute(const Params ¶ms) const

{

	int i, j;

	TRasterGR8P r = (TRasterGR8P)params.m_r;

	assert(r);

	double factor = computeFactor(params);

	if (m_blur > 0.0)

		TRop::blur(params.m_r, params.m_r, m_blur, 0, 0, true);

	r->lock();

	for (i = 0; i < r->getLy(); i++) {

		TPixelGR8 *bufGr = r->pixels(i);

		for (j = 0; j < r->getLx(); j++, bufGr++)

			if (bufGr->value > 0) {

				double val = bufGr->value * factor + 0.5;

				bufGr->value = (UCHAR)((val > 255) ? 255 : val);

			}

	}

	r->unlock();

	return true;

}

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

namespace

{

bool inline doIsBorderPix(int index, TPixelCM32 *pix, TPixelGR8 *pixGr, int paint)

{

	return (pix->getPaint() != paint && (pix->isPurePaint() || pixGr->value != 0));

}

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

bool inline isBorderPix(int index, TPixelCM32 *pix, int wrap, TPixelGR8 *pixGr, int wrapGr, int color)

{

	return doIsBorderPix(index, pix + 1, pixGr + 1, color) ||

		   doIsBorderPix(index, pix - 1, pixGr - 1, color) ||

		   doIsBorderPix(index, pix + wrap, pixGr + wrapGr, color) ||

		   doIsBorderPix(index, pix - wrap, pixGr - wrapGr, color);

}

}

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

void TBlendRasterStyle::makeIcon(const TDimension &d)

{

	TFilePath dir = TEnv::getStuffDir() + "pixmaps";

	static TRasterP normalIc;

	if (normalIc == TRasterP())

		TImageReader::load(dir + "blend.bmp", normalIc);

	arrangeIcon(d, normalIc);

}

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

double TBlendRasterStyle::computeFactor(const Params ¶ms) const

{

	TRasterCM32P rCm = (TRasterCM32P)params.m_rOrig;

	TRasterGR8P rGr = (TRasterGR8P)params.m_r;

	TPixelGR8 *bufGr;

	TPixelCM32 *bufCmap;

	int i, j;

	int wr = params.m_rOrig->getWrap();

	int wrGr = params.m_r->getWrap();

	int num_lines = 0;

	double tot_sum = 0;

	//interactive!

	//if (Factor == 0)

	rGr->lock();

	rCm->lock();

	for (i = 1; i < params.m_r->getLy() - 1; i++) {

		int line_sum = 0, num_points = 0;

		bufGr = rGr->pixels(i) + 1;

		bufCmap = rCm->pixels(i) + 1;

		for (j = 1; j < rGr->getLx() - 1; j++, bufGr++, bufCmap++) {

			if (bufGr->value > 0) {

				int paint = bufCmap->getPaint();

				if ((bufCmap->isPurePaint() || bufGr->value != 0) &&

					isBorderPix(params.m_colorIndex, bufCmap, wr, bufGr, wrGr, paint)) {

					line_sum += troundp(bufGr->value);

					num_points++;

				}

			}

		}

		rGr->unlock();

		rCm->unlock();

		if (num_points != 0) {

			tot_sum += ((float)line_sum / ((float)num_points * 255));

			num_lines++;

		}

	}

	if (num_lines == 0)

		return 0;

	return num_lines / tot_sum;

}

//*************************************************************************************

//    TNoColorRasterStyle  implementation

//*************************************************************************************

void TNoColorRasterStyle::makeIcon(const TDimension &d)

{

	TFilePath dir = TEnv::getStuffDir() + "pixmaps";

	static TRasterP normalIc;

	if (normalIc == TRasterP())

		TImageReader::load(dir + "markup.bmp", normalIc);

	if (normalIc == TRasterP()) {

		m_icon = TRaster32P(d);

		m_icon->fill(TPixel32::Red);

		return;

	}

	m_icon = TRasterP();

	if (d == TDimension(52, 52) && normalIc != TRasterP())

		m_icon = normalIc->clone();

	else {

		m_icon = TRaster32P(d);

		TRop::resample(m_icon, normalIc, TScale(d.lx / 52.0, d.ly / 52.0));

	}

}