#include "tsystem.h"

#include <set></set>

#include "tropcm.h"

#include "tcolorstyles.h"

#include "tpixelutils.h"

#include "ttile.h"

#include "tpalette.h"

#include "timage_io.h"

#include "trasterimage.h"

#include "tsimplecolorstyles.h"

//#include "tlevel.h"

//#include "ttoonzimage.h"

//#include "tgeometry.h"

//#include "timage_io.h"

extern "C" {

#include "toonz4.6/raster.h"

}

#if defined(_WIN32) && defined(x64)

#define USE_SSE2

#endif

#ifdef USE_SSE2

#include <emmintrin.h></emmintrin.h>

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

namespace {

class alignas(16) TPixelFloat {

public:

  TPixelFloat() : b(0), g(0), r(0), m(0) {}

  TPixelFloat(float rr, float gg, float bb, float mm)

      : b(bb), g(gg), r(rr), m(mm) {}

  TPixelFloat(const TPixel32 &pix) : b(pix.b), g(pix.g), r(pix.r), m(pix.m) {}

  float b, g, r, m;

};

}  // anonymous namespace

#endif

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

bool renderRas32(const TTile &tileOut, const TTile &tileIn,

                 const TPaletteP palette);

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

const TPixel32 c_transparencyCheckPaint = TPixel32(80, 80, 80, 255);

const TPixel32 c_transparencyCheckInk   = TPixel32::Black;

void TRop::convert(const TRaster32P &rasOut, const TRasterCM32P &rasIn,

                   const TPaletteP palette, bool transparencyCheck) {

  int count = palette->getStyleCount();

  int count2 =

      std::max({count, TPixelCM32::getMaxInk(), TPixelCM32::getMaxPaint()});

  // per poter utilizzare lo switch (piu' efficiente) si utilizza 255

  // anziche' TPixelCM32::getMaxTone()

  assert(TPixelCM32::getMaxTone() == 255);

  int rasLx = rasOut->getLx();

  int rasLy = rasOut->getLy();

  rasOut->lock();

  rasIn->lock();

#ifdef USE_SSE2

  if (TSystem::getCPUExtensions() & TSystem::CpuSupportsSse2) {

    __m128i zeros = _mm_setzero_si128();

    TPixelFloat *paints =

        (TPixelFloat *)_aligned_malloc(count2 * sizeof(TPixelFloat), 16);

    TPixelFloat *inks =

        (TPixelFloat *)_aligned_malloc(count2 * sizeof(TPixelFloat), 16);

    std::vector<tpixel32> paints2(count2);</tpixel32>

    std::vector<tpixel32> inks2(count2);</tpixel32>

    if (transparencyCheck) {

      for (int i = 0; i < palette->getStyleCount(); i++) {

        paints2[i] = c_transparencyCheckPaint;

        inks2[i]   = c_transparencyCheckInk;

        paints[i]  = TPixelFloat(paints2[i]);

        inks[i]    = TPixelFloat(inks2[i]);

      }

      paints2[0] = TPixel32::Transparent;

      paints[0]  = TPixelFloat(TPixel32::Transparent);

    }

    /*

else if (true)

{

            for(int i=0;i<palette->getStyleCount();i++)</palette->

{

paints2[i] = c_transparencyCheckPaint;

                    inks2[i]   = c_transparencyCheckInk;

paints[i]  = TPixelFloat(paints2[i]);

                    inks[i]    = TPixelFloat(inks2[i]);

            paints2[i] = TPixel32::Transparent;

            paints[i] = TPixelFloat(TPixel32::Transparent);

}

            paints2[0] = TPixel32::Transparent;

            paints[0] = TPixelFloat(TPixel32::Transparent);

}

*/

    else

      for (int i = 0; i < palette->getStyleCount(); i++) {

        TPixel32 color = ::premultiply(palette->getStyle(i)->getAverageColor());

        paints[i] = inks[i] = TPixelFloat(color);

        paints2[i] = inks2[i] = color;

      }

    float maxTone     = (float)TPixelCM32::getMaxTone();

    __m128 den_packed = _mm_load1_ps(&maxTone);

    for (int y = 0; y < rasLy; ++y) {

      TPixel32 *pix32   = rasOut->pixels(y);

      TPixelCM32 *pixIn = rasIn->pixels(y);

      TPixelCM32 *endPixIn = pixIn + rasLx;

      while (pixIn < endPixIn) {

        int tt = pixIn->getTone();

        int p  = pixIn->getPaint();

        int i  = pixIn->getInk();

        switch (tt) {

        case 255:

          *pix32++ = paints2[p];

          break;

        case 0:

          *pix32++ = inks2[i];

          break;

        default: {

          float t         = (float)tt;

          __m128 a_packed = _mm_load_ps((float *)&(inks[i]));

          __m128 b_packed = _mm_load_ps((float *)&(paints[p]));

          __m128 num_packed  = _mm_load1_ps(&t);

          __m128 diff_packed = _mm_sub_ps(den_packed, num_packed);

          // calcola in modo vettoriale out = ((den-num)*a + num*b)/den

          __m128 outPix_packed = _mm_mul_ps(diff_packed, a_packed);

          __m128 tmpPix_packed = _mm_mul_ps(num_packed, b_packed);

          outPix_packed = _mm_add_ps(outPix_packed, tmpPix_packed);

          outPix_packed = _mm_div_ps(outPix_packed, den_packed);

          // converte i canali da float a char

          __m128i outPix_packed_i = _mm_cvtps_epi32(outPix_packed);

          outPix_packed_i         = _mm_packs_epi32(outPix_packed_i, zeros);

          outPix_packed_i         = _mm_packus_epi16(outPix_packed_i, zeros);

          *(DWORD *)(pix32) = _mm_cvtsi128_si32(outPix_packed_i);

          ++pix32;

        }

        }

        ++pixIn;

      }

    }

    _aligned_free(paints);

    _aligned_free(inks);

  } else  // SSE2 not supported

#endif    // _WIN32

  {

    std::vector<tpixel32> paints(count2, TPixel32(255, 0, 0));</tpixel32>

    std::vector<tpixel32> inks(count2, TPixel32(255, 0, 0));</tpixel32>

    if (transparencyCheck) {

      for (int i = 0; i < palette->getStyleCount(); i++) {

        paints[i] = c_transparencyCheckPaint;

        inks[i]   = c_transparencyCheckInk;

      }

      paints[0] = TPixel32::Transparent;

    } else

      for (int i  = 0; i < palette->getStyleCount(); i++)

        paints[i] = inks[i] =

            ::premultiply(palette->getStyle(i)->getAverageColor());

    for (int y = 0; y < rasLy; ++y) {

      TPixel32 *pix32      = rasOut->pixels(y);

      TPixelCM32 *pixIn    = rasIn->pixels(y);

      TPixelCM32 *endPixIn = pixIn + rasLx;

      while (pixIn < endPixIn) {

        int t = pixIn->getTone();

        int p = pixIn->getPaint();

        int i = pixIn->getInk();

        if (t == TPixelCM32::getMaxTone())

          *pix32++ = paints[p];

        else if (t == 0)

          *pix32++ = inks[i];

        else

          *pix32++ = blend(inks[i], paints[p], t, TPixelCM32::getMaxTone());

        ++pixIn;

      }

    }

  }

  rasOut->unlock();

  rasIn->unlock();

}

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

static void do_convert(const TTile &dst, const TTile &src,

                       const TPaletteP palette, bool transparencyCheck,

                       bool applyFx) {

  // assert(palette);

  // assert(_rasOut && _rasIn);

  // assert(rasOut->getSize() == rasIn->getSize());

  if (applyFx && renderRas32(dst, src, palette)) return;

  TRaster32P rasOut;

  TRasterCM32P rasIn;

  if (dst.getRaster()->getSize() != src.getRaster()->getSize()) {

    TRect rect = TRect(convert(dst.m_pos), dst.getRaster()->getSize()) *

                 TRect(convert(src.m_pos), src.getRaster()->getSize());

    TRect rectOut = rect - convert(dst.m_pos);

    rasOut        = dst.getRaster()->extract(rectOut);

    TRect rectIn  = rect - convert(src.m_pos);

    rasIn         = src.getRaster()->extract(rectIn);

  } else {

    rasOut = dst.getRaster();

    rasIn  = src.getRaster();

  }

  TRop::convert(rasOut, rasIn, palette, transparencyCheck);

}

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

void TRop::convert(

    const TRaster32P &rasOut, const TRasterCM32P &rasIn, TPaletteP palette,

    const TRect &theClipRect,  // il rect su cui e' applicata la conversione

    bool transparencyCheck, bool applyFx) {

  assert(palette);

  assert(rasIn && rasOut);

  TRect clipRect(theClipRect);

  if (clipRect.isEmpty())

    clipRect = rasIn->getBounds();

  else {

    if (!clipRect.overlaps(rasIn->getBounds())) return;

    clipRect = clipRect * rasIn->getBounds();

  }

  if (clipRect.isEmpty()) return;

  TRect clipRectIn, clipRectOut;

  if (applyFx && palette->getFxRects(clipRect, clipRectIn, clipRectOut)) {

    TRect rAux = clipRectIn;

    TRasterP rAuxIn =

        rasIn->extract(clipRectIn);  // la extract modifica clipRectIn

    if (rAux != clipRectIn && rAux != rasIn->getBounds()) {

      TRasterCM32P rNew(rAux.getSize());

      TRect tmpRect = clipRectIn - rAux.getP00();

      rNew->extract(tmpRect)->copy(rAuxIn);

      rAuxIn     = rNew;

      clipRectIn = rAux;

    }

    TTile tileIn(rAuxIn, ::convert(clipRectIn.getP00()));

    rAux = clipRectOut;

    TRasterP rAuxOut =

        rasOut->extract(clipRectOut);  // la extract modifica clipRectOut

    TTile tileOut(rAuxOut, ::convert(clipRectOut.getP00()));

    TRop::convert(tileOut, tileIn, palette, transparencyCheck, true);

  } else {

    TRect clipRectIn  = clipRect;

    TRect clipRectOut = clipRect;

    TRasterP _rasOut  = rasOut->extract(clipRectOut);

    TRasterP _rasIn   = rasIn->extract(clipRectIn);

    TTile t1(_rasOut, ::convert(clipRectOut.getP00()));

    TTile t2(_rasIn, ::convert(clipRectIn.getP00()));

    TRop::convert(t1, t2, palette, transparencyCheck, false);

  }

}

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

void TRop::convert(const TTile &dst, const TTile &src, const TPaletteP plt,

                   bool transparencyCheck, bool applyFxs) {

  // if (dst->getSize() != src->getSize())

  //  throw TRopException("convert: size mismatch");

  // assert(plt);

  if ((TRaster32P)dst.getRaster())

    do_convert(dst, src, plt, transparencyCheck, applyFxs);

  else if ((TRaster64P)dst.getRaster()) {

    TRaster32P aux(dst.getRaster()->getLx(), dst.getRaster()->getLy());

    TTile taux(aux, dst.m_pos);

    do_convert(taux, src, plt, transparencyCheck, applyFxs);

    TRop::convert(dst.getRaster(), aux);

  } else

    throw TRopException("unsupported pixel type");

}

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

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

namespace {

TRasterP putSinglePaintInRaster(TRasterCM32P &rasIn, int paintId,

                                TPixel32 color) {

  TRaster32P rasOut;

  for (int y = 0; y < rasIn->getLy(); y++) {

    TPixelCM32 *pixIn  = rasIn->pixels(y);

    TPixelCM32 *endPix = pixIn + rasIn->getLx();

    TPixel32 *pixOut   = 0;

    if (rasOut) pixOut = rasOut->pixels(y);

    while (pixIn < endPix) {

      if (pixIn->getPaint() == paintId) {

        if (!rasOut) {

          rasOut = TRaster32P(rasIn->getLx(), rasIn->getLy());

          rasOut->fill(TPixel32::Transparent);

          pixOut = rasOut->pixels(y) + (pixIn - rasIn->pixels(y));

        }

        if (!pixIn->isPureInk()) *pixOut = color;

        /*else if (!pixIn->isPureInk())

  {

        assert(TPixelCM32::getMaxTone()==0xff);

        pixOut->m = pixIn->getTone();

        pixOut->r = 255*color.r/pixOut->m;

        pixOut->g = 255*color.g/pixOut->m;

        pixOut->b = 255*color.b/pixOut->m;

}*/

        pixIn->setPaint(0);

        // pixIn->setTone(0);

      }

      pixIn++;

      pixOut++;

    }

  }

  return rasOut;

}

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

TRasterP putSingleInkInRasterGR8(TRasterCM32P &rasIn, int inkId) {

  TRasterGR8P rasOut;

  for (int y = 0; y < rasIn->getLy(); y++) {

    TPixelCM32 *pixIn  = rasIn->pixels(y);

    TPixelCM32 *endPix = pixIn + rasIn->getLx();

    TPixelGR8 *pixOut;

    if (rasOut) pixOut = rasOut->pixels(y);

    while (pixIn < endPix) {

      if (pixIn->getInk() == inkId) {

        assert(TPixelCM32::getMaxTone() == 0xff);

        if (!rasOut) {

          rasOut = TRasterGR8P(rasIn->getLx(), rasIn->getLy());

          rasOut->fill(0);

          pixOut = rasOut->pixels(y) + (pixIn - rasIn->pixels(y));

        }

        *pixOut = 255 - pixIn->getTone();

        // pixIn->setInk(0);

        pixIn->setTone(TPixelCM32::getMaxTone());

      }

      pixIn++;

      pixOut++;

    }

  }

  return rasOut;

}

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

TRasterP putSingleInkInRasterRGBM(TRasterCM32P &rasIn, int inkId) {

  TRaster32P rasOut;

  for (int y = 0; y < rasIn->getLy(); y++) {

    TPixelCM32 *pixIn  = rasIn->pixels(y);

    TPixelCM32 *endPix = pixIn + rasIn->getLx();

    TPixel *pixOut;

    if (rasOut) pixOut = rasOut->pixels(y);

    while (pixIn < endPix) {

      if (pixIn->getInk() == inkId) {

        assert(TPixelCM32::getMaxTone() == 0xff);

        if (!rasOut) {

          rasOut = TRaster32P(rasIn->getLx(), rasIn->getLy());

          rasOut->fill(TPixel32::Transparent);

          pixOut = rasOut->pixels(y) + (pixIn - rasIn->pixels(y));

        }

        pixOut->r = pixOut->g = pixOut->b = pixOut->m = 255 - pixIn->getTone();

        // pixIn->setInk(0);

        pixIn->setTone(TPixelCM32::getMaxTone());

      }

      pixIn++;

      if (rasOut) pixOut++;

    }

  }

  return rasOut;

}

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

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

// filename!!

// interactive!!

bool computePaletteFx(const std::vector<std::pair<tcolorstyle *,="" int="">> &fx,</std::pair<tcolorstyle>

                      const TTile &tileOut, const TTile &tileIn,

                      const TPaletteP plt) {

  int i;

  TRasterCM32P rasIn = tileIn.getRaster();

  TRaster32P rAux32, rasOut = tileOut.getRaster();

  TRasterGR8P rAuxGR;

  int frame = plt->getFrame();

  std::vector<trasterp> paintLayers(fx.size());</trasterp>

  std::vector<trasterp> inkLayers(fx.size());</trasterp>

  // tolgo dal raster d'ingresso gli ink e i paint con gli effetti, mettendoli

  // in dei raster layer

  for (i = 0; i < (int)fx.size(); i++) {

    TRasterStyleFx *rfx = fx[i].first->getRasterStyleFx();

    if (rfx->isPaintStyle())

      paintLayers[i] = putSinglePaintInRaster(rasIn, fx[i].second,

                                              fx[i].first->getMainColor());

    if (rfx->isInkStyle()) {

      if (rfx->inkFxNeedRGBMRaster())

        inkLayers[i] = putSingleInkInRasterRGBM(rasIn, fx[i].second);

      else

        inkLayers[i] = putSingleInkInRasterGR8(rasIn, fx[i].second);

    }

  }

  // raster d'ingresso senza i colori fx, viene renderizzato nel raster d'uscita

  do_convert(tileOut, tileIn, plt, false, false);

  // ogni layer viene "effettato".; se il risultato e' non nullo, viene

  // sovrapposto sul raster d'uscita

  // prima vengono messi tutti i layer di paint, poi quelli di ink

  TRect rectOut =

      TRect(convert(tileOut.m_pos), tileOut.getRaster()->getSize()) -

      convert(tileIn.m_pos);

  for (i = 0; i < (int)fx.size(); i++)

    if (paintLayers[i]) {

      TRasterStyleFx::Params params(paintLayers[i], convert(tileIn.m_pos),

                                    rasIn, fx[i].second, frame);

      if (fx[i].first->getRasterStyleFx()->compute(params))

        TRop::over(rasOut, paintLayers[i]->extract(rectOut), rasOut);

    }

  for (i = 0; i < (int)fx.size(); i++)

    if (inkLayers[i]) {

      TRasterStyleFx *rfx = fx[i].first->getRasterStyleFx();

      TRasterStyleFx::Params params(inkLayers[i], convert(tileIn.m_pos), rasIn,

                                    fx[i].second, frame);

      if (rfx->compute(params)) {

        if (rfx->inkFxNeedRGBMRaster())

          TRop::over(rasOut, rasOut, inkLayers[i]->extract(rectOut));

        else

          TRop::over(rasOut, inkLayers[i]->extract(rectOut),

                     fx[i].first->getMainColor());

      }

    }

  return true;

}

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

}  // namespace

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

bool renderRas32(const TTile &tileOut, const TTile &tileIn,

                 const TPaletteP palette) {

  assert(TRect(convert(tileIn.m_pos), tileIn.getRaster()->getSize())

             .contains(TRect(convert(tileOut.m_pos),

                             tileOut.getRaster()->getSize())));

  assert((TRasterCM32P)tileIn.getRaster());

  // Shrink = shrink;

  // INIT_TCM(rin)

  /* mark up are made apart */

  // computeMarkup(rasIn, palette);

  std::vector<std::pair<tcolorstyle *,="" int="">> fxArray;</std::pair<tcolorstyle>

  for (int i = 0; i < palette->getStyleCount(); i++)

    if (palette->getStyle(i)->isRasterStyle())

      fxArray.push_back(std::pair<tcolorstyle *,="" int="">(palette->getStyle(i), i));</tcolorstyle>

  if (fxArray.empty()) return false;

  TTile _tileIn(tileIn.getRaster()->clone(), tileIn.m_pos);

  tileIn.getRaster()->lock();

  tileOut.getRaster()->lock();

  computePaletteFx(fxArray, tileOut, _tileIn, palette);

  tileIn.getRaster()->unlock();

  tileOut.getRaster()->unlock();

  return true;

}

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

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

namespace {

void addColor(TPaletteP plt, int index, const TPaletteP &upPlt,

              std::map<int, int=""> &usedInks) {</int,>

  TColorStyle *cs = upPlt->getStyle(index);

  if (cs && cs->getMainColor() == plt->getStyle(index)->getMainColor()) {

    usedInks[index] = index;

    return;

  }

  int firstStyleId                     = plt->getFirstUnpagedStyle();

  if (firstStyleId == -1) firstStyleId = plt->getStyleCount();

  usedInks[index]                      = firstStyleId;

  plt->getPage(0)->addStyle(TPixel32::Red);

}

void addColor(TPaletteP plt, int index, std::map<int, int=""> &usedInks) {</int,>

  int firstStyleId                     = plt->getFirstUnpagedStyle();

  if (firstStyleId == -1) firstStyleId = plt->getStyleCount();

  usedInks[index]                      = firstStyleId;

  plt->getPage(0)->addStyle(TPixel32::Red);

}

// Check if the downPlt has the same style (same color, same index) and use it.

// If the same style is not found, then add it as a new style.

void tryMergeInkOrAddColor(TPaletteP downPlt, const TPaletteP matchPlt,

                           int index, std::map<int, int=""> &usedInks) {</int,>

  if (0 <= index && index < downPlt->getStyleCount() &&

      index < matchPlt->getStyleCount()) {

    TSolidColorStyle *solidDownStyle =

        dynamic_cast<tsolidcolorstyle *="">(downPlt->getStyle(index));</tsolidcolorstyle>

    TSolidColorStyle *solidMatchStyle =

        dynamic_cast<tsolidcolorstyle *="">(matchPlt->getStyle(index));</tsolidcolorstyle>

    if (solidDownStyle && solidMatchStyle &&

        solidDownStyle->getMainColor() == solidMatchStyle->getMainColor()) {

      usedInks[index] = index;

      return;

    }

  }

  addColor(downPlt, index, usedInks);

}

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

// std::map<int,int>& usedInk  upInkId -> downInkId</int,int>

void doMergeCmapped(TRasterCM32P rasOut, const TRasterCM32P &rasUp,

                    const TPaletteP &pltOut, const TPaletteP &matchPlt,

                    bool onlyInks, int matchlinePrevalence,

                    std::map<int, int=""> &usedInks, bool mergePalette) {</int,>

  double val = matchlinePrevalence / 100.0;  // matchlinePrevalence ==0 always

                                             // ink down; matchlinePrevalence ==

                                             // 100 always ink up;

  assert(rasOut && rasUp);

  assert(rasOut->getSize() == rasUp->getSize());

  TPaletteP downPlt = pltOut->clone();

  std::map<int, int="">::iterator it;</int,>

  for (it = usedInks.begin(); it != usedInks.end(); it++)

    downPlt->getPage(0)->addStyle(TPixel32::Red);

  for (int y = 0; y < rasOut->getLy(); y++) {

    TPixelCM32 *pixDown = rasOut->pixels(y),

               *endPix  = pixDown + rasOut->getLx();

    TPixelCM32 *pixUp   = rasUp->pixels(y);

    while (pixDown < endPix) {

      // there is lines in matchline

      if (!pixUp->isPurePaint()) {

        int toneDown = pixDown->getTone();

        int toneUp   = pixUp->getTone();

        if (usedInks.find(pixUp->getInk()) == usedInks.end()) {

          if (mergePalette)

            tryMergeInkOrAddColor(downPlt, matchPlt, pixUp->getInk(), usedInks);

          else

            addColor(downPlt, pixUp->getInk(), usedInks);

        }

        if (val == 1) {  // Matchline is on top, with gap

          pixDown->setTone(toneUp);

          pixDown->setInk(usedInks[pixUp->getInk()]);

        } else if (val == 0) {  // Matchline is on bottom, with gap

          if (pixDown->isPurePaint()) {

            pixDown->setTone(toneUp);

            pixDown->setInk(usedInks[pixUp->getInk()]);

          } else {

            //*pixOut = *pixDown;

          }

        } else {

          if ((val > 0 && toneUp < toneDown) ||

              (val == 0 && toneDown == 255))  //(toneUp

            pixDown->setTone(toneUp);

          if ((255 - toneDown) * (1 - val) <=

              val * (255 - toneUp - 1))  // val==0 -> if (toneDown== 255)....

            // val==0.5 -> if (toneup

            // val==1 -> if (toneup<255)...

            pixDown->setInk(usedInks[pixUp->getInk()]);

        }

      }

      int paintIndex;

      if (!onlyInks && (paintIndex = pixUp->getPaint()) > 0) {

        if (usedInks.find(paintIndex) == usedInks.end())

          addColor(downPlt, paintIndex, usedInks);

        pixDown->setPaint(usedInks[paintIndex]);

      }

      pixUp++;

      pixDown++;

      // pixOut++;

    }

  }

}

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

void addColors(const TPixelCM32 &color, TPaletteP plt, const TPaletteP &upPlt,

               std::map<int, int=""> &usedColors) {</int,>

  if (usedColors.find(color.getInk()) == usedColors.end())

    addColor(plt, color.getInk(), upPlt, usedColors);

  if (usedColors.find(color.getPaint()) == usedColors.end())

    addColor(plt, color.getPaint(), upPlt, usedColors);

}

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

void addColors(const TPixelCM32 &color, TPaletteP plt,

               std::map<int, int=""> &usedColors) {</int,>

  if (usedColors.find(color.getInk()) == usedColors.end())

    addColor(plt, color.getInk(), usedColors);

  if (usedColors.find(color.getPaint()) == usedColors.end())

    addColor(plt, color.getPaint(), usedColors);

}

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

void doApplyMatchLines(TRasterCM32P rasOut, const TRasterCM32P &rasUp,

                       int inkIndex, int matchlinePrevalence) {

  double val = matchlinePrevalence / 100.0;  // matchlinePrevalence ==0->always

                                             // ink down; matchlinePrevalence ==

                                             // 100 always ink up;

  assert(rasOut && rasUp);

  assert(rasOut->getSize() == rasUp->getSize());

  for (int y = 0; y < rasOut->getLy(); y++) {

    TPixelCM32 *pixDown = rasOut->pixels(y),

               *endPix  = pixDown + rasOut->getLx();

    TPixelCM32 *pixUp   = rasUp->pixels(y);

    while (pixDown < endPix) {

      if (!pixUp->isPurePaint()) {

        int toneDown = pixDown->getTone();

        int toneUp   = pixUp->getTone();

        if (val == 1) {  // Matchline is on top, with gap

          pixDown->setTone(toneUp);

          pixDown->setInk(inkIndex);

        } else if (val == 0) {  // Matchline is on bottom, with gap

          if (pixDown->isPurePaint()) {

            pixDown->setTone(toneUp);

            pixDown->setInk(inkIndex);

          } else {

          }

          //*pixOut = *pixDown;

        }

        if ((val > 0 && toneUp < toneDown) || (val == 0 && toneDown == 255))

          pixDown->setTone(toneUp);

        if ((255 - toneDown) * (1 - val) <=

            val * (255 - toneUp - 1))  // val==0 -> if (toneDown == 255)....

          // val==0.5 -> if (toneup

          // val==1 -> if (toneup<255)...

          pixDown->setInk(inkIndex);

      }

      pixUp++;

      pixDown++;

    }

  }

}

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

}  // namespace

#ifdef LEVO

void TRop::eraseColors(TRasterCM32P ras, vector<int> &colorIds, bool eraseInks,</int>

                       bool keepColor) {

  assert(ras);

  vector<int> curColorIds;</int>

  std::sort(colorIds.begin(), colorIds.end());

  if (!keepColor)

    curColorIds = colorIds;

  else {

    // prendo tutti i colori ECCETTO quelli nel vettore colorIds

    unsigned int count1 = 0, count2 = 0;

    int size = eraseInks ? TPixelCM32::getMaxInk() : TPixelCM32::getMaxPaint();

    curColorIds.resize(size + 1 - colorIds.size());

    for (int i = 0; i < size; i++)

      if (count1 < colorIds.size() && colorIds[count1] == i)

        count1++;

      else

        curColorIds[count2++] = i;

  }

  for (int y = 0; y < ras->getLy(); y++) {

    TPixelCM32 *pix = ras->pixels(y), *endPix = pix + ras->getLx();

    while (pix < endPix) {

      unsigned int i;

      int color = eraseInks ? pix->getInk() : pix->getPaint();

      if (color != 0)

        for (i = 0; i < curColorIds.size() && curColorIds[i] <= color; i++)

          if (color == curColorIds[i]) {

            *pix = eraseInks ? TPixelCM32(0, pix->getPaint(),

                                          TPixelCM32::getMaxTone())

                             : TPixelCM32(pix->getInk(), 0, pix->getTone());

            break;

          }

      pix++;

    }

  }

}

#endif

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

void TRop::eraseColors(TRasterCM32P ras, std::vector<int> *colorIds,</int>

                       bool eraseInks) {

  if (colorIds) std::sort(colorIds->begin(), colorIds->end());

  for (int y = 0; y < ras->getLy(); y++) {

    TPixelCM32 *pix = ras->pixels(y), *endPix = pix + ras->getLx();

    for (; pix < endPix; pix++) {

      unsigned int i = 0;

      int color      = eraseInks ? pix->getInk() : pix->getPaint();

      if (color == 0) continue;

      if (colorIds) {

        while (i < colorIds->size() && (*colorIds)[i] < color) i++;

        if (i == colorIds->size() || color != (*colorIds)[i]) continue;

      }

      if (eraseInks) {

        pix->setInk(0);

        pix->setTone(TPixelCM32::getMaxTone());

      } else

        pix->setPaint(0);

    }

  }

}

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

/*

void TRop::overaCmapped(TRasterCM32P rasOut, const TRasterCM32P& rasUp, const

TPaletteP &pltOut, int matchlinePrevalence, std::map<int,int>& usedColors)</int,int>

{

doMergeCmapped(rasOut, rasUp, pltOut, false, matchlinePrevalence, usedColors);

}

*/

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

void TRop::applyMatchLines(TRasterCM32P rasOut, const TRasterCM32P &rasUp,

                           const TPaletteP &pltOut, const TPaletteP &matchPlt,

                           int inkIndex, int matchlinePrevalence,

                           std::map<int, int=""> &usedInks) {</int,>

  assert(matchlinePrevalence >= 0);

  if (inkIndex == -1)

    doMergeCmapped(rasOut, rasUp, pltOut, matchPlt, true, matchlinePrevalence,

                   usedInks, false);

  else if (inkIndex == -2)

    doMergeCmapped(rasOut, rasUp, pltOut, matchPlt, true, matchlinePrevalence,

                   usedInks, true);

  else

    doApplyMatchLines(rasOut, rasUp, inkIndex, matchlinePrevalence);

}

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

void TRop::eraseStyleIds(TToonzImage *image, const std::vector<int> styleIds) {</int>

  assert(image);

  TRasterCM32P ras = image->getRaster();

  int i;

  for (i = 0; i < (int)styleIds.size(); i++) {

    int styleId = styleIds[i];

    ras->lock();

    for (int y = 0; y < ras->getLy(); y++) {

      TPixelCM32 *pix = ras->pixels(y), *endPix = pix + ras->getLx();

      while (pix < endPix) {

        bool isPaint = (pix->getPaint() == styleId);

        bool isInk   = (pix->getInk() == styleId);

        if (!isPaint && !isInk) {

          pix++;

          continue;

        } else if (isPaint && !isInk)

          *pix = TPixelCM32(pix->getInk(), 0, pix->getTone());

        else if (!isPaint && isInk)

          *pix = TPixelCM32(0, pix->getPaint(), TPixelCM32::getMaxTone());

        else if (isPaint && isInk)

          *pix = TPixelCM32(0, 0, pix->getTone());

        else

          assert(0);

        pix++;

      }

    }

    ras->unlock();

  }

}

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

inline bool isTransparent(TPixelCM32 *pix) {

  return (((*((ULONG *)pix)) & 0x000fffff) == 0xff);

}

void TRop::overlayCmapped(TRasterCM32P rasOut, const TRasterCM32P &rasUp,

                          const TPaletteP &pltOut, const TPaletteP &upPlt,

                          std::map<int, int=""> &usedColors) {</int,>

  assert(rasOut && rasUp);

  assert(rasOut->getSize() == rasUp->getSize());

  TPaletteP downPlt = pltOut->clone();

  std::map<int, int="">::iterator it;</int,>

  for (it = usedColors.begin(); it != usedColors.end(); it++)

    downPlt->getPage(0)->addStyle(TPixel32::Red);

  for (int y = 0; y < rasOut->getLy(); y++) {

    TPixelCM32 *pixDown = rasOut->pixels(y);

    TPixelCM32 *pixUp   = rasUp->pixels(y);

    for (int x = 0; x < rasOut->getLx(); x++, pixUp++, pixDown++) {

      if (isTransparent(pixUp))  // WARNING! cannot check transparent pixels

                                 // with *pixup==TPixelCM32() since also

                                 // 0x183000ff i.e., is a valid transparent

                                 // value

        continue;

      int tone = pixUp->getTone();

      if (isTransparent(pixDown) || tone == 255 || tone == 0 ||

          pixUp->getPaint() !=

              0)  // up e' punto interno, o esterno non antialiasato

      {