/*

% Copyright (C) 2004 - 2022 GraphicsMagick Group

%

% This program is covered by multiple licenses, which are described in

% Copyright.txt. You should have received a copy of Copyright.txt with this

% package; otherwise see http://www.graphicsmagick.org/www/Copyright.html.

%

% Interfaces to support quantum operators.

% Written by Bob Friesenhahn, March 2004.

%

*/

/*

  Include declarations.

*/

#include "magick/studio.h"

#include "magick/enum_strings.h"

#include "magick/gem.h"

#include "magick/pixel_iterator.h"

#include "magick/random.h"

#include "magick/utility.h"

#include "magick/operator.h"

/*

  Types.

*/

typedef struct _QuantumImmutableContext

{

  ChannelType channel;

  Quantum quantum_value;

  double double_value;

} QuantumImmutableContext;

typedef struct _QuantumMutableContext

{

  Quantum *channel_lut;

} QuantumMutableContext;

typedef struct _ChannelOptions_t

{

  DoublePixelPacket

    values;

  MagickBool

    red_enabled,

    green_enabled,

    blue_enabled,

    opacity_enabled;

} ChannelOptions_t;

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   Q u a n t u m O p e r a t o r I m a g e                                   %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  QuantumOperatorImage() performs the requested arithmetic,

%  bitwise-logical, or value operation on the selected channels of

%  the entire image.  The AllChannels channel option operates on all

%  color channels whereas the GrayChannel channel option treats the

%  color channels as a grayscale intensity.

%

%  These operations are on the DirectClass pixels of the image and do not

%  update pixel indexes or colormap.

%

%  The format of the QuantumOperatorImage method is:

%

%      MagickPassFail QuantumOperatorImage(Image *image,

%        ChannelType channel, QuantumOperator operator,

%        double rvalue)

%

%  A description of each parameter follows:

%

%    o image: The image.

%

%    o channel: Channel to operate on (RedChannel, CyanChannel,

%        GreenChannel, MagentaChannel, BlueChannel, YellowChannel,

%        OpacityChannel, BlackChannel, MatteChannel, AllChannels,

%        GrayChannel).  The AllChannels type only updates color

%        channels.  The GrayChannel type treats the color channels

%        as if they represent an intensity.

%

%    o quantum_operator: Operator to use (AddQuantumOp, AndQuantumOp,

%        AssignQuantumOp, DepthQuantumOp, DivideQuantumOp, GammaQuantumOp,

%        LShiftQuantumOp, MultiplyQuantumOp,  NegateQuantumOp,

%        NoiseGaussianQuantumOp, NoiseImpulseQuantumOp,

%        NoiseLaplacianQuantumOp, NoiseMultiplicativeQuantumOp,

%        NoisePoissonQuantumOp, NoiseRandomQuantumOp, NoiseUniformQuantumOp,

%        OrQuantumOp, RShiftQuantumOp, SubtractQuantumOp,

%        ThresholdBlackQuantumOp, ThresholdQuantumOp, ThresholdWhiteQuantumOp,

%        ThresholdBlackNegateQuantumOp, ThresholdWhiteNegateQuantumOp,

%        XorQuantumOp).

%

%    o rvalue: Operator argument.

%

%    o exception: Updated with error description.

%

*/

MagickExport MagickPassFail QuantumOperatorImage(Image *image,

  const ChannelType channel,const QuantumOperator quantum_operator,

  const double rvalue,ExceptionInfo *exception)

{

  return QuantumOperatorRegionImage(image,0,0,image->columns,image->rows,

                                    channel,quantum_operator,rvalue,exception);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

+   Q u a n t u m O p e r a t o r I m a g e M u l t i v a l u e               %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  QuantumOperatorImageMultivalue() is a semi-private implementation

%  function which accepts a comma delimited string of per-channel values

%  and applies a specified operator to the channels of the image.  The

%  main reason for this function to exist is to support

%  ChannelThresholdPixels(), BlackThresholdImage(), WhiteThresholdImage(),

%  or any other legacy style function which needs to be implemented.

%

%  The format of the QuantumOperatorImageMultivalue method is:

%

%      MagickPassFail QuantumOperatorImageMultivalue(

%                                 Image *image,

%                                 const QuantumOperator quantum_operator,

%                                 const char *values)

%

%  A description of each parameter follows:

%

%    o image: The image.

%

%    o values: define the rvalues, <red>{<green>,<blue>,<opacity>}{%}.

%

*/

MagickExport MagickPassFail

QuantumOperatorImageMultivalue(Image *image,

                               const QuantumOperator quantum_operator,

                               const char *values)

{

  ChannelOptions_t

    options;

  int

    count;

  MagickPassFail

    status;

  assert(image != (Image *) NULL);

  assert(image->signature == MagickSignature);

  if (values == (const char *) NULL)

    return MagickFail;;

  options.red_enabled        = MagickFalse;

  options.green_enabled      = MagickFalse;

  options.blue_enabled       = MagickFalse;

  options.opacity_enabled    = MagickFalse;

  options.values.red       = -1.0;

  options.values.green     = -1.0;

  options.values.blue      = -1.0;

  options.values.opacity   = -1.0;

  count=sscanf(values,"%lf%*[/,%%]%lf%*[/,%%]%lf%*[/,%%]%lf",

               &options.values.red,

               &options.values.green,

               &options.values.blue,

               &options.values.opacity);

  if ((count > 3) && (options.values.opacity >= 0.0))

    options.opacity_enabled = MagickTrue;

  if ((count > 2) && (options.values.blue >= 0.0))

    options.blue_enabled = MagickTrue;

  if ((count > 1) && (options.values.green >= 0.0))

    options.green_enabled = MagickTrue;

  if ((count > 0) && (options.values.red >= 0.0))

    options.red_enabled = MagickTrue;

  if (strchr(values,'%') != (char *) NULL)

    {

      if (options.red_enabled)

        options.values.red     *= MaxRGB/100.0;

      if (options.green_enabled)

        options.values.green   *= MaxRGB/100.0;

      if (options.blue_enabled)

        options.values.blue    *= MaxRGB/100.0;

      if (options.opacity_enabled)

        options.values.opacity *= MaxRGB/100.0;

    }

  status=MagickPass;

  if ((IsRGBColorspace(image->colorspace)) &&

      ((count == 1) ||

       ((options.values.red == options.values.green) &&

        (options.values.green == options.values.blue))))

    {

      /*

        Apply operation to all channels in gray or RGB space.

      */

      if (IsGrayColorspace(image->colorspace))

        status=QuantumOperatorImage(image,GrayChannel,quantum_operator,

                                    options.values.red,&image->exception);

      else

        status=QuantumOperatorImage(image,AllChannels,quantum_operator,

                                    options.values.red,&image->exception);

    }

  else

    {

      /*

        Apply operator to individual RGB(A) channels.

      */

      if ((MagickPass == status) && (options.red_enabled))

        {

          status=QuantumOperatorImage(image,RedChannel,quantum_operator,

                                      options.values.red,&image->exception);

        }

      if ((MagickPass == status) && (options.green_enabled))

        {

          status=QuantumOperatorImage(image,GreenChannel,quantum_operator,

                                      options.values.green,&image->exception);

        }

      if ((MagickPass == status) && (options.blue_enabled))

        {

          status=QuantumOperatorImage(image,BlueChannel,quantum_operator,

                                      options.values.blue,&image->exception);

        }

      if ((MagickPass == status) && (options.opacity_enabled))

        {

          status=QuantumOperatorImage(image,OpacityChannel,quantum_operator,

                                      options.values.opacity,&image->exception);

        }

    }

  if ((MagickPass == status) && (options.opacity_enabled))

    {

      status=QuantumOperatorImage(image,OpacityChannel,quantum_operator,

                                  options.values.opacity,&image->exception);

    }

  return status;

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   Q u a n t u m O p e r a t o r R e g i o n I m a g e                       %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  QuantumOperatorRegionImage() performs the requested arithmetic,

%  bitwise-logical, or value operation on the selected channels of

%  the image over the specified region. The AllChannels channel option

%  operates on all color channels whereas the GrayChannel channel option

%  treats the color channels as a grayscale intensity.

%

%  These operations are on the DirectClass pixels of the image and do not

%  update pixel indexes or colormap.

%

%  The format of the QuantumOperatorRegionImage method is:

%

%      MagickPassFail QuantumOperatorRegionImage(Image *image,

%        long x, long y, unsigned long columns, unsigned long rows,

%        ChannelType channel, QuantumOperator quantum_operator,

%        double rvalue)

%

%  A description of each parameter follows:

%

%    o image: The image.

%

%    o channel: Channel to operate on (RedChannel, CyanChannel,

%        GreenChannel, MagentaChannel, BlueChannel, YellowChannel,

%        OpacityChannel, BlackChannel, MatteChannel, AllChannels,

%        GrayChannel).  The AllChannels type only updates color

%        channels.  The GrayChannel type treats the color channels

%        as if they represent an intensity.

%

%    o x: Ordinate of left row of region.

%

%    o y: Ordinate of top column of region.

%

%    o columns: Width of region.

%

%    o rows: Height of region.

%

%    o quantum_operator: Operator to use (AddQuantumOp,AndQuantumOp,

%        AssignQuantumOp, DepthQuantumOp, DivideQuantumOp, GammaQuantumOp,

%        LShiftQuantumOp, MultiplyQuantumOp,  NegateQuantumOp,

%        NoiseGaussianQuantumOp, NoiseImpulseQuantumOp,

%        NoiseLaplacianQuantumOp, NoiseMultiplicativeQuantumOp,

%        NoisePoissonQuantumOp, NoiseRandomQuantumOp, NoiseUniformQuantumOp,

%        OrQuantumOp, RShiftQuantumOp, SubtractQuantumOp,

%        ThresholdBlackQuantumOp, ThresholdQuantumOp, ThresholdWhiteQuantumOp,

%        XorQuantumOp).

%

%    o rvalue: Operator argument.

%

%    o exception: Updated with error description.

%

*/

#define ApplyArithmeticOperator(lvalue,op,rvalue)       \

{                                                       \

    double                                              \

      result;                                           \

                                                        \

    result=(double) lvalue op (double) rvalue;          \

    lvalue=RoundDoubleToQuantum(result);                \

}

static MagickPassFail

QuantumAddCB(void *mutable_data,

             const void *immutable_data,

             Image * restrict image,

             PixelPacket * restrict pixels,

             IndexPacket * restrict indexes,

             const long npixels,

             ExceptionInfo *exception)

{

  const QuantumImmutableContext

    *context=(const QuantumImmutableContext *) immutable_data;

  register long

    i;

  ARG_NOT_USED(mutable_data);

  ARG_NOT_USED(image);

  ARG_NOT_USED(indexes);

  ARG_NOT_USED(exception);

  switch (context->channel)

    {

    case RedChannel:

    case CyanChannel:

      for (i=0; i < npixels; i++)

        ApplyArithmeticOperator(pixels[i].red,+,context->double_value);

      break;

    case GreenChannel:

    case MagentaChannel:

      for (i=0; i < npixels; i++)

        ApplyArithmeticOperator(pixels[i].green,+,context->double_value);

      break;

    case BlueChannel:

    case YellowChannel:

      for (i=0; i < npixels; i++)

        ApplyArithmeticOperator(pixels[i].blue,+,context->double_value);

      break;

    case BlackChannel:

    case MatteChannel:

    case OpacityChannel:

      for (i=0; i < npixels; i++)

        ApplyArithmeticOperator(pixels[i].opacity,+,context->double_value);

      break;

    case UndefinedChannel:

    case AllChannels:

      for (i=0; i < npixels; i++)

        {

          ApplyArithmeticOperator(pixels[i].red,+,context->double_value);

          ApplyArithmeticOperator(pixels[i].green,+,context->double_value);

          ApplyArithmeticOperator(pixels[i].blue,+,context->double_value);

        }

      break;

    case GrayChannel:

      for (i=0; i < npixels; i++)

        {

          Quantum

            intensity;

          intensity = PixelIntensity(&pixels[i]);

          ApplyArithmeticOperator(intensity,+,context->double_value);

          pixels[i].red = pixels[i].green = pixels[i].blue = intensity;

        }

      break;

    }

  return (MagickPass);

}

static MagickPassFail

QuantumAndCB(void *mutable_data,

             const void *immutable_data,

             Image * restrict image,

             PixelPacket * restrict pixels,

             IndexPacket * restrict indexes,

             const long npixels,

             ExceptionInfo *exception)

{

  const QuantumImmutableContext

    *context=(const QuantumImmutableContext *) immutable_data;

  register long

    i;

  ARG_NOT_USED(mutable_data);

  ARG_NOT_USED(image);

  ARG_NOT_USED(indexes);

  ARG_NOT_USED(exception);

  switch (context->channel)

    {

    case RedChannel:

    case CyanChannel:

      for (i=0; i < npixels; i++)

        pixels[i].red &= context->quantum_value;

      break;

    case GreenChannel:

    case MagentaChannel:

      for (i=0; i < npixels; i++)

        pixels[i].green &= context->quantum_value;

      break;

    case BlueChannel:

    case YellowChannel:

      for (i=0; i < npixels; i++)

        pixels[i].blue &= context->quantum_value;

      break;

    case BlackChannel:

    case MatteChannel:

    case OpacityChannel:

      for (i=0; i < npixels; i++)

        pixels[i].opacity &= context->quantum_value;

      break;

    case UndefinedChannel:

    case AllChannels:

      for (i=0; i < npixels; i++)

        {

          pixels[i].red &= context->quantum_value;

          pixels[i].green &= context->quantum_value;

          pixels[i].blue &= context->quantum_value;

        }

      break;

    case GrayChannel:

      for (i=0; i < npixels; i++)

        {

          Quantum

            intensity;

          intensity = PixelIntensity(&pixels[i]);

          intensity &= context->quantum_value;

          pixels[i].red = pixels[i].green = pixels[i].blue = intensity;

        }

      break;

    }

  return (MagickPass);

}

static MagickPassFail

QuantumAssignCB(void *mutable_data,

                const void *immutable_data,

                Image * restrict image,

                PixelPacket * restrict pixels,

                IndexPacket * restrict indexes,

                const long npixels,

                ExceptionInfo *exception)

{

  const QuantumImmutableContext

    *context=(const QuantumImmutableContext *) immutable_data;

  register long

    i;

  ARG_NOT_USED(mutable_data);

  ARG_NOT_USED(image);

  ARG_NOT_USED(indexes);

  ARG_NOT_USED(exception);

  switch (context->channel)

    {

    case RedChannel:

    case CyanChannel:

      for (i=0; i < npixels; i++)

        pixels[i].red = context->quantum_value;

      break;

    case GreenChannel:

    case MagentaChannel:

      for (i=0; i < npixels; i++)

        pixels[i].green = context->quantum_value;

      break;

    case BlueChannel:

    case YellowChannel:

      for (i=0; i < npixels; i++)

        pixels[i].blue = context->quantum_value;

      break;

    case BlackChannel:

    case MatteChannel:

    case OpacityChannel:

      for (i=0; i < npixels; i++)

        pixels[i].opacity = context->quantum_value;

      break;

    case UndefinedChannel:

    case AllChannels:

      for (i=0; i < npixels; i++)

        {

          pixels[i].red = context->quantum_value;

          pixels[i].green = context->quantum_value;

          pixels[i].blue = context->quantum_value;

        }

      break;

    case GrayChannel:

      for (i=0; i < npixels; i++)

        {

          pixels[i].red = pixels[i].green = pixels[i].blue =

            context->quantum_value;

        }

      break;

    }

  return (MagickPass);

}

#if 0

#define ApplyChannelDepth(parameter)                                    \

  {                                                                     \

    for (i=0; i < npixels; i++)                                         \

      parameter=scale*((parameter)/scale);                              \

  }

#endif

#if MaxRGB > MaxMap

#  define CrushChannelDepth(parameter) (scale*((parameter)/scale))

#else

#  define CrushChannelDepth(parameter) (mutable_context->channel_lut[ScaleQuantumToMap(parameter)])

#endif

static MagickPassFail

QuantumDepthCB(void *mutable_data,

               const void *immutable_data,

               Image * restrict image,

               PixelPacket * restrict pixels,

               IndexPacket * restrict indexes,

               const long npixels,

               ExceptionInfo *exception)

{

  QuantumMutableContext

    *mutable_context=(QuantumMutableContext *) mutable_data;

  const QuantumImmutableContext

    *immutable_context=(const QuantumImmutableContext *) immutable_data;

  unsigned int

    depth;

  unsigned int

    scale;

  register long

    i;

  MagickPassFail

    status=MagickPass;

  ARG_NOT_USED(mutable_data);

  ARG_NOT_USED(exception);

  depth=immutable_context->quantum_value;

  if (depth < 1)

    depth=1;

  else if (depth > QuantumDepth)

    depth=QuantumDepth;

  if (depth < QuantumDepth)

    {

      scale=MaxRGB / (MaxRGB >> (QuantumDepth-depth));

      /*

        Build LUT for Q8 and Q16 builds

      */

#if MaxRGB <= MaxMap

#  if defined(HAVE_OPENMP)

#    pragma omp critical (GM_QuantumDepthCB)

#  endif

      if (mutable_context->channel_lut == (Quantum *) NULL)

        {

          mutable_context->channel_lut=MagickAllocateArray(Quantum *, MaxMap+1,sizeof(Quantum));

          if (mutable_context->channel_lut == (Quantum *) NULL)

            status=MagickFail;

          if (mutable_context->channel_lut != (Quantum *) NULL)

            {

              unsigned int

                li;

              for (li=0; li <= MaxMap; li++)

                mutable_context->channel_lut[li] = scale*(li/scale);

            }

        }

      if (MagickFail == status)

        return status;

#else

      ARG_NOT_USED(*mutable_context);

      ARG_NOT_USED(status);

#endif

      switch (immutable_context->channel)

        {

        case RedChannel:

        case CyanChannel:

          for (i=0; i < npixels; i++)

            pixels[i].red=CrushChannelDepth(pixels[i].red);

          break;

        case GreenChannel:

        case MagentaChannel:

          for (i=0; i < npixels; i++)

            pixels[i].green=CrushChannelDepth(pixels[i].green);

          break;

        case BlueChannel:

        case YellowChannel:

          for (i=0; i < npixels; i++)

            pixels[i].blue=CrushChannelDepth(pixels[i].blue);

          break;

        case MatteChannel:

        case OpacityChannel:

          if (image->colorspace == CMYKColorspace)

            for (i=0; i < npixels; i++)

              indexes[i]=CrushChannelDepth(indexes[i]);

          else

            for (i=0; i < npixels; i++)

              pixels[i].opacity=CrushChannelDepth(pixels[i].opacity);

          break;

        case BlackChannel:

          for (i=0; i < npixels; i++)

            pixels[i].opacity=CrushChannelDepth(pixels[i].opacity);

          break;

        case UndefinedChannel:

        case AllChannels:

          for (i=0; i < npixels; i++)

            {

              pixels[i].red=CrushChannelDepth(pixels[i].red);

              pixels[i].green=CrushChannelDepth(pixels[i].green);

              pixels[i].blue=CrushChannelDepth(pixels[i].blue);

              if (image->colorspace == CMYKColorspace)

                pixels[i].opacity=CrushChannelDepth(pixels[i].opacity);

            }

          break;

        case GrayChannel:

          for (i=0; i < npixels; i++)

            {

              Quantum

                intensity;

              intensity = PixelIntensity(&pixels[i]);

              intensity=CrushChannelDepth(intensity);

              pixels[i].red = pixels[i].green = pixels[i].blue = intensity;

            }

          break;

        }

    }

  return MagickPass;

}

static MagickPassFail

QuantumDivideCB(void *mutable_data,

                const void *immutable_data,

                Image * restrict image,

                PixelPacket * restrict pixels,

                IndexPacket * restrict indexes,

                const long npixels,

                ExceptionInfo *exception)

{

  const QuantumImmutableContext

    *context=(const QuantumImmutableContext *) immutable_data;

  register long

    i;

  ARG_NOT_USED(mutable_data);

  ARG_NOT_USED(image);

  ARG_NOT_USED(indexes);

  ARG_NOT_USED(exception);

  switch (context->channel)

    {

    case RedChannel:

    case CyanChannel:

      for (i=0; i < npixels; i++)

        ApplyArithmeticOperator(pixels[i].red,/,context->double_value);

      break;

    case GreenChannel:

    case MagentaChannel:

      for (i=0; i < npixels; i++)

        ApplyArithmeticOperator(pixels[i].green,/,context->double_value);

      break;

    case BlueChannel:

    case YellowChannel:

      for (i=0; i < npixels; i++)

        ApplyArithmeticOperator(pixels[i].blue,/,context->double_value);

      break;

    case BlackChannel:

    case MatteChannel:

    case OpacityChannel:

      for (i=0; i < npixels; i++)

        ApplyArithmeticOperator(pixels[i].opacity,/,context->double_value);

      break;

    case UndefinedChannel:

    case AllChannels:

      for (i=0; i < npixels; i++)

        {

          ApplyArithmeticOperator(pixels[i].red,/,context->double_value);

          ApplyArithmeticOperator(pixels[i].green,/,context->double_value);

          ApplyArithmeticOperator(pixels[i].blue,/,context->double_value);

        }

      break;

    case GrayChannel:

      for (i=0; i < npixels; i++)

        {

          Quantum

            intensity;

          intensity = PixelIntensity(&pixels[i]);

          ApplyArithmeticOperator(intensity,/,context->double_value);

          pixels[i].red = pixels[i].green = pixels[i].blue = intensity;

        }

      break;

    }

  return (MagickPass);

}

#if MaxRGB > MaxMap

#  define GammaAdjustQuantum(quantum) (MaxRGBDouble*pow(quantum/MaxRGBDouble,1.0/immutable_context->double_value)+0.5)

#else

#  define GammaAdjustQuantum(quantum) (mutable_context->channel_lut[ScaleQuantumToMap(quantum)])

#endif

static MagickPassFail

QuantumGammaCB(void *mutable_data,

               const void *immutable_data,

               Image * restrict image,

               PixelPacket * restrict pixels,

               IndexPacket * restrict indexes,

               const long npixels,

               ExceptionInfo *exception)

{

  QuantumMutableContext

    *mutable_context=(QuantumMutableContext *) mutable_data;

  const QuantumImmutableContext

    *immutable_context=(const QuantumImmutableContext *) immutable_data;

  register long

    i;

  MagickPassFail

    status=MagickPass;

  ARG_NOT_USED(image);

  ARG_NOT_USED(indexes);

  ARG_NOT_USED(exception);

  /*

    Build LUT for Q8 and Q16 builds

  */

#if MaxRGB <= MaxMap

#  if defined(HAVE_OPENMP)

#    pragma omp critical (GM_QuantumGammaCB)

#  endif

  if (mutable_context->channel_lut == (Quantum *) NULL)

    {

      mutable_context->channel_lut=MagickAllocateArray(Quantum *, MaxMap+1,sizeof(Quantum));

      if (mutable_context->channel_lut == (Quantum *) NULL)

        status=MagickFail;

      if (mutable_context->channel_lut != (Quantum *) NULL)

        {

          for (i=0; i <= (long) MaxMap; i++)

            mutable_context->channel_lut[i] =

              ScaleMapToQuantum(MaxMap*pow((double) i/MaxMap,

                                           1.0/immutable_context->double_value));

        }

    }

  if (MagickFail == status)

    return status;

#else

  ARG_NOT_USED(*mutable_context);

  ARG_NOT_USED(status);

#endif

  switch (immutable_context->channel)

    {

    case RedChannel:

    case CyanChannel:

      for (i=0; i < npixels; i++)

        pixels[i].red=GammaAdjustQuantum(pixels[i].red);

      break;

    case GreenChannel:

    case MagentaChannel:

      for (i=0; i < npixels; i++)

        pixels[i].green=GammaAdjustQuantum(pixels[i].green);

      break;

    case BlueChannel:

    case YellowChannel:

      for (i=0; i < npixels; i++)

        pixels[i].blue=GammaAdjustQuantum(pixels[i].blue);

      break;

    case BlackChannel:

    case MatteChannel:

    case OpacityChannel:

      for (i=0; i < npixels; i++)

        pixels[i].opacity=GammaAdjustQuantum(pixels[i].opacity);

      break;

    case UndefinedChannel:

    case AllChannels:

      for (i=0; i < npixels; i++)

        {

          pixels[i].red=GammaAdjustQuantum(pixels[i].red);

          pixels[i].green=GammaAdjustQuantum(pixels[i].green);

          pixels[i].blue=GammaAdjustQuantum(pixels[i].blue);

        }

      break;

    case GrayChannel:

      for (i=0; i < npixels; i++)

        {

          Quantum

            intensity;

          intensity = PixelIntensity(&pixels[i]);

          intensity = GammaAdjustQuantum(intensity);

          pixels[i].red = pixels[i].green = pixels[i].blue = intensity;

        }

      break;

    }

  return status;

}

static MagickPassFail

QuantumNegateCB(void *mutable_data,

                const void *immutable_data,

                Image * restrict image,

                PixelPacket * restrict pixels,

                IndexPacket * restrict indexes,

                const long npixels,

                ExceptionInfo *exception)

{

  const QuantumImmutableContext

    *context=(const QuantumImmutableContext *) immutable_data;

  register long

    i;

  ARG_NOT_USED(mutable_data);

  ARG_NOT_USED(image);

  ARG_NOT_USED(indexes);

  ARG_NOT_USED(exception);

  switch (context->channel)

    {

    case RedChannel:

    case CyanChannel:

      for (i=0; i < npixels; i++)

        pixels[i].red=MaxRGB-pixels[i].red;

      break;

    case GreenChannel:

    case MagentaChannel:

      for (i=0; i < npixels; i++)

        pixels[i].green=MaxRGB-pixels[i].green;

      break;

    case BlueChannel:

    case YellowChannel:

      for (i=0; i < npixels; i++)

        pixels[i].blue=MaxRGB-pixels[i].blue;

      break;

    case BlackChannel:

    case MatteChannel:

    case OpacityChannel:

      for (i=0; i < npixels; i++)

        pixels[i].opacity=MaxRGB-pixels[i].opacity;

      break;

    case UndefinedChannel:

    case AllChannels:

      for (i=0; i < npixels; i++)

        {

          pixels[i].red=MaxRGB-pixels[i].red;

          pixels[i].green=MaxRGB-pixels[i].green;

          pixels[i].blue=MaxRGB-pixels[i].blue;

        }