// Toonz includes

#include "tpixelutils.h"

#include "tpalette.h"

#include "tcolorstyles.h"

#include "timage_io.h"

#include "tropcm.h"

#include "ttile.h"

#include "toonz/toonzscene.h"

#include "toonz/tcamera.h"

#include "autoadjust.h"

#include "autopos.h"

#include "cleanuppalette.h"

#include "cleanupcommon.h"

#include "tmsgcore.h"

#include "toonz/cleanupparameters.h"

#include "toonz/tcleanupper.h"

using namespace CleanupTypes;

/*  The Cleanup Process Reworked   -   EXPLANATION (by Daniele)

INTRODUCTION:

  The purpose of a Cleanup Process is hereby intended as the task of

transforming

  a fullcolor image (any bpp, matte supported*) into a TRasterCM32 -

  that is, a colormap image - given an externally specified palette of ink

colors to

  be recognized. No paint color is assumed at this stage.

  Typically, artists draw outlines using a black or dark color, whereas

different hues are

  used to mark lines that denote shadows or lights on characters.

  Additional processing steps include the ability to recognize and counter any

linear

  transformation in the image which is 'signaled' by the presence of (black)

pegbar holes,

  so that the countering linear transformation maps those peg holes in the usual

centered

  horizontal fashion.

  Post-processing include despeckling (ie removal or recoloration of little

blots with

  uniform color), and tones' brightness/contrast manipulation.

  (*) The image is first overed on top of a white background

CONSTRAINTS:

  We assume the following constraints throughout the process:

  - Palette colors:

    * Color 0 represents the PAPER color, and will just substitute it in the

colormap.

    * Colors with index >= 2 are MATCH-LINE colors, and their HUE ONLY (the H in

HSV coordinates)

    is essential to line recognition. The hue of image pixels is compared to

that of each

    matchline color - and the nearest matchline color is associated to that

pixel.

    If that associated matchline color is still too 'hue-distant' from the pixel

color

    (beyond a user-specified parameter), the pixel is ignored (ie associated to

paper).

    Furthermore, each matchline color also has a parameter corresponding to a

saturation

    threshold; pixels whose color's saturation is below the threshold specified

by the

    associated color are reassociated to the PAPER color.

    * Color 1 represents the OUTLINE color, and its VALUE (the V in HSV

coordinates) is

    assumed to be the image's lowest. Its H and S components are unused.

    Pixels whose value is below this value + a user-defined threshold parameter

are

    'outline-PRONE' pixels (even matchline-associated pixels can be).

    They are assumed to be full outline pixels if their CHROMA (S*V) is above a

    'Color threshold'. This condition lets the user settle how outline/matchline

    disputed pixels should be considered.

  - The Colormap tone for a pixel is extracted according to these rules:

    * Paper pixels are completely transparent (tone = 255).

    * Undisputed matchline colors build the tone upon the pixel's Saturation,

scaled

      so that 1.0 maps to 0, and the saturation threshold for that matchline

      color maps to 255.

    * Undisputed Outline colors do similarly, with the Value.

    * Disputed outline/matchline colors result in the blend PRODUCT of the above

tones.

      This makes the tone smoother on outline/matchline intersections.

*/

//**************************************************************************************

//    Local namespace stuff

//**************************************************************************************

namespace {

// some useful functions for doing math

inline double affMV1(const TAffine &aff, double v1, double v2) {

  return aff.a11 * v1 + aff.a12 * v2 + aff.a13;

}

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

inline double affMV2(const TAffine &aff, double v1, double v2) {

  return aff.a21 * v1 + aff.a22 * v2 + aff.a23;

}

//=========================================================================

//! Auxiliary class for HSV (toonz 4.x style)

struct HSVColor {

  double m_h;

  double m_s;

  double m_v;

public:

  HSVColor(double h = 0, double s = 0, double v = 0) : m_h(h), m_s(s), m_v(v) {}

  static HSVColor fromRGB(double r, double g, double b);

};

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

HSVColor HSVColor::fromRGB(double r, double g, double b) {

  double h, s, v;

  double max, min, delta;

  max = std::max({r, g, b});

  min = std::min({r, g, b});

  v = max;

  if (max != 0)

    s = (max - min) / max;

  else

    s = 0;

  if (s == 0)

    h = 0;

  else {

    delta = max - min;

    if (r == max)

      h = (g - b) / delta;

    else if (g == max)

      h = 2.0 + (b - r) / delta;

    else if (b == max)

      h = 4.0 + (r - g) / delta;

    h = h * 60.0;

    if (h < 0) h += 360.0;

  }

  return HSVColor(h, s, v);

}

//=========================================================================

//! Precomputation data about target colors

struct TargetColorData {

  int m_idx;                 //!< Palette color index

  HSVColor m_hsv;            //!< HSV coordinates of the color

  double m_saturationLower;  //!< Pixel colors associated with this color must

                             //! be above this

  double m_hueLower, m_hueUpper;  //!< Pixel colors associated with this color

                                  //! must in this range

public:

  TargetColorData(const TargetColor &color)

      : m_idx(-1)

      , m_hsv(HSVColor::fromRGB(color.m_color.r / 255.0,

                                color.m_color.g / 255.0,

                                color.m_color.b / 255.0))

      , m_saturationLower(1.0 - color.m_threshold / 100.0)

      , m_hueLower(m_hsv.m_h - color.m_hRange * 0.5)

      , m_hueUpper(m_hsv.m_h + color.m_hRange * 0.5) {

    if (m_hueLower < 0.0) m_hueLower += 360.0;

    if (m_hueUpper > 360.0) m_hueUpper -= 360.0;

  }

};

//=========================================================================

//! Brightness/Contrast color transform data

#define MAX_N_PENCILS 8

/* the following must be updated at every change in palette content */

int N_pencils = 4;                      /* not counting autoclose */

TPixelRGBM32 Pencil[MAX_N_PENCILS + 1]; /* last is autoclose pencil */

int Pencil_index[MAX_N_PENCILS + 1];    /* "" */

int Pencil_id[MAX_N_PENCILS + 1];       /* "" */

TPixelRGBM32 Paper = TPixel32::White;

//=========================================================================

//! Brightness/Contrast color transform structure

class TransfFunction {

  USHORT TransfFun[(MAX_N_PENCILS + 1) << 8];

  void setTransfFun(int pencil, int b1, int c1) {

    int i, p1, p2, brig, cont, max;

    cont = 255 - c1;

    brig = 255 - b1;

    max  = 255;

    notLessThan(1, cont);

    p2 = brig;

    p1 = p2 - cont;

    for (i = 0; i <= p1; i++) TransfFun[pencil << 8 | i] = 0;

    for (; i < p2; i++)

      TransfFun[pencil << 8 | i] = std::min(max, max * (i - p1) / cont);

    for (; i < 256; i++) TransfFun[pencil << 8 | i] = max;

  }

public:

  TransfFunction(const TargetColors &colors) {

    memset(TransfFun, 0, sizeof TransfFun);

    int count = std::min(colors.getColorCount(), MAX_N_PENCILS);

    for (int p = 0; p < count; p++) {

      int brightness = troundp(2.55 * colors.getColor(p).m_brightness);

      int contrast   = troundp(2.55 * colors.getColor(p).m_contrast);

      setTransfFun(p, brightness, contrast);

    }

  }

  USHORT *getTransfFun() { return TransfFun; }

};

//=========================================================================

//! Brightness/Contrast functions

void brightnessContrast(const TRasterCM32P &cm, const TargetColors &colors) {

  TransfFunction transform(colors);

  USHORT *transf_fun = transform.getTransfFun();

  int ink, tone;

  int newTone, newInk;

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

    TPixelCM32 *pix    = cm->pixels(y);

    TPixelCM32 *endPix = pix + cm->getLx();

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

      tone = pix->getTone();

      if (tone < 255) {

        ink     = pix->getInk();

        newTone = transf_fun[ink << 8 | tone];

        newInk  = (newTone == 255) ? 0 : colors.getColor(ink).m_index;

        *pix = TPixelCM32(newInk, 0, newTone);

      }

    }

  }

}

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

void brightnessContrastGR8(const TRasterCM32P &cm, const TargetColors &colors) {

  TransfFunction transform(colors);

  USHORT *transf_fun = transform.getTransfFun();

  int val, black = colors.getColor(1).m_index;

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

    TPixelCM32 *pix    = cm->pixels(y);

    TPixelCM32 *endPix = pix + cm->getLx();

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

      val  = transf_fun[pix->getValue() + 256];

      *pix = (val < 255) ? TPixelCM32(black, 0, val) : TPixelCM32();

    }

  }

}

//=========================================================================

//! Transparency check

void transparencyCheck(const TRasterCM32P &cmin, const TRaster32P &rasout) {

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

    TPixelCM32 *pix    = cmin->pixels(y);

    TPixelCM32 *endPix = pix + cmin->getLx();

    TPixel32 *outPix = rasout->pixels(y);

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

      int ink  = pix->getInk();

      int tone = pix->getTone();

      if (ink == 4095)

        *outPix = TPixel32::Green;

      else

        *outPix = (tone == 0) ? TPixel32::Black

                              : (tone == 255) ? TPixel32::White : TPixel32::Red;

    }

  }

}

}  // namespace

//**************************************************************************************

//    TCleanupper implementation - elementary functions

//**************************************************************************************

TCleanupper *TCleanupper::instance() {

  static TCleanupper theCleanupper;

  return &theCleanupper;

}

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

void TCleanupper::setParameters(CleanupParameters *parameters) {

  m_parameters = parameters;

}

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

TPalette *TCleanupper::createToonzPaletteFromCleanupPalette() {

  TPalette *cleanupPalette = m_parameters->m_cleanupPalette.getPointer();

  return createToonzPalette(cleanupPalette, 1);

}

//**************************************************************************************

//    CleanupProcessedImage implementation

//**************************************************************************************

TToonzImageP CleanupPreprocessedImage::getImg() const {

  return (TToonzImageP)(TImageCache::instance()->get(m_imgId, true));

}

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

CleanupPreprocessedImage::CleanupPreprocessedImage(

    CleanupParameters *parameters, TToonzImageP processed, bool fromGr8)

    : m_wasFromGR8(fromGr8)

    , m_autocentered(false)

    , m_size(processed->getSize()) {

  if (!processed)

    m_imgId = "";

  else {

    m_imgId = TImageCache::instance()->getUniqueId();

    assert(!processed->getRaster()->getParent());

    TImageCache::instance()->add(m_imgId, (TImageP)processed);

  }

  if (!m_wasFromGR8) {

    const TPixel32 white(255, 255, 255, 0);

    for (int i = 0; i < parameters->m_colors.getColorCount(); ++i) {

      TPixel32 cc = parameters->m_colors.getColor(i).m_color;

      for (int tone = 0; tone < 256; tone++) {

        m_pixelsLut.push_back(blend(parameters->m_colors.getColor(i).m_color,

                                    white, tone, TPixelCM32::getMaxTone()));

      }

    }

  }

}

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

CleanupPreprocessedImage::~CleanupPreprocessedImage() {

  TImageCache::instance()->remove(m_imgId);

}

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

TRasterImageP CleanupPreprocessedImage::getPreviewImage() const {

  TRaster32P ras(getSize());

  TRasterImageP ri(ras);

  double xdpi = 0, ydpi = 0;

  getImg()->getDpi(xdpi, ydpi);

  ri->setDpi(xdpi, ydpi);

  return ri;

}

//**************************************************************************************

//    TCleanupper implementation  -  Process functions

//**************************************************************************************

bool TCleanupper::getResampleValues(const TRasterImageP &image, TAffine &aff,

                                    double &blur, TDimension &outDim,

                                    TPointD &outDpi, bool isCameraTest,

                                    bool &isSameDpi) {

  double outlp, outlq;

  double scalex, scaley;

  double cxin, cyin, cpout, cqout;

  double max_blur;

  TPointD dpi;

  // Locking the input image to be cleanupped

  image->getRaster()->lock();

  // Retrieve image infos

  int rasterLx = image->getRaster()->getLx();

  int rasterLy = image->getRaster()->getLy();

  /*---入力画像サイズとSaveBoxのサイズが一致しているか？の判定---*/

  TRect saveBox          = image->getSavebox();

  bool raster_is_savebox = true;

  if (saveBox == TRect() &&

      ((saveBox.getLx() > 0 && saveBox.getLx() < rasterLx) ||

       (saveBox.getLy() > 0 && saveBox.getLy() < rasterLy)))

    raster_is_savebox = false;

  // Use the same source dpi throughout the level

  dpi = getSourceDpi();

  if (dpi == TPointD())

    dpi.x = dpi.y = 65.0;  // using 65.0 as default DPI //??????WHY

  else if (!dpi.x)

    dpi.x = dpi.y;

  else if (!dpi.y)

    dpi.y = dpi.x;

  // Retrieve some cleanup parameters

  int rotate = m_parameters->m_rotate;

  // Build scaling/dpi data

  {

    m_parameters->getOutputImageInfo(outDim, outDpi.x, outDpi.y);

    // input -> output scale factor

    scalex = outDpi.x / dpi.x;

    scaley = outDpi.y / dpi.y;

    outlp = outDim.lx;

    outlq = outDim.ly;

  }

  /*---

   * 拡大／縮小をしていない場合（DPIが変わらない場合）、NearestNeighborでリサンプリングする。---*/

  isSameDpi = areAlmostEqual(outDpi.x, dpi.x, 0.1) &&

              areAlmostEqual(outDpi.y, dpi.y, 0.1);

  // Retrieve input center

  if (raster_is_savebox) {

    cxin = -saveBox.getP00().x + (saveBox.getLx() - 1) / 2.0;

    cyin = -saveBox.getP00().y + (saveBox.getLy() - 1) / 2.0;

  } else {

    cxin = (rasterLx - 1) / 2.0;

    cyin = (rasterLy - 1) / 2.0;

  }

  // Retrieve output center

  cpout = (outlp - 1) / 2.0;

  cqout = (outlq - 1) / 2.0;

  // Perform autocenter if any is found

  double angle = 0.0;

  double skew  = 0.0;

  TAffine pre_aff;

  image->getRaster()->lock();

  bool autocentered =

      doAutocenter(angle, skew, cxin, cyin, cqout, cpout, dpi.x, dpi.y,

                   raster_is_savebox, saveBox, image, scalex);

  image->getRaster()->unlock();

  // Build the image transform as deduced by the autocenter

  if (m_parameters->m_autocenterType == AUTOCENTER_CTR && skew) {

    pre_aff.a11 = cos(skew * M_PI_180);

    pre_aff.a21 = sin(skew * M_PI_180);

  }

  aff = (TScale(scalex, scaley) * pre_aff) * TRotation(angle);

  aff = aff.place(cxin, cyin, cpout, cqout);

  // Apply eventual additional user-defined transforms

  TPointD pout = TPointD((outlp - 1) / 2.0, (outlq - 1) / 2.0);

  if (m_parameters->m_rotate != 0)

    aff = TRotation(-(double)m_parameters->m_rotate).place(pout, pout) * aff;

  if (m_parameters->m_flipx || m_parameters->m_flipy)

    aff = TScale(m_parameters->m_flipx ? -1 : 1, m_parameters->m_flipy ? -1 : 1)

              .place(pout, pout) *

          aff;

  if (!isCameraTest)

    aff = TTranslation(m_parameters->m_offx * outDpi.x / 2,

                       m_parameters->m_offy * outDpi.y / 2) *

          aff;

  max_blur = 20.0 * sqrt(fabs(scalex /*** * oversample_factor ***/));

  blur     = pow(max_blur, (100 - m_parameters->m_sharpness) / (100 - 1));

  return autocentered;

}

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

// this one incorporate the preprocessColors and the finalize function; used for

// swatch.(typically on very small rasters)

TRasterP TCleanupper::processColors(const TRasterP &rin) {

  if (m_parameters->m_lineProcessingMode == lpNone) return rin;

  TRasterCM32P rcm = TRasterCM32P(rin->getSize());

  if (!rcm) {

    assert(!"failed finalRas allocation!");

    return TRasterCM32P();

  }

  // Copy current cleanup palette to parameters' colors

  m_parameters->m_colors.update(m_parameters->m_cleanupPalette.getPointer(),

                                m_parameters->m_noAntialias);

  bool toGr8 = (m_parameters->m_lineProcessingMode == lpGrey);

  if (toGr8) {

    // No (color) processing. Not even thresholding. This just means that all

    // the important

    // stuff here is made in the brightness/contrast stage...

    // NOTE: Most of the color processing should be DISABLED in this case!!

    // finalRas->clear();

    rin->lock();

    rcm->lock();

    if (TRasterGR8P(rin)) {

      UCHAR *rowin    = rin->getRawData();

      TUINT32 *rowout = reinterpret_cast<tuint32 *="">(rcm->getRawData());</tuint32>

      for (int i = 0; i < rin->getLy(); i++) {

        for (int j = 0; j < rin->getLx(); j++)

          *rowout++ = *rowin++;  // Direct copy for now... :(

        rowin += rin->getWrap() - rin->getLx();

        rowout += rcm->getWrap() - rcm->getLx();

      }

    } else {

      TPixel32 *rowin = reinterpret_cast<tpixel32 *="">(rin->getRawData());</tpixel32>

      TUINT32 *rowout = reinterpret_cast<tuint32 *="">(rcm->getRawData());</tuint32>

      for (int i = 0; i < rin->getLy(); i++) {

        for (int j = 0; j < rin->getLx(); j++)

          *rowout++ = TPixelGR8::from(*rowin++).value;

        rowin += rin->getWrap() - rin->getLx();

        rowout += rcm->getWrap() - rcm->getLx();

      }

    }

    rin->unlock();

    rcm->unlock();

  } else {

    assert(TRaster32P(rin));

    preprocessColors(rcm, rin, m_parameters->m_colors);

  }

  // outImg->setDpi(outDpi.x, outDpi.y);

  CleanupPreprocessedImage cpi(m_parameters,

                               TToonzImageP(rcm, rcm->getBounds()), toGr8);

  cpi.m_autocentered = true;

  TRaster32P rout = TRaster32P(rin->getSize());

  finalize(rout, &cpi);

  return rout;

}

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

CleanupPreprocessedImage *TCleanupper::process(

    TRasterImageP &image, bool first_image, TRasterImageP &onlyResampledImage,

    bool isCameraTest, bool returnResampled, bool onlyForSwatch,

    TAffine *resampleAff, TRasterP templateForResampled) {

  TAffine aff;

  double blur;

  TDimension outDim(0, 0);

  TPointD outDpi;

  bool isSameDpi    = false;

  bool autocentered = getResampleValues(image, aff, blur, outDim, outDpi,

                                        isCameraTest, isSameDpi);

  if (m_parameters->m_autocenterType != AUTOCENTER_NONE && !autocentered)

    DVGui::warning(

        QObject::tr("The autocentering failed on the current drawing."));

  bool fromGr8 = (bool)TRasterGR8P(image->getRaster());

  bool toGr8   = (m_parameters->m_lineProcessingMode == lpGrey);

  // If necessary, perform auto-adjust

  if (!isCameraTest && m_parameters->m_lineProcessingMode != lpNone && toGr8 &&

      m_parameters->m_autoAdjustMode != AUTO_ADJ_NONE && !onlyForSwatch) {

    static int ref_cum[256];

    UCHAR lut[256];

    int cum[256];

    double x0_src_f, y0_src_f, x1_src_f, y1_src_f;

    int x0_src, y0_src, x1_src, y1_src;

    // cleanup_message("Autoadjusting... \n");

    TAffine inv = aff.inv();

    x0_src_f = affMV1(inv, 0, 0);

    y0_src_f = affMV2(inv, 0, 0);

    x1_src_f = affMV1(inv, outDim.lx - 1, outDim.ly - 1);

    y1_src_f = affMV2(inv, outDim.lx - 1, outDim.ly - 1);

    x0_src = tround(x0_src_f);

    y0_src = tround(y0_src_f);

    x1_src = tround(x1_src_f);

    y1_src = tround(y1_src_f);

    set_autoadjust_window(x0_src, y0_src, x1_src, y1_src);

    if (!TRasterGR8P(image->getRaster())) {

      // Auto-adjusting a 32-bit image. This means that a white background must

      // be introduced first.

      TRaster32P ras32(image->getRaster()->clone());

      TRop::addBackground(ras32, TPixel32::White);

      image = TRasterImageP(ras32);  // old image is released here

      ras32 = TRaster32P();

      TRasterGR8P rgr(image->getRaster()->getSize());

      TRop::copy(rgr, image->getRaster());

      // This is now legit. It was NOT before the clone, since the original

      // could be cached.

      image->setRaster(rgr);

    }

    switch (m_parameters->m_autoAdjustMode) {

    case AUTO_ADJ_HISTOGRAM:

      if (first_image) {

        build_gr_cum(image, ref_cum);

      } else {

        build_gr_cum(image, cum);

        build_gr_lut(ref_cum, cum, lut);

        apply_lut(image, lut);

      }

      break;

    case AUTO_ADJ_HISTO_L:

      histo_l_algo(image, first_image);

      break;

    case AUTO_ADJ_BLACK_EQ:

      black_eq_algo(image);

      break;

    case AUTO_ADJ_NONE:

    default:

      assert(false);

      break;

    }

  }

  fromGr8 = (bool)TRasterGR8P(

      image->getRaster());  // may have changed type due to auto-adjust

  assert(returnResampled ||

         !onlyForSwatch);  // if onlyForSwatch, then returnResampled

  // Allocate output colormap raster

  TRasterCM32P finalRas;

  if (!onlyForSwatch) {

    finalRas = TRasterCM32P(outDim);

    if (!finalRas) {

      TImageCache::instance()->outputMap(outDim.lx * outDim.ly * 4,

                                         "C:\\cachelog");

      assert(!"failed finalRas allocation!");

      return 0;

    }

  }

  // In case the input raster was a greymap, we cannot reutilize finalRas's

  // buffer to transform the final

  // fullcolor pixels to colormap pixels directly (1 32-bit pixel would hold 4

  // 8-bit pixels) - therefore,

  // a secondary greymap is allocated.

  // NOTE: This should be considered obsolete? By using TRop::resample(

  // <traster32p& instance=""> , ...) we</traster32p&>

  // should get the same effect!!

  TRasterP tmp_ras;

  if (returnResampled || (fromGr8 && toGr8)) {

    if (templateForResampled)

      tmp_ras = templateForResampled->create(outDim.lx, outDim.ly);

    else if (fromGr8 && toGr8)

      tmp_ras = TRasterGR8P(outDim);

    else

      tmp_ras = TRaster32P(outDim);

    if (!tmp_ras) {

      TImageCache::instance()->outputMap(outDim.lx * outDim.ly * 4,

                                         "C:\\cachelog");

      assert(!"failed tmp_ras allocation!");

      return 0;

    }

  } else

    // if finalRas is allocated, and the intermediate raster has to be 32-bit,

    // we can perform pixel

    // conversion directly on the same output buffer

    tmp_ras = TRaster32P(outDim.lx, outDim.ly, outDim.lx,

                         (TPixel32 *)finalRas->getRawData());

  TRop::ResampleFilterType flt_type;

  if (isSameDpi)

    flt_type = TRop::ClosestPixel;  // NearestNeighbor

  else if (isCameraTest)

    flt_type = TRop::Triangle;

  else

    flt_type = TRop::Hann2;

  TRop::resample(tmp_ras, image->getRaster(), aff, flt_type, blur);

  if ((TRaster32P)tmp_ras && !templateForResampled)

    // Add white background to deal with semitransparent pixels

    TRop::addBackground(tmp_ras, TPixel32::White);

  if (resampleAff) *resampleAff = aff;

  image->getRaster()->unlock();

  image = TRasterImageP();

  if (returnResampled) {

    onlyResampledImage = TRasterImageP(tmp_ras);

    onlyResampledImage->setDpi(outDpi.x, outDpi.y);

  }

  if (onlyForSwatch) return 0;

  assert(finalRas);

  // Copy current cleanup palette to parameters' colors

  m_parameters->m_colors.update(m_parameters->m_cleanupPalette.getPointer(),

                                m_parameters->m_noAntialias);

  if (toGr8) {

    // No (color) processing. Not even thresholding. This just means that all

    // the important

    // stuff here is made in the brightness/contrast stage...

    // NOTE: Most of the color processing should be DISABLED in this case!!

    tmp_ras->lock();

    finalRas->lock();

    assert(tmp_ras->getSize() == finalRas->getSize());

    assert(tmp_ras->getLx() == tmp_ras->getWrap());

    assert(finalRas->getLx() == finalRas->getWrap());

    int pixCount = outDim.lx * outDim.ly;

    if (fromGr8) {

      UCHAR *rowin    = tmp_ras->getRawData();

      TUINT32 *rowout = reinterpret_cast<tuint32 *="">(finalRas->getRawData());</tuint32>

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

        *rowout++ = *rowin++;  // Direct copy for now... :(

    } else {

      TPixel32 *rowin = reinterpret_cast<tpixel32 *="">(tmp_ras->getRawData());</tpixel32>

      TUINT32 *rowout = reinterpret_cast<tuint32 *="">(finalRas->getRawData());</tuint32>

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

        *rowout++ = TPixelGR8::from(*rowin++).value;

    }

    tmp_ras->unlock();

    finalRas->unlock();

  } else {

    // WARNING: finalRas and tmp_ras may share the SAME buffer!

    assert(TRaster32P(tmp_ras));

    preprocessColors(finalRas, tmp_ras, m_parameters->m_colors);

  }

  TToonzImageP final;

  final = TToonzImageP(finalRas, finalRas->getBounds());

  final->setDpi(outDpi.x, outDpi.y);

  CleanupPreprocessedImage *cpi =

      new CleanupPreprocessedImage(m_parameters, final, toGr8);

  cpi->m_autocentered = autocentered;

  cpi->m_appliedAff   = aff;

  return cpi;

}

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

TRasterImageP TCleanupper::autocenterOnly(const TRasterImageP &image,

                                          bool isCameraTest,

                                          bool &autocentered) {

  double xDpi, yDpi;

  // double inlx, inly, zoom_factor, max_blur;

  double skew = 0, angle = 0,

         dist = 0 /*lq_nozoom, lp_nozoom,, cx, cy, scalex, scaley*/;

  double cxin, cyin, cpout, cqout;

  int rasterIsSavebox = true;

  TAffine aff, preAff, inv;

  int rasterLx, finalLx, rasterLy, finalLy;

  rasterLx = finalLx = image->getRaster()->getLx();

  rasterLy = finalLy = image->getRaster()->getLy();

  TRect saveBox = image->getSavebox();

  if ((saveBox == TRect()) &&

      ((saveBox.getLx() > 0 && saveBox.getLx() < rasterLx) ||

       (saveBox.getLy() > 0 && saveBox.getLy() < rasterLy)))

    rasterIsSavebox = false;

  int rotate = m_parameters->m_rotate;

  image->getDpi(xDpi, yDpi);

  if (!xDpi)  // using 65.0 as default DPI

    xDpi = (yDpi ? yDpi : 65);

  if (!yDpi) yDpi = (xDpi ? xDpi : 65);

  if (rasterIsSavebox) {

    cxin = -saveBox.getP00().x + (saveBox.getLx() - 1) / 2.0;

    cyin = -saveBox.getP00().y + (saveBox.getLy() - 1) / 2.0;

  } else {

    cxin = (rasterLx - 1) / 2.0;

    cyin = (rasterLy - 1) / 2.0;

  }

  cpout = (rasterLx - 1) / 2.0;

  cqout = (rasterLy - 1) / 2.0;

  if (m_parameters->m_autocenterType != AUTOCENTER_NONE)

    autocentered = doAutocenter(angle, skew, cxin, cyin, cqout, cpout, xDpi,

                                yDpi, rasterIsSavebox, saveBox, image, 1.0);

  else

    autocentered = true;

  if (m_parameters->m_autocenterType == AUTOCENTER_CTR && skew) {

    aff.a11 = cos(skew * M_PI_180);

    aff.a21 = sin(skew * M_PI_180);

  }

  aff = aff * TRotation(angle);

  aff = aff.place(cxin, cyin, cpout, cqout);

  if (rotate != 0 && rotate != 180) std::swap(finalLx, finalLy);

  TPointD pin  = TPointD((rasterLx - 1) / 2.0, (rasterLy - 1) / 2.0);

  TPointD pout = TPointD((finalLx - 1) / 2.0, (finalLy - 1) / 2.0);

  if (rotate != 0) aff = TRotation(-(double)rotate).place(pin, pout) * aff;

  if (m_parameters->m_flipx || m_parameters->m_flipy)

    aff = TScale(m_parameters->m_flipx ? -1 : 1, m_parameters->m_flipy ? -1 : 1)

              .place(pout, pout) *

          aff;

  if (!isCameraTest)

    aff = TTranslation(m_parameters->m_offx * xDpi / 2,

                       m_parameters->m_offy * yDpi / 2) *

          aff;

  TRasterP tmpRas;

  TPoint dp;

  if (isCameraTest)  // in cameratest, I don't want to crop the image to be

                     // shown.

  // so, I resample without cropping, and I compute the offset needed to have it

  // autocentered.

  // That offset is stored in the RasterImage(setOffset below) and then used

  // when displaying the image in camerastand (in method

  // RasterPainter::onRasterImage)

  {

    // TPointD srcActualCenter = aff.inv()*TPointD(finalLx/2.0, finalLy/2.0);//

    // the autocenter position in the source image

    // TPointD srcCenter = imageToResample->getRaster()->getCenterD();*/

    TPointD dstActualCenter = TPointD(finalLx / 2.0, finalLy / 2.0);

    TPointD dstCenter       = aff * image->getRaster()->getCenterD();

    dp = convert(

        dstCenter -

        dstActualCenter);  // the amount to be offset in the destination image.

    TRect r = convert(aff * convert(image->getRaster()->getBounds()));

    aff     = (TTranslation(convert(-r.getP00())) * aff);