#pragma once

// 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_

#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</blursection>

  // pBS,

  //						 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(); p != pBS->end();</sxyd>

         ++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_)