#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));

  }

}