// YOMBParam.h: interface for the CYOMBParam class.

//

//////////////////////////////////////////////////////////////////////

#if !defined(AFX_YOMBPARAM_H__41D42152_F2EE_11D5_B92D_0040F674BE6A__INCLUDED_)

#define AFX_YOMBPARAM_H__41D42152_F2EE_11D5_B92D_0040F674BE6A__INCLUDED_

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

#include <vector></vector>

#include "STColSelPic.h"

#include "SDef.h"

#include "InputParam.h"

#include "YOMBInputParam.h"

#include "BlurMatrix.h"

//#pragma warning(disable: 4786)

//#include "tmsg.h"

#define P(d) tmsg_info(" - %d -\n", d)

class CYOMBParam

{

public:

	bool m_isRandomSampling;

	bool m_isShowSelection;

	bool m_isStopAtContour;

	bool m_isBlurOnPair;

	double m_dSample;

	int m_nbSample;

	double m_dA, m_dAB;

	std::string m_name;

	bool m_isCM;

	// for RGBM color groups

	std::vector<i_pixel> m_color;</i_pixel>

	// for CMAP color indides

	COLOR_INDEX_LIST m_ink, m_paint;

	CYOMBParam() : m_isRandomSampling(false), m_isShowSelection(false),

				   m_isStopAtContour(false), m_isBlurOnPair(false),

				   m_dSample(0.0), m_nbSample(0),

				   m_dA(0.0), m_dAB(0.0), m_name(""),

				   m_isCM(false),

				   m_color(0)

	{

		m_ink.nb = m_paint.nb = 0;

	};

	CYOMBParam(const CYOMBParam &bp) : m_color(bp.m_color),

									   m_isRandomSampling(bp.m_isRandomSampling),

									   m_isShowSelection(bp.m_isShowSelection),

									   m_isStopAtContour(bp.m_isStopAtContour),

									   m_isBlurOnPair(bp.m_isBlurOnPair),

									   m_dSample(bp.m_dSample),

									   m_nbSample(bp.m_nbSample),

									   m_dA(bp.m_dA),

									   m_dAB(bp.m_dAB),

									   m_name(bp.m_name),

									   m_isCM(bp.m_isCM)

	{

		if (m_isCM) {

			m_ink.nb = bp.m_ink.nb;

			int i = 0;

			for (i = 0; i < m_ink.nb; i++)

				m_ink.ci[i] = bp.m_ink.ci[i];

			m_paint.nb = bp.m_paint.nb;

			for (i = 0; i < m_paint.nb; i++)

				m_paint.ci[i] = bp.m_paint.ci[i];

		}

	};

	virtual ~CYOMBParam(){};

	void print();

	void null();

	void read(const CInputParam &ip);

#ifdef _WIN32

	bool read(std::basic_ifstream<char> &in);</char>

#endif

	void makeColorsUS();

	void makeItUS();

	static void adjustToMatte(I_PIXEL &p);

	//	void blurPixel(CSTColSelPic<uc_pixel>& pic, const int xx, const int yy,</uc_pixel>

	//				   const CBlurMatrix& bm, UC_PIXEL& col,const UCHAR osel);

	//	bool isContourOnPath(const int xx, const int yy,

	//						 std::vector<blursection>::const_iterator pBS,</blursection>

	//						 CSTColSelPic<uc_pixel>& pic);</uc_pixel>

	//	void addPixel(I_PIXEL& p, const UC_PIXEL* pic);

	//	void addPixel(I_PIXEL& p, const CSTColSelPic<uc_pixel>& pic,</uc_pixel>

	//                 const int xxyy, const int xy );

	void addPixel(I_PIXEL &p, const I_PIXEL &pp);

	int getColorIndex(const UCHAR c);

	void scale(const double d);

	template <class p=""></class>

	void addPixel(I_PIXEL &p, const P *pic)

	{

		p.r += ((int)pic->r);

		p.g += ((int)pic->g);

		p.b += ((int)pic->b);

		p.m += ((int)pic->m);

	}

	// Checks the path from blurred pixel to the sample pixel.

	template <class p=""></class>

	bool isContourOnPath(const int xx, const int yy,

						 std::vector<blursection>::const_iterator pBS,</blursection>

						 CSTColSelPic
 &pic)

	{

		for (std::vector<sxyd>::const_iterator p = pBS->begin();</sxyd>

			 p != pBS->end();

			 ++p) {

			int x = xx + p->x;

			int y = yy + p->y;

			int xy = y * pic.m_lX + x;

			if (x >= 0 && y >= 0 && x < pic.m_lX && y < pic.m_lY)

				if (*(pic.m_sel + xy) == (UCHAR)0)

					return true;

		}

		return false;

	}

	template <class p=""></class>

	void addPixel(I_PIXEL &ip, const CSTColSelPic
 &pic,

				  const int xxyy, const int xy)

	{

		if (!m_isBlurOnPair) {

			addPixel(ip, pic.m_pic + xy);

		} else {

			int i = getColorIndex(*(pic.m_sel + xy));

			int ii = getColorIndex(*(pic.m_sel + xxyy));

			int l = m_color.size() / 2;

			if (i == ii || abs(ii - i) == l) {

				addPixel(ip, pic.m_pic + xy);

			} else {

				if (ii < l) {

					if (i < l) {

						addPixel(ip, m_color[ii]);

					} else

						addPixel(ip, m_color[ii + l]);

				} else {

					if (i < l) {

						addPixel(ip, m_color[ii - l]);

					} else

						addPixel(ip, m_color[ii]);

				}

			}

		}

	}

	template <class p=""></class>

	void blurPixel(CSTColSelPic
 &pic, const int xx, const int yy,

				   const CBlurMatrix &bm, I_PIXEL &col, const int iBm)

	{

		I_PIXEL p = {0, 0, 0, 0};

		int nb = 0;

		int xxyy = yy * pic.m_lX + xx;

		for (std::vector<blursection>::const_iterator pBS = bm.m_m[iBm].begin();</blursection>

			 pBS != bm.m_m[iBm].end();

			 ++pBS) {

			//		const SXYD* xyd=pBS->begin();

			BLURSECTION::const_iterator xyd = pBS->begin();

			int x = xx + xyd->x;

			int y = yy + xyd->y;

			if (x >= 0 && y >= 0 && x < pic.m_lX && y < pic.m_lY) {

				int xy = y * pic.m_lX + x;

				if (*(pic.m_sel + xy) > (UCHAR)0)

					if (bm.m_isSAC) {

						if (!isContourOnPath(xx, yy, pBS, pic)) {

							addPixel(p, pic, xxyy, xy);

							nb++;

						}

					} else {

						addPixel(p, pic, xxyy, xy);

						nb++;

					}

			}

		}

		if (nb > 0) {

			double r = (double)p.r / (double)nb;

			double g = (double)p.g / (double)nb;

			double b = (double)p.b / (double)nb;

			double m = (double)p.m / (double)nb;

			col.r = I_ROUND(r);

			col.g = I_ROUND(g);

			col.b = I_ROUND(b);

			col.m = I_ROUND(m);

		} else {

			P *pPic = pic.m_pic + yy * pic.m_lX + xx;

			col.r = (int)(pPic->r);

			col.g = (int)(pPic->g);

			col.b = (int)(pPic->b);

			col.m = (int)(pPic->m);

		}

	}

	template <class p=""></class>

	bool isRealMixture(CSTColSelPic
 &pic, const int xx, const int yy,

					   const CBlurMatrix &bm, const int iBm, const UCHAR osel) const

	{

		for (std::vector<blursection>::const_iterator pBS = bm.m_m[iBm].begin();</blursection>

			 pBS != bm.m_m[iBm].end();

			 ++pBS) {

			//		const SXYD* xyd= pBS->begin();

			BLURSECTION::const_iterator xyd = pBS->begin();

			int x = xx + xyd->x;

			int y = yy + xyd->y;

			if (x >= 0 && x < pic.m_lX && y >= 0 && y < pic.m_lY) {

				int xy = y * pic.m_lX + x;

				UCHAR *pSel = pic.m_sel + xy;

				if (*pSel > (UCHAR)0 && *pSel != osel)

					return true;

			}

		}

		return false;

	}

	template <class p=""></class>

	void doIt(CSTColSelPic
 &ipic, CSTColSelPic
 &opic)

	{

		CBlurMatrix bm(m_dSample, m_nbSample, m_isStopAtContour, m_isRandomSampling);

		UCHAR *pSel = ipic.m_sel;

		for (int y = 0; y < ipic.m_lY; y++)

			for (int x = 0; x < ipic.m_lX; x++, pSel++)

				if (*pSel > (UCHAR)0) {

					I_PIXEL col;

					int iBm = bm.m_isRS ? rand() % NBRS : 0;

					if (isRealMixture(ipic, x, y, bm, iBm, *pSel))

						blurPixel(ipic, x, y, bm, col, iBm);

					else

						ipic.getPixel(x, y, col);

					opic.setRGBM(x, y, col);

				}

	}

};

#endif // !defined(AFX_YOMBPARAM_H__41D42152_F2EE_11D5_B92D_0040F674BE6A__INCLUDED_)