#pragma once

#ifndef TCG_IMAGE_OPS_HPP

#define TCG_IMAGE_OPS_HPP

// tcg includes

#include "../image_ops.h"

#include "../pixel.h"

#include "../unique_ptr.h"

// STD includes

#include <assert.h></assert.h>

#include <memory></memory>

namespace tcg {

namespace image_ops {

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

//    Flat Blur  implementation

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

template <typename pixsum="" ptrin,="" ptrout,="" typename=""></typename>

void _flatFilterLine(PtrIn in, PtrOut out, int lx, int addIn, int addOut,

                     int radius, PixSum *sums) {

  typedef typename std::iterator_traits<ptrin> trIn;</ptrin>

  typedef typename trIn::value_type pixIn_type;

  struct locals {

    inline static void fillSums(int lx, int radius, PtrIn lineIn,

                                PixSum *pixsum, int addIn, int addSum) {

      using namespace pixel_ops;

      PtrIn newPixIn = lineIn;

      PixSum sum;

      // Build up to radius pixels adding new pixels only

      int x, xNew, xEnd = tmin(radius, lx);

      for (xNew = 0; xNew != xEnd; ++xNew, newPixIn += addIn)

        sum = sum + *newPixIn;

      // Store sums AND add new pixels. Observe that the current pixel value is

      // decreased

      // BEFORE storage. This makes this function "strict" in calculating the

      // sums.

      for (x = 0; xNew != lx;

           ++x, ++xNew, lineIn += addIn, newPixIn += addIn, pixsum += addSum) {

        sum     = (sum + *newPixIn) - *lineIn;

        *pixsum = *pixsum + sum;

      }

      // Finally, without adding new pixels

      for (; x != lx; ++x, lineIn += addIn, pixsum += addSum) {

        sum     = sum - *lineIn;

        *pixsum = *pixsum + sum;

      }

    }

  };

  memset(sums, 0, lx * sizeof(PixSum));

  // Add *strict* halves of the convolution sums

  locals::fillSums(lx, radius, in, sums, addIn,

                   1);  // Right part of the convolution

  locals::fillSums(lx, radius, in + addIn * (lx - 1), sums + lx - 1, -addIn,

                   -1);  // Left   ...

  // Normalize sums

  int diameter = 2 * radius + 1;

  for (int x = 0; x != lx; ++x, in += addIn, out += addOut, ++sums) {

    using namespace pixel_ops;

    pixIn_type pix(*in);

    pixel_ops::assign(

        pix, (*sums + pix) / diameter);  // Note that *in is added, due *strict*

                                         // halving the sums above

    *out = pix;

  }

}

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

template 

          typename SelectorFunc>

void _flatFilterLine(PtrIn in, PtrOut out, int lx, int addIn, int addOut,

                     SelectorFunc selector, int radius, PixSum *sums,

                     int *counts) {

  typedef typename std::iterator_traits<ptrin> trIn;</ptrin>

  typedef typename trIn::value_type pixIn_type;

  struct locals {

    inline static void fillSums(int lx, int radius, PtrIn lineIn,

                                PixSum *pixsum, int *pixcount, int addIn,

                                int addSum, SelectorFunc selector) {

      using namespace pixel_ops;

      PtrIn newPixIn = lineIn;

      PixSum sum;

      int count = 0;

      // Build up to radius pixels adding new pixels only

      int x, xNew, xEnd = tmin(radius, lx);

      for (xNew = 0; xNew != xEnd; ++xNew, newPixIn += addIn) {

        const pixIn_type &npi = *newPixIn;

        if (selector(npi)) sum = sum + npi, ++count;

      }

      // Store sums AND add new pixels. Observe that the current pixel value is

      // decreased

      // BEFORE storage. This makes this function "strict" in calculating the

      // sums.

      for (x = 0; xNew != lx; ++x, ++xNew, lineIn += addIn, newPixIn += addIn,

          pixsum += addSum, pixcount += addSum) {

        const pixIn_type &npi = *newPixIn, &li = *lineIn;

        if (selector(npi)) sum = sum + npi, ++count;

        if (selector(li)) sum  = sum - li, --count;

        *pixsum = *pixsum + sum, *pixcount += count;

      }

      // Finally, without adding new pixels

      for (; x != lx;

           ++x, lineIn += addIn, pixsum += addSum, pixcount += addSum) {

        const pixIn_type &li = *lineIn;

        if (selector(li)) sum = sum - li, --count;

        *pixsum = *pixsum + sum, *pixcount += count;

      }

    }

  };

  memset(sums, 0, lx * sizeof(PixSum));

  memset(counts, 0, lx * sizeof(int));

  // Add *strict* halves of the convolution sums

  locals::fillSums(lx, radius, in, sums, counts, addIn, 1, selector);

  locals::fillSums(lx, radius, in + addIn * (lx - 1), sums + lx - 1,

                   counts + lx - 1, -addIn, -1, selector);

  // Normalize sums

  for (int x = 0; x != lx; ++x, in += addIn, out += addOut, ++sums, ++counts) {

    using namespace pixel_ops;

    assert(*counts >= 0);

    pixIn_type pix(*in);

    pixel_ops::assign(pix, (*sums + pix) / (*counts + 1));

    *out = pix;

  }

}

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

template <typename imgin,="" imgout,="" scalar="" typename=""></typename>

void blurRows(const ImgIn &imgIn, ImgOut &imgOut, int radius, Scalar) {

  typedef typename image_traits<imgin>::pixel_ptr_type PtrIn;</imgin>

  typedef typename image_traits<imgout>::pixel_ptr_type PtrOut;</imgout>

  typedef tcg::Pixel<scalar, image_traits<imgin="">::pixel_category> PixSum;</scalar,>

  // Validate parameters

  int inLx  = image_traits<imgin>::width(imgIn),</imgin>

      inLy  = image_traits<imgin>::height(imgIn);</imgin>

  int outLx = image_traits<imgout>::width(imgOut),</imgout>

      outLy = image_traits<imgout>::height(imgOut);</imgout>

  assert(inLx == outLx && inLy == outLy);

  int inWrap  = image_traits<imgin>::wrap(imgIn),</imgin>

      outWrap = image_traits<imgout>::wrap(imgOut);</imgout>

  // Allocate an intermediate line of pixels to store sum values

  tcg::unique_ptr<pixsum[]> sums(new PixSum[inLx]);</pixsum[]>

  // Filter rows

  for (int y = 0; y != inLy; ++y) {

    PtrIn lineIn   = image_traits<imgin>::pixel(imgIn, 0, y);</imgin>

    PtrOut lineOut = image_traits<imgout>::pixel(imgOut, 0, y);</imgout>

    _flatFilterLine(lineIn, lineOut, inLx, 1, 1, radius, sums.get());

  }

}

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

template 

          typename Scalar>

void blurRows(const ImgIn &imgIn, ImgOut &imgOut, int radius,

              SelectorFunc selector, Scalar) {

  typedef typename image_traits<imgin>::pixel_ptr_type PtrIn;</imgin>

  typedef typename image_traits<imgout>::pixel_ptr_type PtrOut;</imgout>

  typedef tcg::Pixel<scalar, image_traits<imgin="">::pixel_category> PixSum;</scalar,>

  // Validate parameters

  int inLx  = image_traits<imgin>::width(imgIn),</imgin>

      inLy  = image_traits<imgin>::height(imgIn);</imgin>

  int outLx = image_traits<imgout>::width(imgOut),</imgout>

      outLy = image_traits<imgout>::height(imgOut);</imgout>

  assert(inLx == outLx && inLy == outLy);

  int inWrap  = image_traits<imgin>::wrap(imgIn),</imgin>

      outWrap = image_traits<imgout>::wrap(imgOut);</imgout>

  // Allocate an intermediate line of pixels to store sum values

  tcg::unique_ptr<pixsum[]> sums(new PixSum[inLx]);</pixsum[]>

  tcg::unique_ptr<int[]> counts(new int[inLx]);</int[]>

  // Filter rows

  for (int y = 0; y != inLy; ++y) {

    PtrIn lineIn   = image_traits<imgin>::pixel(imgIn, 0, y);</imgin>

    PtrOut lineOut = image_traits<imgout>::pixel(imgOut, 0, y);</imgout>

    _flatFilterLine(lineIn, lineOut, inLx, 1, 1, selector, radius, sums.get(),

                    counts.get());

  }

}

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

template <typename imgin,="" imgout,="" scalar="" typename=""></typename>

void blurCols(const ImgIn &imgIn, ImgOut &imgOut, int radius, Scalar) {

  typedef typename image_traits<imgin>::pixel_ptr_type PtrIn;</imgin>

  typedef typename image_traits<imgout>::pixel_ptr_type PtrOut;</imgout>

  typedef tcg::Pixel<scalar, image_traits<imgin="" typename="">::pixel_category></scalar,>

      PixSum;

  // Validate parameters

  int inLx  = image_traits<imgin>::width(imgIn),</imgin>

      inLy  = image_traits<imgin>::height(imgIn);</imgin>

  int outLx = image_traits<imgout>::width(imgOut),</imgout>

      outLy = image_traits<imgout>::height(imgOut);</imgout>

  assert(inLx == outLx && inLy == outLy);

  int inWrap  = image_traits<imgin>::wrap(imgIn),</imgin>

      outWrap = image_traits<imgout>::wrap(imgOut);</imgout>

  // Allocate an intermediate line of pixels to store sum values

  tcg::unique_ptr<pixsum[]> sums(new PixSum[inLy]);</pixsum[]>

  // Filter columns

  for (int x = 0; x != inLx; ++x) {

    PtrIn lineIn   = image_traits<imgin>::pixel(imgIn, x, 0);</imgin>

    PtrOut lineOut = image_traits<imgout>::pixel(imgOut, x, 0);</imgout>

    _flatFilterLine(lineIn, lineOut, inLy, inWrap, outWrap, radius, sums.get());

  }

}

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

template 

          typename Scalar>

void blurCols(const ImgIn &imgIn, ImgOut &imgOut, int radius,

              SelectorFunc selector, Scalar) {

  typedef typename image_traits<imgin>::pixel_ptr_type PtrIn;</imgin>

  typedef typename image_traits<imgout>::pixel_ptr_type PtrOut;</imgout>

  typedef tcg::Pixel<scalar, image_traits<imgin="" typename="">::pixel_category></scalar,>

      PixSum;

  // Validate parameters

  int inLx  = image_traits<imgin>::width(imgIn),</imgin>

      inLy  = image_traits<imgin>::height(imgIn);</imgin>

  int outLx = image_traits<imgout>::width(imgOut),</imgout>

      outLy = image_traits<imgout>::height(imgOut);</imgout>

  assert(inLx == outLx && inLy == outLy);

  int inWrap  = image_traits<imgin>::wrap(imgIn),</imgin>

      outWrap = image_traits<imgout>::wrap(imgOut);</imgout>

  // Allocate an intermediate line of pixels to store sum values

  tcg::unique_ptr<pixsum[]> sums(new PixSum[inLy]);</pixsum[]>

  tcg::unique_ptr<int[]> counts(new int[inLy]);</int[]>

  // Filter columns

  for (int x = 0; x != inLx; ++x) {

    PtrIn lineIn   = image_traits<imgin>::pixel(imgIn, x, 0);</imgin>

    PtrOut lineOut = image_traits<imgout>::pixel(imgOut, x, 0);</imgout>

    _flatFilterLine(lineIn, lineOut, inLy, inWrap, outWrap, selector, radius,

                    sums.get(), counts.get());

  }

}

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

template <typename imgin,="" imgout,="" scalar="" typename=""></typename>

void blur(const ImgIn &imgIn, ImgOut &imgOut, int radius, Scalar) {

  blurRows(imgIn, imgOut, radius, Scalar);

  blurCols(imgOut, imgOut, radius, Scalar);

}

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

template 

          typename Scalar>

void blur(const ImgIn &imgIn, ImgOut &imgOut, int radius, SelectorFunc selector,

          Scalar) {

  blurRows(imgIn, imgOut, radius, selector, Scalar);

  blurCols(imgOut, imgOut, radius, selector, Scalar);

}

}

}  // namespace tcg::image_ops

#endif  // TCG_IMAGE_OPS_HPP