#include "iwa_bokehreffx.h"

#include "trop.h"

#include <qreadwritelock></qreadwritelock>

#include <qset></qset>

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

namespace {

QMutex fx_mutex;

QReadWriteLock lock;

template <typename t=""></typename>

TRasterGR8P allocateRasterAndLock(T** buf, TDimensionI dim) {

  TRasterGR8P ras(dim.lx * sizeof(T), dim.ly);

  ras->lock();

  *buf = (T*)ras->getRawData();

  return ras;

}

// modify fft coordinate to normal

inline int getCoord(int index, int lx, int ly) {

  int i = index % lx;

  int j = index / lx;

  int cx = i - lx / 2;

  int cy = j - ly / 2;

  if (cx < 0) cx += lx;

  if (cy < 0) cy += ly;

  return cy * lx + cx;

}

// release all registered raster memories

void releaseAllRasters(QList<trastergr8p>& rasterList) {</trastergr8p>

  for (int r = 0; r < rasterList.size(); r++) rasterList.at(r)->unlock();

}

// release all registered raster memories and free all fft plans

void releaseAllRastersAndPlans(QList<trastergr8p>& rasterList,</trastergr8p>

                               QList<kiss_fftnd_cfg>& planList) {</kiss_fftnd_cfg>

  releaseAllRasters(rasterList);

  for (int p = 0; p < planList.size(); p++) kiss_fft_free(planList.at(p));

}

};  // namespace

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

BokehRefThread::BokehRefThread(int channel, kiss_fft_cpx* fftcpx_channel_before,

                               kiss_fft_cpx* fftcpx_channel,

                               kiss_fft_cpx* fftcpx_alpha,

                               kiss_fft_cpx* fftcpx_iris, float4* result_buff,

                               kiss_fftnd_cfg kissfft_plan_fwd,

                               kiss_fftnd_cfg kissfft_plan_bkwd,

                               TDimensionI& dim)

    : m_channel(channel)

    , m_fftcpx_channel_before(fftcpx_channel_before)

    , m_fftcpx_channel(fftcpx_channel)

    , m_fftcpx_alpha(fftcpx_alpha)

    , m_fftcpx_iris(fftcpx_iris)

    , m_result_buff(result_buff)

    , m_kissfft_plan_fwd(kissfft_plan_fwd)

    , m_kissfft_plan_bkwd(kissfft_plan_bkwd)

    , m_dim(dim)

    , m_finished(false)

    , m_isTerminated(false) {}

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

void BokehRefThread::run() {

  // execute channel fft

  kiss_fftnd(m_kissfft_plan_fwd, m_fftcpx_channel_before, m_fftcpx_channel);

  // cancel check

  if (m_isTerminated) {

    m_finished = true;

    return;

  }

  int size = m_dim.lx * m_dim.ly;

  // multiply filter

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

    float re, im;

    re = m_fftcpx_channel[i].r * m_fftcpx_iris[i].r -

         m_fftcpx_channel[i].i * m_fftcpx_iris[i].i;

    im = m_fftcpx_channel[i].r * m_fftcpx_iris[i].i +

         m_fftcpx_iris[i].r * m_fftcpx_channel[i].i;

    m_fftcpx_channel[i].r = re;

    m_fftcpx_channel[i].i = im;

  }

  // execute invert fft

  kiss_fftnd(m_kissfft_plan_bkwd, m_fftcpx_channel, m_fftcpx_channel_before);

  // cancel check

  if (m_isTerminated) {

    m_finished = true;

    return;

  }

  // normal composite exposure value

  float4* result_p = m_result_buff;

  for (int i = 0; i < size; i++, result_p++) {

    // modify fft coordinate to normal

    int coord = getCoord(i, m_dim.lx, m_dim.ly);

    float alpha = m_fftcpx_alpha[coord].r / (float)size;

    // ignore transpalent pixels

    if (alpha == 0.0f) continue;

    float exposure = m_fftcpx_channel_before[coord].r / (float)size;

    // in case of using upper layer at all

    if (alpha >= 1.0f || (m_channel == 0 && (*result_p).x == 0.0f) ||

        (m_channel == 1 && (*result_p).y == 0.0f) ||

        (m_channel == 2 && (*result_p).z == 0.0f)) {

      // set exposure

      if (m_channel == 0)  // R

        (*result_p).x = exposure;

      else if (m_channel == 1)  // G

        (*result_p).y = exposure;

      else  // B

        (*result_p).z = exposure;

    }

    // in case of compositing both layers

    else {

      if (m_channel == 0)  // R

      {

        (*result_p).x *= 1.0f - alpha;

        (*result_p).x += exposure;

      } else if (m_channel == 1)  // G

      {

        (*result_p).y *= 1.0f - alpha;

        (*result_p).y += exposure;

      } else  // B

      {

        (*result_p).z *= 1.0f - alpha;

        (*result_p).z += exposure;

      }

    }

  }

  m_finished = true;

}

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

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

// Get the pixel size of bokehAmount ( referenced ino_blur.cpp )

// DONE

float Iwa_BokehRefFx::getBokehPixelAmount(const double frame,

                                          const TAffine affine) {

  // Convert to vector

  TPointD vect;

  vect.x = m_bokehAmount->getValue(frame);

  vect.y = 0.0;

  // Apply geometrical transformation

  TAffine aff(affine);

  aff.a13 = aff.a23 = 0;  // ignore translation

  vect              = aff * vect;

  // return the length of the vector

  return sqrtf((float)(vect.x * vect.x + vect.y * vect.y));

}

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

// normalize the source raster image to 0-1 and set to dstMem

// returns true if the source is (seems to be) premultiplied

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

template <typename pixel="" raster,="" typename=""></typename>

bool Iwa_BokehRefFx::setSourceRaster(const RASTER srcRas, float4* dstMem,

                                     TDimensionI dim) {

  bool isPremultiplied = true;

  float4* chann_p = dstMem;

  for (int j = 0; j < dim.ly; j++) {

    PIXEL* pix = srcRas->pixels(j);

    for (int i = 0; i < dim.lx; i++, pix++, chann_p++) {

      (*chann_p).x = (float)pix->r / (float)PIXEL::maxChannelValue;

      (*chann_p).y = (float)pix->g / (float)PIXEL::maxChannelValue;

      (*chann_p).z = (float)pix->b / (float)PIXEL::maxChannelValue;

      (*chann_p).w = (float)pix->m / (float)PIXEL::maxChannelValue;

      // if there is at least one pixel of which any of RGB channels has

      // higher value than alpha channel, the source image can be jusged

      // as NON-premultiplied.

      if (isPremultiplied &&

          ((*chann_p).x > (*chann_p).w || (*chann_p).y > (*chann_p).w ||

           (*chann_p).z > (*chann_p).w))

        isPremultiplied = false;

    }

  }

  return isPremultiplied;

}

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

// normalize brightness of the depth reference image to unsigned char

// and store into detMem

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

template <typename pixel="" raster,="" typename=""></typename>

void Iwa_BokehRefFx::setDepthRaster(const RASTER srcRas, unsigned char* dstMem,

                                    TDimensionI dim) {

  unsigned char* depth_p = dstMem;

  for (int j = 0; j < dim.ly; j++) {

    PIXEL* pix = srcRas->pixels(j);

    for (int i = 0; i < dim.lx; i++, pix++, depth_p++) {

      // normalize brightness to 0-1

      float val = ((float)pix->r * 0.3f + (float)pix->g * 0.59f +

                   (float)pix->b * 0.11f) /

                  (float)PIXEL::maxChannelValue;

      // convert to unsigned char

      (*depth_p) = (unsigned char)(val * (float)UCHAR_MAX + 0.5f);

    }

  }

}

template <typename pixel="" raster,="" typename=""></typename>

void Iwa_BokehRefFx::setDepthRasterGray(const RASTER srcRas,

                                        unsigned char* dstMem,

                                        TDimensionI dim) {

  unsigned char* depth_p = dstMem;

  for (int j = 0; j < dim.ly; j++) {

    PIXEL* pix = srcRas->pixels(j);

    for (int i = 0; i < dim.lx; i++, pix++, depth_p++) {

      // normalize brightness to 0-1

      float val = (float)pix->value / (float)PIXEL::maxChannelValue;

      // convert to unsigned char

      (*depth_p) = (unsigned char)(val * (float)UCHAR_MAX + 0.5f);

    }

  }

}

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

// create the depth index map based on the histogram

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

void Iwa_BokehRefFx::defineSegemntDepth(

    const unsigned char* indexMap_main, const unsigned char* indexMap_sub,

    const float* mainSub_ratio, const unsigned char* depth_buff,

    const TDimensionI& dimOut, const double frame,

    QVector<float>& segmentDepth_main, QVector<float>& segmentDepth_sub) {</float></float>

  QSet<int> segmentValues;</int>

  // histogram parameters

  struct HISTO {

    int pix_amount;

    int belongingSegmentValue;  // value to which temporary segmented

    int segmentId;

    int segmentId_sub;

  } histo[256];

  // initialize

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

    histo[h].pix_amount            = 0;

    histo[h].belongingSegmentValue = -1;

    histo[h].segmentId             = -1;

  }

  int size = dimOut.lx * dimOut.ly;

  // max and min

  int minHisto = (int)UCHAR_MAX;

  int maxHisto = 0;

  unsigned char* depth_p = (unsigned char*)depth_buff;

  for (int i = 0; i < size; i++, depth_p++) {

    histo[(int)*depth_p].pix_amount++;

    // update max and min

    if ((int)*depth_p < minHisto) minHisto = (int)*depth_p;

    if ((int)*depth_p > maxHisto) maxHisto = (int)*depth_p;

  }

  // the maximum and the minimum depth become the segment layers

  segmentValues.insert(minHisto);

  segmentValues.insert(maxHisto);

  // focus depth becomes the segment layer as well

  int focusVal = (int)(m_onFocusDistance->getValue(frame) * (double)UCHAR_MAX);

  if (minHisto < focusVal && focusVal < maxHisto)

    segmentValues.insert(focusVal);

  // set the initial segmentation for each depth value

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

    for (int seg = 0; seg < segmentValues.size(); seg++) {

      // set the segment

      if (histo[h].belongingSegmentValue == -1) {

        histo[h].belongingSegmentValue = segmentValues.values().at(seg);

        continue;

      }

      // error amount at the current registered layers

      int tmpError = std::abs(h - histo[h].belongingSegmentValue);

      if (tmpError == 0) break;

      // new error amount

      int newError = std::abs(h - segmentValues.values().at(seg));

      // compare the two and update

      if (newError < tmpError)

        histo[h].belongingSegmentValue = segmentValues.values().at(seg);

    }

  }

  // add the segment layers to the distance precision value

  while (segmentValues.size() < m_distancePrecision->getValue()) {

    // add a new segment at the value which will reduce the error amount in

    // maximum

    double tmpMaxErrorMod = 0;

    int tmpBestNewSegVal;

    bool newSegFound = false;

    for (int h = minHisto + 1; h < maxHisto; h++) {

      // if it is already set as the segment, continue

      if (histo[h].belongingSegmentValue == h) continue;

      double errorModAmount = 0;

      // estimate how much the error will be reduced if the current h becomes

      // segment

      for (int i = minHisto + 1; i < maxHisto; i++) {

        // compare the current segment value and h and take the nearest value

        // if h is near (from i), then accumulate the estimated error reduction

        // amount

        if (std::abs(i - histo[i].belongingSegmentValue) >

            std::abs(i - h))  // the current segment value has

                              // proirity, if the distance is the same

          errorModAmount +=

              (std::abs(i - histo[i].belongingSegmentValue) - std::abs(i - h)) *

              histo[i].pix_amount;

      }

      // if h will reduce the error, update the candidate segment value

      if (errorModAmount > tmpMaxErrorMod) {

        tmpMaxErrorMod   = errorModAmount;

        tmpBestNewSegVal = h;

        newSegFound      = true;

      }

    }

    if (!newSegFound) break;

    // register tmpBestNewSegVal to the segment values list

    segmentValues.insert(tmpBestNewSegVal);

    // std::cout << "insert  " << tmpBestNewSegVal << std::endl;

    // update belongingSegmentValue

    for (int h = minHisto + 1; h < maxHisto; h++) {

      // compare the current segment value and h and take the nearest value

      // if tmpBestNewSegVal is near (from h), then update the

      // belongingSegmentValue

      if (std::abs(h - histo[h].belongingSegmentValue) >

          std::abs(h - tmpBestNewSegVal))  // the current segment value has

        // proirity, if the distance is the same

        histo[h].belongingSegmentValue = tmpBestNewSegVal;

    }

  }

  // set indices from the farthest and create the index table for each depth

  // value

  QVector<int> segValVec;</int>

  int tmpSegVal = -1;

  int tmpSegId  = -1;

  for (int h = 255; h >= 0; h--) {

    if (histo[h].belongingSegmentValue != tmpSegVal) {

      segmentDepth_main.push_back((float)histo[h].belongingSegmentValue /

                                  (float)UCHAR_MAX);

      tmpSegVal = histo[h].belongingSegmentValue;

      tmpSegId++;

      segValVec.push_back(tmpSegVal);

    }

    histo[h].segmentId = tmpSegId;

  }

  // "sub" depth segment value list for interporation

  for (int d = 0; d < segmentDepth_main.size() - 1; d++)

    segmentDepth_sub.push_back(

        (segmentDepth_main.at(d) + segmentDepth_main.at(d + 1)) / 2.0f);

  // create the "sub" index table for each depth value

  tmpSegId = 0;

  for (int seg = 0; seg < segValVec.size() - 1; seg++) {

    int hMax = (seg == 0) ? 255 : segValVec.at(seg);

    int hMin = (seg == segValVec.size() - 2) ? 0 : segValVec.at(seg + 1) + 1;

    for (int h = hMax; h >= hMin; h--) histo[h].segmentId_sub = tmpSegId;

    tmpSegId++;

  }

  // convert the depth value to the segment index by using the index table

  depth_p               = (unsigned char*)depth_buff;

  unsigned char* main_p = (unsigned char*)indexMap_main;

  unsigned char* sub_p  = (unsigned char*)indexMap_sub;

  // mainSub_ratio represents the composition ratio of the image with "main"

  // separation.

  float* ratio_p = (float*)mainSub_ratio;

  for (int i = 0; i < size; i++, depth_p++, main_p++, sub_p++, ratio_p++) {

    *main_p = (unsigned char)histo[(int)*depth_p].segmentId;

    *sub_p  = (unsigned char)histo[(int)*depth_p].segmentId_sub;

    float depth         = (float)*depth_p / (float)UCHAR_MAX;

    float main_segDepth = segmentDepth_main.at(*main_p);

    float sub_segDepth  = segmentDepth_sub.at(*sub_p);

    if (main_segDepth == sub_segDepth)

      *ratio_p = 1.0f;

    else {

      *ratio_p =

          1.0f - (main_segDepth - depth) / (main_segDepth - sub_segDepth);

      if (*ratio_p > 1.0f) *ratio_p = 1.0f;

      if (*ratio_p < 0.0f) *ratio_p = 0.0f;

    }

  }

}

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

// set the result

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

template <typename pixel="" raster,="" typename=""></typename>

void Iwa_BokehRefFx::setOutputRaster(float4* srcMem, const RASTER dstRas,

                                     TDimensionI dim, TDimensionI margin) {

  int out_j = 0;

  for (int j = margin.ly; j < dstRas->getLy() + margin.ly; j++, out_j++) {

    PIXEL* pix     = dstRas->pixels(out_j);

    float4* chan_p = srcMem;

    chan_p += j * dim.lx + margin.lx;

    for (int i = 0; i < dstRas->getLx(); i++, pix++, chan_p++) {

      float val;

      val    = (*chan_p).x * (float)PIXEL::maxChannelValue + 0.5f;

      pix->r = (typename PIXEL::Channel)((val > (float)PIXEL::maxChannelValue)

                                             ? (float)PIXEL::maxChannelValue

                                             : val);

      val    = (*chan_p).y * (float)PIXEL::maxChannelValue + 0.5f;

      pix->g = (typename PIXEL::Channel)((val > (float)PIXEL::maxChannelValue)

                                             ? (float)PIXEL::maxChannelValue

                                             : val);

      val    = (*chan_p).z * (float)PIXEL::maxChannelValue + 0.5f;

      pix->b = (typename PIXEL::Channel)((val > (float)PIXEL::maxChannelValue)

                                             ? (float)PIXEL::maxChannelValue

                                             : val);

      val    = (*chan_p).w * (float)PIXEL::maxChannelValue + 0.5f;

      pix->m = (typename PIXEL::Channel)((val > (float)PIXEL::maxChannelValue)

                                             ? (float)PIXEL::maxChannelValue

                                             : val);

    }

  }

}

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

// obtain iris size from the depth value

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

inline float Iwa_BokehRefFx::calcIrisSize(const float depth,

                                          const float bokehPixelAmount,

                                          const double onFocusDistance) {

  return ((float)onFocusDistance - depth) * bokehPixelAmount;

}

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

// resize/invert the iris according to the size ratio

// normalize the brightness

// resize to the output size

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

void Iwa_BokehRefFx::convertIris(const float irisSize, const TRectD& irisBBox,

                                 const TTile& irisTile,

                                 const TDimensionI& dimOut,

                                 kiss_fft_cpx* fftcpx_iris_before) {

  // original size of the iris image

  TDimensionD irisOrgSize = irisBBox.getSize();

  // obtain size ratio based on width

  double irisSizeResampleRatio = irisSize / irisOrgSize.lx;

  // create the raster for resizing

  TDimensionD resizedIrisSize(std::abs(irisSizeResampleRatio) * irisOrgSize.lx,

                              std::abs(irisSizeResampleRatio) * irisOrgSize.ly);

  TDimensionI filterSize((int)std::ceil(resizedIrisSize.lx),

                         (int)std::ceil(resizedIrisSize.ly));

  TPointD resizeOffset((double)filterSize.lx - resizedIrisSize.lx,

                       (double)filterSize.ly - resizedIrisSize.ly);

  bool isIrisOffset[2] = {false, false};

  // iris shape must be exactly at the center of the image

  if ((dimOut.lx - filterSize.lx) % 2 == 1) {

    filterSize.lx++;

    isIrisOffset[0] = true;

  }

  if ((dimOut.ly - filterSize.ly) % 2 == 1) {

    filterSize.ly++;

    isIrisOffset[1] = true;

  }

  // if the filter size becomes larger than the output size, return

  if (filterSize.lx > dimOut.lx || filterSize.ly > dimOut.ly) {

    std::cout

        << "Error: The iris filter size becomes larger than the source size!"

        << std::endl;

    return;

  }

  TRaster64P resizedIris(filterSize);

  // offset

  TAffine aff;

  TPointD affOffset((isIrisOffset[0]) ? 0.5 : 1.0,

                    (isIrisOffset[1]) ? 0.5 : 1.0);

  if (!isIrisOffset[0]) affOffset.x -= resizeOffset.x / 2;

  if (!isIrisOffset[1]) affOffset.y -= resizeOffset.y / 2;

  aff = TTranslation(resizedIris->getCenterD() + affOffset);

  aff *= TScale(irisSizeResampleRatio);

  aff *= TTranslation(-(irisTile.getRaster()->getCenterD() + affOffset));

  // resample the iris

  TRop::resample(resizedIris, irisTile.getRaster(), aff);

  // sum of the value

  float irisValAmount = 0.0;

  int iris_j = 0;

  // initialize

  for (int i = 0; i < dimOut.lx * dimOut.ly; i++) {

    fftcpx_iris_before[i].r = 0.0;

    fftcpx_iris_before[i].i = 0.0;

  }

  for (int j = (dimOut.ly - filterSize.ly) / 2; iris_j < filterSize.ly;

       j++, iris_j++) {

    TPixel64* pix = resizedIris->pixels(iris_j);

    int iris_i    = 0;

    for (int i = (dimOut.lx - filterSize.lx) / 2; iris_i < filterSize.lx;

         i++, iris_i++) {

      // Value = 0.3R 0.59G 0.11B

      fftcpx_iris_before[j * dimOut.lx + i].r =

          ((float)pix->r * 0.3f + (float)pix->g * 0.59f +

           (float)pix->b * 0.11f) /

          (float)USHRT_MAX;

      irisValAmount += fftcpx_iris_before[j * dimOut.lx + i].r;

      pix++;

    }

  }

  // Normalize value

  for (int i = 0; i < dimOut.lx * dimOut.ly; i++)

    fftcpx_iris_before[i].r /= irisValAmount;

}

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

// convert source image value rgb -> exposure

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

void Iwa_BokehRefFx::convertRGBToExposure(const float4* source_buff, int size,

                                          float filmGamma,

                                          bool sourceIsPremultiplied) {

  float4* source_p = (float4*)source_buff;

  for (int i = 0; i < size; i++, source_p++) {

    // continue if alpha channel is 0

    if ((*source_p).w == 0.0f) {

      (*source_p).x = 0.0f;

      (*source_p).y = 0.0f;

      (*source_p).z = 0.0f;

      continue;

    }

    // unmultiply for premultiplied source

    // this will not be applied to non-premultiplied image such as "DigiBook"

    // (digital overlay)

    if (sourceIsPremultiplied) {

      // unpremultiply

      (*source_p).x /= (*source_p).w;

      (*source_p).y /= (*source_p).w;

      (*source_p).z /= (*source_p).w;

    }

    // RGB value -> exposure

    (*source_p).x = pow(10, ((*source_p).x - 0.5f) / filmGamma);

    (*source_p).y = pow(10, ((*source_p).y - 0.5f) / filmGamma);

    (*source_p).z = pow(10, ((*source_p).z - 0.5f) / filmGamma);

    // multiply with alpha channel

    (*source_p).x *= (*source_p).w;

    (*source_p).y *= (*source_p).w;

    (*source_p).z *= (*source_p).w;

  }

}

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

// generate the segment layer source at the current depth

// considering fillGap and doMedian options

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

void Iwa_BokehRefFx::retrieveLayer(const float4* source_buff,

                                   const float4* segment_layer_buff,

                                   const unsigned char* indexMap_mainSub,

                                   int index, int lx, int ly, bool fillGap,

                                   bool doMedian, int margin) {

  // only when fillGap is ON and doMedian is OFF,

  // fill the region where will be behind of the near layers

  bool fill = (fillGap && !doMedian);

  // retrieve the regions with the current depth

  float4* source_p          = (float4*)source_buff;

  float4* layer_p           = (float4*)segment_layer_buff;

  unsigned char* indexMap_p = (unsigned char*)indexMap_mainSub;

  for (int i = 0; i < lx * ly; i++, source_p++, layer_p++, indexMap_p++) {

    // continue if the current pixel is at the far layer

    // consider the fill flag if the current pixel is at the near layer

    if ((int)(*indexMap_p) < index || (!fill && (int)(*indexMap_p) > index))

      continue;

    // copy pixel values

    (*layer_p).x = (*source_p).x;

    (*layer_p).y = (*source_p).y;

    (*layer_p).z = (*source_p).z;

    (*layer_p).w = (*source_p).w;

  }

  if (!fillGap || !doMedian) return;

  if (margin == 0) return;

  // extend pixels by using median filter

  unsigned char* generation_buff;

  TRasterGR8P generation_buff_ras = allocateRasterAndLock<unsigned char="">(</unsigned>

      &generation_buff, TDimensionI(lx, ly));

  // extend (margin * 2) pixels in order to enough cover when two adjacent

  // layers are both blurred in the maximum radius

  for (int gen = 0; gen < margin * 2; gen++) {

    // apply single median filter

    doSingleMedian(source_buff, segment_layer_buff, indexMap_mainSub, index, lx,

                   ly, generation_buff, gen + 1);

  }

  generation_buff_ras->unlock();

}

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

// apply single median filter

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

void Iwa_BokehRefFx::doSingleMedian(const float4* source_buff,

                                    const float4* segment_layer_buff,

                                    const unsigned char* indexMap_mainSub,

                                    int index, int lx, int ly,

                                    const unsigned char* generation_buff,

                                    int curGen) {

  float4* source_p          = (float4*)source_buff;

  float4* layer_p           = (float4*)segment_layer_buff;

  unsigned char* indexMap_p = (unsigned char*)indexMap_mainSub;

  unsigned char* gen_p      = (unsigned char*)generation_buff;

  for (int posY = 0; posY < ly; posY++) {

    for (int posX = 0; posX < lx;

         posX++, source_p++, layer_p++, indexMap_p++, gen_p++) {

      // continue if the current pixel is at the same or far depth

      if ((int)(*indexMap_p) <= index) continue;

      // continue if the current pixel is already extended

      if ((*gen_p) > 0) continue;

      // check out the neighbor pixels. store brightness in neighbor[x].w

      float4 neighbor[8];

      int neighbor_amount = 0;

      for (int ky = posY - 1; ky <= posY + 1; ky++) {

        for (int kx = posX - 1; kx <= posX + 1; kx++) {

          // skip the current pixel itself

          if (kx == posX && ky == posY) continue;

          // border condition

          if (ky < 0 || ky >= ly || kx < 0 || kx >= lx) continue;

          // index in the buffer

          int neighborId = ky * lx + kx;

          if ((int)indexMap_mainSub[neighborId] !=

                  index &&  // pixels from the original image can be used as

                            // neighbors

              (generation_buff[neighborId] == 0 ||  // pixels which is not yet

                                                    // be extended cannot be

                                                    // used as neighbors

               generation_buff[neighborId] == curGen))  // pixels which is

                                                        // extended in the

                                                        // current median

                                                        // generation cannot be

                                                        // used as neighbors

            continue;

          // compute brightness (actually, it is "pseudo" brightness

          // since the source buffer is already converted to exposure)

          float brightness = source_buff[neighborId].x * 0.3f +

                             source_buff[neighborId].y * 0.59f +

                             source_buff[neighborId].z * 0.11f;

          // insert with sorting

          int ins_index;

          for (ins_index = 0; ins_index < neighbor_amount; ins_index++) {

            if (neighbor[ins_index].w < brightness) break;

          }

          // displace neighbor values from neighbor_amount-1 to ins_index

          for (int k = neighbor_amount - 1; k >= ins_index; k--) {

            neighbor[k + 1].x = neighbor[k].x;

            neighbor[k + 1].y = neighbor[k].y;

            neighbor[k + 1].z = neighbor[k].z;

            neighbor[k + 1].w = neighbor[k].w;

          }

          // set the neighbor value

          neighbor[ins_index].x = source_buff[neighborId].x;

          neighbor[ins_index].y = source_buff[neighborId].y;

          neighbor[ins_index].z = source_buff[neighborId].z;

          neighbor[ins_index].w = brightness;

          // increment the count

          neighbor_amount++;

        }

      }

      // If there is no neighbor pixles available, continue

      if (neighbor_amount == 0) continue;

      // switch the behavior when there are even number of neighbors

      bool flag = ((posX + posY) % 2 == 0);

      // pick up the medium index

      int pickIndex = (flag)

                          ? (int)std::floor((float)(neighbor_amount - 1) / 2.0f)

                          : (int)std::ceil((float)(neighbor_amount - 1) / 2.0f);

      // set the medium pixel values

      (*layer_p).x = neighbor[pickIndex].x;

      (*layer_p).y = neighbor[pickIndex].y;

      (*layer_p).z = neighbor[pickIndex].z;

      (*layer_p).w = (*source_p).w;

      // set the generation

      (*gen_p) = (unsigned char)curGen;

    }

  }

}

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

// normal-composite the layer as is, without filtering

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

void Iwa_BokehRefFx::compositeAsIs(const float4* segment_layer_buff,

                                   const float4* result_buff_mainSub,

                                   int size) {

  float4* layer_p  = (float4*)segment_layer_buff;

  float4* result_p = (float4*)result_buff_mainSub;

  for (int i = 0; i < size; i++, layer_p++, result_p++) {

    // in case the pixel is full opac

    if ((*layer_p).w == 1.0f) {

      (*result_p).x = (*layer_p).x;

      (*result_p).y = (*layer_p).y;

      (*result_p).z = (*layer_p).z;

      (*result_p).w = 1.0f;

      continue;

    }

    // in case the pixel is full transparent

    else if ((*layer_p).w == 0.0f)

      continue;

    // in case the pixel is semi-transparent, do normal composite

    else {

      (*result_p).x = (*layer_p).x + (*result_p).x * (1.0f - (*layer_p).w);

      (*result_p).y = (*layer_p).y + (*result_p).y * (1.0f - (*layer_p).w);

      (*result_p).z = (*layer_p).z + (*result_p).z * (1.0f - (*layer_p).w);

      (*result_p).w = (*layer_p).w + (*result_p).w * (1.0f - (*layer_p).w);

    }

  }

}

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

// retrieve segment layer image for each channel

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

void Iwa_BokehRefFx::retrieveChannel(const float4* segment_layer_buff,  // src

                                     kiss_fft_cpx* fftcpx_r_before,     // dst

                                     kiss_fft_cpx* fftcpx_g_before,     // dst

                                     kiss_fft_cpx* fftcpx_b_before,     // dst

                                     kiss_fft_cpx* fftcpx_a_before,     // dst

                                     int size) {

  float4* layer_p = (float4*)segment_layer_buff;

  for (int i = 0; i < size; i++, layer_p++) {

    fftcpx_r_before[i].r = (*layer_p).x;

    fftcpx_g_before[i].r = (*layer_p).y;

    fftcpx_b_before[i].r = (*layer_p).z;

    fftcpx_a_before[i].r = (*layer_p).w;

  }

}

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

// multiply filter on channel

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

void Iwa_BokehRefFx::multiplyFilter(kiss_fft_cpx* fftcpx_channel,  // dst

                                    kiss_fft_cpx* fftcpx_iris,     // filter

                                    int size) {

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

    float re, im;

    re = fftcpx_channel[i].r * fftcpx_iris[i].r -

         fftcpx_channel[i].i * fftcpx_iris[i].i;

    im = fftcpx_channel[i].r * fftcpx_iris[i].i +

         fftcpx_channel[i].i * fftcpx_iris[i].r;

    fftcpx_channel[i].r = re;

    fftcpx_channel[i].i = im;

  }

}

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

// normal comosite the alpha channel

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

void Iwa_BokehRefFx::compositeAlpha(const float4* result_buff,         // dst

                                    const kiss_fft_cpx* fftcpx_alpha,  // alpha

                                    int lx, int ly) {

  int size         = lx * ly;

  float4* result_p = (float4*)result_buff;

  for (int i = 0; i < size; i++, result_p++) {

    // modify fft coordinate to normal

    float alpha = fftcpx_alpha[getCoord(i, lx, ly)].r / (float)size;

    if ((*result_p).w < 1.0f) {

      if (alpha >= 1.0f)

        (*result_p).w = 1.0f;

      else

        (*result_p).w = alpha + ((*result_p).w * (1.0f - alpha));

    }

  }

}

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

// interpolate main and sub exposures

// convert exposure -> value (0-1)

// set to the result

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

void Iwa_BokehRefFx::interpolateExposureAndConvertToRGB(

    const float4* result_main_buff,  // result1

    const float4* result_sub_buff,   // result2

    const float* mainSub_ratio,      // ratio

    float filmGamma,

    const float4* source_buff,  // dst

    int size) {

  float4* resultMain_p = (float4*)result_main_buff;

  float4* resultSub_p  = (float4*)result_sub_buff;

  float* ratio_p       = (float*)mainSub_ratio;

  float4* out_p        = (float4*)source_buff;

  for (int i = 0; i < size;

       i++, resultMain_p++, resultSub_p++, ratio_p++, out_p++) {

    // interpolate main and sub exposures

    float4 result;

    result.x =

        (*resultMain_p).x * (*ratio_p) + (*resultSub_p).x * (1.0f - (*ratio_p));

    result.y =

        (*resultMain_p).y * (*ratio_p) + (*resultSub_p).y * (1.0f - (*ratio_p));

    result.z =

        (*resultMain_p).z * (*ratio_p) + (*resultSub_p).z * (1.0f - (*ratio_p));

    result.w =

        (*resultMain_p).w * (*ratio_p) + (*resultSub_p).w * (1.0f - (*ratio_p));

    (*out_p).w = result.w;

    // convert exposure -> value (0-1)

    // continue for transparent pixel

    if (result.w == 0.0f) {

      (*out_p).x = 0.0f;

      (*out_p).y = 0.0f;

      (*out_p).z = 0.0f;

      continue;

    }

    // convert Exposure to value

    result.x = log10(result.x) * filmGamma + 0.5f;

    result.y = log10(result.y) * filmGamma + 0.5f;

    result.z = log10(result.z) * filmGamma + 0.5f;

    (*out_p).x =

        (result.x > 1.0f) ? 1.0f : ((result.x < 0.0f) ? 0.0f : result.x);

    (*out_p).y =

        (result.y > 1.0f) ? 1.0f : ((result.y < 0.0f) ? 0.0f : result.y);

    (*out_p).z =

        (result.z > 1.0f) ? 1.0f : ((result.z < 0.0f) ? 0.0f : result.z);

  }

}

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

Iwa_BokehRefFx::Iwa_BokehRefFx()

    : m_onFocusDistance(0.5)

    , m_bokehAmount(30.0)

    , m_hardness(0.3)

    , m_distancePrecision(10)

    , m_fillGap(true)

    , m_doMedian(true) {

  // Bind parameters

  addInputPort("Iris", m_iris);

  addInputPort("Source", m_source);

  addInputPort("Depth", m_depth);

  bindParam(this, "on_focus_distance", m_onFocusDistance, false);

  bindParam(this, "bokeh_amount", m_bokehAmount, false);

  bindParam(this, "hardness", m_hardness, false);

  bindParam(this, "distance_precision", m_distancePrecision, false);

  bindParam(this, "fill_gap", m_fillGap, false);