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

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

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

namespace {

template <class t=""></class>

void change_channel_(T *ima, const int pix_size, const int channels) {

  for (int ii = 0; ii < pix_size; ++ii, ima += channels) {

    ima[0] = ~ima[0];

  }

}

template <class t=""></class>

void change_multiplied_rgb(T *ima, T *alp, const int pix_size,

                           const int channels) {

  for (int ii = 0; ii < pix_size; ++ii, ima += channels, alp += channels) {

    if (alp[0] < ima[0]) {

      ima[0] = 0;

    } else {

      ima[0] = alp[0] - ima[0];

    }

  }

}

template <class t=""></class>

void change_template_(T *ima, const int hh, const int ww, const int ch,

                      const bool *sw /* each channels switch */

                      ) {

  const int sz = hh * ww;

  if (igs::image::rgba::siz == ch) {

    using namespace igs::image::rgba;

    if (sw[0]) {

      change_multiplied_rgb(&ima[red], &ima[alp], sz, ch);

    }

    if (sw[1]) {

      change_multiplied_rgb(&ima[gre], &ima[alp], sz, ch);

    }

    if (sw[2]) {

      change_multiplied_rgb(&ima[blu], &ima[alp], sz, ch);

    }

    if (sw[3]) {

      change_channel_(&ima[alp], sz, ch);

    }

  } else if (igs::image::rgb::siz == ch) {

    using namespace igs::image::rgb;

    if (sw[0]) {

      change_channel_(&ima[red], sz, ch);

    }

    if (sw[1]) {

      change_channel_(&ima[gre], sz, ch);

    }

    if (sw[2]) {

      change_channel_(&ima[blu], sz, ch);

    }

  } else if (1 == ch) { /* Grayscale */

    if (sw[0]) {

      change_channel_(&ima[0], sz, ch);

    }

  }

}

}

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

#include <limits></limits>

#include "igs_negate.h"

void igs::negate::change(unsigned char *image_array, const int height,

                         const int width, const int channels, const int bits,

                         const bool *sw_array /* each channel switch  */

                         ) {

  if ((igs::image::rgba::siz != channels) &&

      (igs::image::rgb::siz != channels) && (1 != channels) /* bit(monoBW) */

      ) {

    throw std::domain_error("Bad channels,Not rgba/rgb/grayscale");

  }

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

    change_template_(image_array, height, width, channels, sw_array);

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

    change_template_(reinterpret_cast<unsigned *="" short="">(image_array), height,</unsigned>

                     width, channels, sw_array);

  } else if (1 == bits) {

    const int bi         = width * channels * bits;

    const int dg         = std::numeric_limits<unsigned char="">::digits;</unsigned>

    const int sl_bytes   = bi / dg + ((0 != (bi % dg)) ? 1 : 0);

    const int image_size = height * sl_bytes;

    for (int ii = 0; ii < image_size; ++ii) {

      image_array[ii] = ~image_array[ii];

    }

  } else {

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

  }

}