#if _MSC_VER >= 1400

#define _CRT_SECURE_NO_DEPRECATE 1

#endif

// STColSelPic.h: interface for the CSTColSelPic class.

//

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

#if !defined(AFX_STCOLSELPIC_H__80D708B0_FCA2_11D5_B949_0040F674BE6A__INCLUDED_)

#define AFX_STCOLSELPIC_H__80D708B0_FCA2_11D5_B949_0040F674BE6A__INCLUDED_

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

#ifdef _WIN32

#pragma warning(disable : 4996)

#endif

#include <streambuf></streambuf>

#include <vector></vector>

#include <memory></memory>

#include <math.h></math.h>

#include <memory.h></memory.h>

#include "YOMBInputParam.h"

#include "STPic.h"

#include "SDef.h"

#include "CIL.h"

#include "SError.h"

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

class CSTColSelPic : public CSTPic

{

public:

	std::shared_ptr<uchar> m_sel;</uchar>

	CSTColSelPic() : CSTPic
() {}

	virtual ~CSTColSelPic()

	{

	};

	void nullSel()

	{

		m_sel.reset();

	}

	void initSel() //throw(SMemAllocError)

	{

		nullSel();

		if (CSTPic
::m_lX > 0 && CSTPic
::m_lY > 0) {

			m_sel.reset(new UCHAR[CSTPic
::m_lX * CSTPic
::m_lY], std::default_delete<uchar[]>());</uchar[]>

			if (!m_sel)

				throw SMemAllocError(" in initColorSelection");

		} else {

			char s[200];

			sprintf(s, " in initColorSelection lXY=(%d,%d)\n", CSTPic
::m_lX, CSTPic
::m_lY);

			throw SMemAllocError(s);

		}

	}

	void copySel(const UCHAR *sel)

	{

		memcpy(m_sel.get(), sel, CSTPic
::m_lX * CSTPic
::m_lY * sizeof(UCHAR));

	}

	void copySel(const UCHAR sel)

	{

		memset(m_sel.get(), sel, CSTPic
::m_lX * CSTPic
::m_lY * sizeof(UCHAR));

	}

	CSTColSelPic(const CSTColSelPic &csp) /*throw(SMemAllocError) */

		: CSTPic
(csp)

	{

	}

	const CSTColSelPic
 &operator=(const CSTColSelPic
 &sp) // throw(SMemAllocError)

	{

		const CSTPic
 *spp;

		CSTPic
 *dpp;

		try {

			CSTPic
::null();

			spp = static_cast<const cstpic<p=""> *>(&sp);</const>

			dpp = static_cast<cstpic<p> *>(this);</cstpic<p>

			*dpp = *spp;

			if (sp.m_sel && CSTPic
::m_lX > 0 && CSTPic
::m_lY > 0) {

				initSel();

				copySel(sp.m_sel.get());

			}

		} catch (SMemAllocError) {

			throw;

		}

		return (*this);

	}

	int isInCIL(USHORT c, const COLOR_INDEX_LIST &cil)

	{

		for (int i = 0; i < cil.nb; i++)

			if (cil.ci[i] == c)

				return i;

		return -1;

	}

	int makeSelectionCMAP32(const COLOR_INDEX_LIST &ink,

							const COLOR_INDEX_LIST &paint)

	{

		UCHAR *pSel = m_sel.get();

		P *pic = CSTPic
::m_pic;

		int xy = 0, nbSel = 0;

		for (int y = 0; y < CSTPic
::m_lY; y++)

			for (int x = 0; x < CSTPic
::m_lX; x++, xy++, pSel++, pic++) {

				int xyRas = y * CSTPic
::m_ras->wrap + x;

				UD44_CMAPINDEX32 ci32 = *((UD44_CMAPINDEX32 *)(CSTPic
::m_ras->buffer) + xyRas);

				if ((ci32 & 0x000000ff) == 0xff) {

					// Paint color

					int p = isInCIL((int)((ci32 >> 8) & 0x00000fff), paint);

					if (p >= 0) {

						*pSel = 255 - p;

						nbSel++;

					}

				} else if ((ci32 & 0x000000ff) == 0x0) {

					// Ink color

					int p = isInCIL((int)((ci32 >> 20) & 0x00000fff), ink);

					if (p >= 0) {

						//*pSel=paint.nb

						*pSel = 255 - p;

						nbSel++;

					}

				} else {

					// Tone color

					int p = isInCIL((int)((ci32 >> 8) & 0x00000fff), paint);

					if (p >= 0)

						if (isInCIL((int)((ci32 >> 20) & 0x00000fff), ink) >= 0) {

							*pSel = 255 - p;

							nbSel++;

						}

				}

			}

		return nbSel;

	}

	int makeSelectionCMAP(const COLOR_INDEX_LIST &ink,

						  const COLOR_INDEX_LIST &paint)

	{

		copySel((UCHAR)0);

		if (CSTPic
::m_lX > 0 && CSTPic
::m_lY > 0 && m_sel && CSTPic
::m_pic && CSTPic
::m_ras) {

			if (CSTPic
::m_ras->type == RAS_CM32)

				return makeSelectionCMAP32(ink, paint);

		}

		return 0;

	}

	int makeSelectionCMAP(const CCIL &ink,

						  const CCIL &paint)

	{

		copySel((UCHAR)0);

		COLOR_INDEX_LIST hink, hpaint;

		hink.nb = ink.m_nb;

		int i;

		for (i = 0; i < ink.m_nb; i++)

			hink.ci[i] = (USHORT)ink.m_ci[i];

		hpaint.nb = paint.m_nb;

		for (i = 0; i < paint.m_nb; i++)

			hpaint.ci[i] = (USHORT)paint.m_ci[i];

		if (CSTPic
::m_lX > 0 && CSTPic
::m_lY > 0 && m_sel && CSTPic
::m_pic && CSTPic
::m_ras) {

			if (CSTPic
::m_ras->type == RAS_CM32)

				return makeSelectionCMAP32(hink, hpaint);

		}

		return 0;

	}

	int makeSelectionRGB(const std::vector<i_pixel> &col,</i_pixel>

						 const double dA, const double dAB)

	{

		int nbCol;

		copySel((UCHAR)0);

		nbCol = col.size();

		if (CSTPic
::m_lX > 0 && CSTPic
::m_lY > 0 && m_sel && CSTPic
::m_pic) {

			switch (nbCol) {

			case 1:

				return makeSelectionRGB1(col, dA);

				break;

			case 2:

				return makeSelectionRGB2(col, dA, dAB);

				break;

			case 3:

				return makeSelectionRGB3(col, dA, dAB);

				break;

			default:

				return makeSelectionRGBMore(col, dA, dAB);

				break;

			}

		}

		return 0;

	}

	double distRGB2(const I_PIXEL &c1, const I_PIXEL &c2) const

	{

		double q = (double)(c1.r - c2.r) * (double)(c1.r - c2.r);

		q += (double)(c1.g - c2.g) * (double)(c1.g - c2.g);

		q += (double)(c1.b - c2.b) * (double)(c1.b - c2.b);

		return q;

	}

	double distRGBM2(const I_PIXEL &c1, const I_PIXEL &c2) const

	{

		double q = (double)(c1.r - c2.r) * (double)(c1.r - c2.r);

		q += (double)(c1.g - c2.g) * (double)(c1.g - c2.g);

		q += (double)(c1.b - c2.b) * (double)(c1.b - c2.b);

		q += (double)(c1.m - c2.m) * (double)(c1.m - c2.m);

		return q;

	}

	double distRGB(const I_PIXEL &c1, const I_PIXEL &c2) const

	{

		int qd = (c1.r - c2.r) * (c1.r - c2.r) + (c1.g - c2.g) * (c1.g - c2.g) + (c1.b - c2.b) * (c1.b - c2.b);

		return sqrt((double)qd);

	}

	double distRGBM(const I_PIXEL &c1, const I_PIXEL &c2) const

	{

		int qd = (c1.r - c2.r) * (c1.r - c2.r) + (c1.g - c2.g) * (c1.g - c2.g) +

				 (c1.b - c2.b) * (c1.b - c2.b) * (c1.m - c2.m) * (c1.m - c2.m);

		return sqrt((double)qd);

	}

	inline bool isSameColor(const I_PIXEL &c1, const I_PIXEL &c2) const

	{

		return (c1.r == c2.r && c1.g == c2.g && c1.b == c2.b);

	}

	inline void setIntPixel(I_PIXEL &dp, const P &sp) const

	{

		dp.r = (int)sp.r;

		dp.g = (int)sp.g;

		dp.b = (int)sp.b;

		dp.m = (int)sp.m;

	}

	inline void setIntPixel(I_PIXEL &dp, const P *sp) const

	{

		dp.r = (int)sp->r;

		dp.g = (int)sp->g;

		dp.b = (int)sp->b;

		dp.m = (int)sp->m;

	}

	int makeSelectionRGB1(const std::vector<i_pixel> &col, const double dA)</i_pixel>

	{

		P *pPic = CSTPic
::m_pic;

		UCHAR *pSel = m_sel;

		I_PIXEL ip;

		int xy, lxy = CSTPic
::m_lX * CSTPic
::m_lY;

		int nbPixel = 0;

		double dA2 = dA * dA;

		for (xy = 0; xy < lxy; xy++, pPic++, pSel++) {

			//		if ( pPic->m>0 ) {

			setIntPixel(ip, pPic);

			if (ip.m == col[0].m && distRGB2(ip, col[0]) <= dA2) {

				*pSel = 255;

				nbPixel++;

			}

			//		}

		}

		return nbPixel;

	}

	bool isBetween(const I_PIXEL &a, const I_PIXEL &b, const I_PIXEL &c) const

	{

		if (c.r < std::min(a.r, b.r))

			return false;

		if (c.r > std::max(a.r, b.r))

			return false;

		if (c.g < std::min(a.g, b.g))

			return false;

		if (c.g > std::max(a.g, b.g))

			return false;

		if (c.b < std::min(a.b, b.b))

			return false;

		if (c.b > std::max(a.b, b.b))

			return false;

		if (c.m < std::min(a.m, b.m))

			return false;

		if (c.m > std::max(a.m, b.m))

			return false;

		/*

//if ( c.m!=0 )

//	tmsg_info("A=(%d,%d,%d,%d) B=(%d,%d,%d,%d) C=(%d,%d,%d,%d)\n",a.r,a.g,a.b,a.m,b.r,b.g,b.b,b.m,c.r,c.g,c.b,c.m);

	if ( c.r

		return false;

	if ( c.r>a.r && c.r>b.r )

		return false;

	if ( c.g

		return false;

	if ( c.g>a.g && c.g>b.g )

		return false;

	if ( c.b

		return false;

	if ( c.b>a.b && c.b>b.b )

		return false;

	if ( c.m

		return false;

	if ( c.m>a.m && c.m>b.m )

		return false;

//if ( c.m!=0 )

//tmsg_info("IS_BETWEEN");

*/

		return true;

	}

	bool isLinComb(const I_PIXEL &a, const I_PIXEL &b, const I_PIXEL &c,

				   const double dAB)

	{

		//	if ( isSameColor(a,b) && isSameColor(a,c) )

		//		return true;

		if (!isBetween(a, b, c))

			return false;

		return true;

		/*	double dab=distRGBM(a,b);

	double dac=distRGBM(a,c);

	double dbc=distRGBM(b,c);

	double d= dab-(dac+dbc);

	d= d<0.0 ? -d : d;

	if ( d<=dAB )

		return true;

	return false;

*/

	}

	int makeSelectionRGB2(const std::vector<i_pixel> &col,</i_pixel>

						  const double dA, const double dAB)

	{

		P *pPic;

		UCHAR *pSel;

		I_PIXEL ip;

		int xy, lxy, nbPixel;

		double dA2 = dA * dA;

		nbPixel = 0;

		pPic = CSTPic
::m_pic;

		pSel = m_sel;

		lxy = CSTPic
::m_lX * CSTPic
::m_lY;

		for (xy = 0; xy < lxy; xy++, pPic++, pSel++) {

			//		if ( pPic->m>0 ) {

			setIntPixel(ip, pPic);

			if (ip.m == col[0].m && distRGB2(ip, col[0]) <= dA2) {

				*pSel = 255;

				nbPixel++;

			} else if (ip.m == col[1].m && distRGB2(ip, col[1]) <= dA2) {

				*pSel = (UCHAR)(255 - 1);

				nbPixel++;

			} else if (isLinComb(col[0], col[1], ip, dAB)) {

				//				*pSel=(UCHAR)253;

				*pSel = distRGBM2(col[0], ip) < distRGBM2(col[1], ip) ? 255 : (UCHAR)(255 - 1);

				nbPixel++;

			}

			//		}

		}

		return nbPixel;

	}

	int makeSelectionRGB3(const std::vector<i_pixel> &col,</i_pixel>

						  const double dA, const double dAB)

	{

		P *pPic = CSTPic
::m_pic;

		UCHAR *pSel = m_sel;

		I_PIXEL ip;

		int xy, nbPixel = 0;

		int lxy = CSTPic
::m_lX * CSTPic
::m_lY;

		double dA2 = dA * dA;

		for (xy = 0; xy < lxy; xy++, pPic++, pSel++) {

			//		if ( pPic->m>0 ) {

			setIntPixel(ip, pPic);

			if (ip.m == col[0].m && distRGB2(ip, col[0]) <= dA2) {

				*pSel = 255;

				nbPixel++;

			} else if (ip.m == col[1].m && distRGB2(ip, col[1]) <= dA2) {

				*pSel = (UCHAR)(255 - 1);

				nbPixel++;

			} else if (ip.m == col[2].m && distRGB2(ip, col[2]) <= dA2) {

				*pSel = (UCHAR)(255 - 2);

				nbPixel++;

			} else if (isLinComb(col[0], col[1], ip, dAB)) {

				*pSel = distRGBM2(col[0], ip) < distRGBM2(col[1], ip) ? 255 : 255 - 1;

				nbPixel++;

			} else if (isLinComb(col[0], col[2], ip, dAB)) {

				*pSel = distRGBM2(col[0], ip) < distRGBM2(col[2], ip) ? 255 : 255 - 2;

				nbPixel++;

			} else if (isLinComb(col[1], col[2], ip, dAB)) {

				*pSel = distRGBM2(col[1], ip) < distRGBM2(col[2], ip) ? 255 - 1 : 255 - 2;

				nbPixel++;

			}

			//		}

		}

		return nbPixel;

	}

	int makeSelectionRGBMore(const std::vector<i_pixel> &col,</i_pixel>

							 const double dA, const double dAB)

	{

		int nbPixel = 0, i, j, k;

		int nbCol = col.size();

		for (i = 1, k = 0; i < nbCol; i++)

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

				nbPixel += makeSelectionRGBMore(col, dA, dAB, i, j, k);

				k++;

			}

		return nbPixel;

	}

	int makeSelectionRGBMore(const std::vector<i_pixel> &col,</i_pixel>

							 const double dA, const double dAB,

							 const int i, const int j, const int k)

	{

		P *pPic = CSTPic
::m_pic;

		UCHAR *pSel = m_sel;

		I_PIXEL ip;

		int nbPixel = 0;

		double dA2 = dA * dA;

		int nbCol = col.size();

		for (int y = 0; y < CSTPic
::m_lY; y++)

			for (int x = 0; x < CSTPic
::m_lX; x++, pPic++, pSel++) {

				//			if ( pPic->m>0 ) {

				setIntPixel(ip, pPic);

				if (ip.m == col[i].m && distRGB2(ip, col[i]) <= dA2) {

					*pSel = (UCHAR)(255 - i);

					nbPixel++;

				} else if (ip.m == col[j].m && distRGB2(ip, col[j]) <= dA2) {

					*pSel = (UCHAR)(255 - j);

					nbPixel++;

				} else if (isLinComb(col[i], col[j], ip, dAB)) {

					*pSel = distRGBM2(col[i], ip) < distRGBM2(col[j], ip) ? 255 - i : 255 - j;

					nbPixel++;

				}

				//			}

			}

		return nbPixel;

	}

	void setSel01()

	{

		int xy = CSTPic
::m_lX * CSTPic
::m_lY;

		UCHAR *p = m_sel;

		for (int i = 0; i < xy; i++, p++)

			*p = *p > (UCHAR)0 ? (UCHAR)1 : (UCHAR)0;

	}

	void showSelection()

	{

		P *pPic;

		UCHAR *pSel;

		int lxy, xy;

		int fcolor;

		lxy = CSTPic
::m_lX * CSTPic
::m_lY;

		pSel = m_sel;

		pPic = CSTPic
::m_pic;

		bool isRGBMType = CSTPic
::getType() == ST_RGBM;

		fcolor = isRGBMType ? 255 : 65535;

		for (xy = 0; xy < lxy; xy++, pPic++, pSel++) {

			/*		if (*pSel==(UCHAR)0) {

			pPic->r=fcolor/2;

			pPic->g=0;

			pPic->b=0;

			pPic->m=fcolor;

		}

*/

			if (*pSel > (UCHAR)0) {

				pPic->r = 255;

				pPic->g = 0;

				pPic->b = 0;

				pPic->m = fcolor;

			}

			/*		if (*pSel==(UCHAR)2) {

			pPic->r=0;

			pPic->g=0;

			pPic->b=fcolor;

			pPic->m=fcolor;

		} 

		if (*pSel==(UCHAR)3) {

			pPic->r=fcolor;

			pPic->g=0;

			pPic->b=0;

			pPic->m=fcolor;

		} 

*/

			/*		if (*pSel==(UCHAR)255) {

			pPic->r=0;

			pPic->g=0;

			pPic->b=fcolor;

			pPic->m=fcolor;

		}

		if (*pSel==(UCHAR)254) {

			pPic->r=fcolor;

			pPic->g=fcolor;

			pPic->b=0;

			pPic->m=fcolor;

		}

		if (*pSel==(UCHAR)253) {

			pPic->r=fcolor;

			pPic->g=0;

			pPic->b=0;

			pPic->m=fcolor;

		}

		if (*pSel==(UCHAR)251) {

			pPic->r=fcolor;

			pPic->g=0;

			pPic->b=fcolor;

			pPic->m=fcolor;

		}

		if (*pSel==(UCHAR)250) {

			pPic->r=0;

			pPic->g=fcolor;

			pPic->b=fcolor;

			pPic->m=fcolor;

		}

*/

		}

	}

	void selBox(SRECT &box)

	{

		box.x0 = CSTPic
::m_lX;

		box.x1 = -1;

		box.y0 = CSTPic
::m_lY;

		box.y1 = -1;

		UCHAR *pSel = m_sel;

		for (int y = 0; y < CSTPic
::m_lY; y++)

			for (int x = 0; x < CSTPic
::m_lX; x++, pSel++)

				if (*pSel > (UCHAR)0) {

					box.x0 = std::min(box.x0, x);

					box.x1 = std::max(box.x1, x);

					box.y0 = std::min(box.y0, y);

					box.y1 = std::max(box.y1, y);

				}

	}

	void selRunLengthH(const SRECT &box, const int step, int &rl, int &nbRl)

	{

		for (int y = box.y0; y <= (box.y1); y += step) {

			int l = 0;

			bool isIn = false;

			UCHAR *pSel = m_sel + y * CSTPic
::m_lX + box.x0;

			for (int x = box.x0; x <= box.x1; x++, pSel++) {

				if (isIn && *pSel == (UCHAR)0) {

					rl += l;

					nbRl++;

					l = 0;

					isIn = false;

				} else if (isIn && *pSel > (UCHAR)0) {

					l++;

				} else if (!isIn && *pSel > (UCHAR)0) {

					l = 1;

					isIn = true;

				}

			}

			if (isIn) {

				rl += l;

				nbRl++;

			}

		}

	}

	void selRunLengthV(const SRECT &box, const int step, int &rl, int &nbRl)

	{

		for (int x = box.x0; x <= (box.x1); x += step) {

			int l = 0;

			bool isIn = false;

			for (int y = box.y0; y <= box.y1; y++) {

				UCHAR *pSel = m_sel + y * CSTPic
::m_lX + x;

				if (isIn && *pSel == (UCHAR)0) {

					rl += l;

					nbRl++;

					l = 0;

					isIn = false;

				} else if (isIn && *pSel > (UCHAR)0) {

					l++;

				} else if (!isIn && *pSel > (UCHAR)0) {

					l = 1;

					isIn = true;

				}

			}

			if (isIn) {

				rl += l;

				nbRl++;

			}

		}

	}

	int selRunLength(const int step)

	{

		int s = step < 1 ? 1 : step;

		SRECT box;

		selBox(box);

		int rl = 0;

		int nbRl = 0;

		selRunLengthH(box, s, rl, nbRl);

		selRunLengthV(box, s, rl, nbRl);

		if (nbRl > 0) {

			double d = (double)rl / (double)nbRl;

			return I_ROUNDP(d);

		}

		return 0;

	}

	void hlsNoise(const double d)

	{

		int xy = CSTPic
::m_lX * CSTPic
::m_lY;

		P *p = CSTPic
::m_pic;

		UCHAR *pSel = m_sel;

		for (int i = 0; i < xy; i++, p++, pSel++)

			if (p->m > 0 && (*pSel) > (UCHAR)0) {

				double h, l, s, q;

				rgb2hls(p->r, p->g, p->b, &h, &l, &s);

				q = 1.0 - d * (double)((rand() % 201) - 100) / 100.0;

				l *= q;

				hls2rgb(h, l, s, &(p->r), &(p->g), &(p->b));

			}

	}

	/*

void expand(const int border) throw(SMemAllocError)

{	try {

		int olX=m_lX;

		int olY=m_lY;

		CSTPic
::expand(border);

		UCHAR* nSel=new UCHAR[m_lX*m_lY];

		if ( !nSel ) 

			throw SMemAllocError("in expand");

		UCHAR* pNSel=nSel;

		for( int y=0; y

			for( int x=0; x

				int ox=x-border;

				int oy=y-border;

				if ( ox>=0 && ox<olx &&="" oy="">=0 && oy</olx>

					*pNSel=*(m_sel+oy*olX+ox);

				} else 

					*pNSel=(UCHAR)0;

			}

		delete [] m_sel;

		m_sel=nSel;

	}

	catch (SMemAllocError) {

		throw;

	}

}

*/

};

#endif // !defined(AFX_STCOLSELPIC_H__80D708B0_FCA2_11D5_B949_0040F674BE6A__INCLUDED_)