#include <cmath>  // pow()

#include "iwa_noise1234.h"

namespace {

double perlin_noise_3d_(const double x, const double y, const double z,

                        const int octaves_start  // 0<=

                        ,

                        const int octaves_end  // 0<=

                        ,

                        const double persistence  // Not 0

                        // 1/4 or 1/2 or 1/sqrt(3) or 1/sqrt(2) or 1 or ...

) {

  double total = 0;

  Noise1234 pn;

  for (int ii = octaves_start; ii <= octaves_end; ++ii) {

    const double frequency = pow(2.0, ii);  // 1,2,4,8...

    const double amplitude = pow(persistence, ii);

    total += pn.noise(x * frequency, y * frequency, z * frequency) * amplitude;

  }

  return total;

}

double perlin_noise_minmax_(const int octaves_start  // 0<=

                            ,

                            const int octaves_end  // 0<=

                            ,

                            const double persistence  // Not 0

                            // 1/4 or 1/2 or 1/sqrt(3) or 1/sqrt(2) or 1 or ...

) {

  double total = 0;

  for (int ii = octaves_start; ii <= octaves_end; ++ii) {

    total += pow(persistence, ii);

  }

  return total;

}

}  // namespace

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

#include <stdexcept>        // std::domain_error(-)

#include <limits>           // std::numeric_limits

#include "igs_ifx_common.h" /* igs::image::rgba */

#include "igs_perlin_noise.h"

namespace {

template <class T>

void change_(T *image_array, const int height, const int width,

             const int wrap,  // pixel

             const int channels, const bool alpha_rendering_sw,

             const double a11  // geometry of 2D affine transformation

             ,

             const double a12, const double a13, const double a21,

             const double a22, const double a23, const double zz,

             const int octaves_start  // 0<=

             ,

             const int octaves_end  // 0<=

             ,

             const double persistence  // Not 0

) {

  const int max_div   = std::numeric_limits<T>::max();

  const int max_div_2 = max_div / 2;

  // 255 / 2    --> 127

  // 65535 / 2  --> 32767

  // const double max_mul = static_cast<double>(max_div_2+0.999999);

  // const double max_off = static_cast<double>(max_div_2+1);

  const double max_mul = static_cast<double>(max_div_2 + 0.499999);

  const double max_off = static_cast<double>(max_div_2 + 1.5);

  /*

  -1 .............. 0 ......... 1

  x127+0.499999

  ------------------------------------------

  -127+0.499999 ... 0 ......... 127+0.499999

  +127+1.5      ... 127+1.5 ... 127+1.5

  ------------------------------------------

  1.000001 ........ 127+1.5 ... 255.999999

  integer

  ------------------------------------------

  1 ............... 128 ....... 255

*/

  const double maxi =

      perlin_noise_minmax_(octaves_start, octaves_end, persistence);

  using namespace igs::image::rgba;

  T *image_crnt;

  T *image_scanline = image_array;

  for (int yy = 0; yy < height; ++yy) {

    image_crnt = image_scanline;

    for (int xx = 0; xx < width; ++xx, image_crnt += channels) {

      const T val = static_cast<T>(

          perlin_noise_3d_(xx * a11 + yy * a12 + a13, xx * a21 + yy * a22 + a23,

                           zz, octaves_start, octaves_end, persistence) /

              maxi * max_mul +

          max_off);

      for (int zz = 0; zz < channels; ++zz) {

        if (!alpha_rendering_sw && (alp == zz)) {

          image_crnt[zz] = static_cast<T>(max_div);

        } else {

          image_crnt[zz] = val;

        }

      }

    }

    image_scanline += channels * wrap;

  }

}

template <>

void change_(float *image_array, const int height, const int width,

             const int wrap,  // pixel

             const int channels, const bool alpha_rendering_sw,

             const double a11  // geometry of 2D affine transformation

             ,

             const double a12, const double a13, const double a21,

             const double a22, const double a23, const double zz,

             const int octaves_start  // 0<=

             ,

             const int octaves_end  // 0<=

             ,

             const double persistence  // Not 0

) {

  const float max_div   = 1.f;

  const float max_div_2 = 0.5f;

  const double maxi =

      perlin_noise_minmax_(octaves_start, octaves_end, persistence);

  using namespace igs::image::rgba;

  float *image_crnt;

  float *image_scanline = image_array;

  for (int yy = 0; yy < height; ++yy) {

    image_crnt = image_scanline;

    for (int xx = 0; xx < width; ++xx, image_crnt += channels) {

      const float val = static_cast<float>(

          perlin_noise_3d_(xx * a11 + yy * a12 + a13, xx * a21 + yy * a22 + a23,

                           zz, octaves_start, octaves_end, persistence) /

              maxi * 0.5f +

          0.5f);

      for (int zz = 0; zz < channels; ++zz) {

        if (!alpha_rendering_sw && (alp == zz)) {

          image_crnt[zz] = 1.f;

        } else {

          image_crnt[zz] = val;

        }

      }

    }

    image_scanline += channels * wrap;

  }

}

}  // namespace

// #include "igs_geometry2d.h"

void igs::perlin_noise::change(

    unsigned char *image_array, const int height, const int width,

    const int wrap,  // pixel

    const int channels, const int bits, const bool alpha_rendering_sw,

    const double a11  // geometry of 2D affine transformation

    ,

    const double a12, const double a13, const double a21, const double a22,

    const double a23, const double zz, const int octaves_start  // 0...

    ,

    const int octaves_end  // 0...

    ,

    const double persistence  // not 0

) {

  // igs::geometry2d::affine af(a11 , a12 , a13 , a21 , a22 , a23);

  // igs::geometry2d::translate();

  if (std::numeric_limits<unsigned char>::digits == bits) {

    change_(image_array, height, width, wrap, channels, alpha_rendering_sw, a11,

            a12, a13, a21, a22, a23, zz, octaves_start, octaves_end,

            persistence);

  } else if (std::numeric_limits<unsigned short>::digits == bits) {

    change_(reinterpret_cast<unsigned short *>(image_array), height, width,

            wrap, channels, alpha_rendering_sw, a11, a12, a13, a21, a22, a23,

            zz, octaves_start, octaves_end, persistence);

  } else if (std::numeric_limits<float>::digits == bits) {

    change_(reinterpret_cast<float *>(image_array), height, width, wrap,

            channels, alpha_rendering_sw, a11, a12, a13, a21, a22, a23, zz,

            octaves_start, octaves_end, persistence);

  } else {

    throw std::domain_error("Bad bits,Not uchar/ushort");

  }

}