/*

% Copyright (C) 2003 - 2018 GraphicsMagick Group

% Copyright (C) 2002 ImageMagick Studio

%

% 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.

%

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

%                                                                             %

%                                                                             %

%                                                                             %

%        CCCC   OOO  M   M  PPPP    OOO   SSSSS  IIIII  TTTTT  EEEEE          %

%       C      O   O MM MM  P   P  O   O  SS       I      T    E              %

%       C      O   O M M M  PPPP   O   O   SSS     I      T    EEE            %

%       C      O   O M   M  P      O   O     SS    I      T    E              %

%        CCCC   OOO  M   M  P       OOO   SSSSS  IIIII    T    EEEEE          %

%                                                                             %

%                                                                             %

%                   GraphicsMagick Image Composition Methods                  %

%                                                                             %

%                                                                             %

%                              Software Design                                %

%                                John Cristy                                  %

%                                 July 1992                                   %

%                            Re-design/Re-write                               %

%                              Bob Friesenhahn                                %

%                                  2008                                       %

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%

%

*/

/*

  Include declarations.

*/

#include "magick/studio.h"

#include "magick/alpha_composite.h"

#include "magick/composite.h"

#include "magick/enum_strings.h"

#include "magick/gem.h"

#include "magick/pixel_cache.h"

#include "magick/pixel_iterator.h"

#include "magick/utility.h"

/*

  Structure to pass any necessary options to composition callbacks.

*/

#if 0

typedef struct _CompositeOptions_t

{

  /* Composition operator */

  /* CompositeOperator compose; */

  /* ModulateComposite */

  double            percent_brightness;

  /* ThresholdComposite */

  double            amount;

  double            threshold;

} CompositeOptions_t;

#endif

/*

  Build a PixelPacket representing the canvas pixel.

*/

static inline void

PrepareDestinationPacket(PixelPacket *destination,

                         const PixelPacket * restrict update_pixels,

                         const Image * restrict update_image,

                         const IndexPacket * restrict update_indexes,

                         const long i)

{

  *destination=update_pixels[i];

  if (!update_image->matte)

    destination->opacity=OpaqueOpacity;

  else

    if (update_image->colorspace == CMYKColorspace)

      destination->opacity=update_indexes[i];

}

/*

  Build a PixelPacket representing the update pixel.

*/

static inline void

PrepareSourcePacket(PixelPacket *source,

                    const PixelPacket * restrict source_pixels,

                    const Image * restrict source_image,

                    const IndexPacket * restrict source_indexes,

                    const long i)

{

  *source=source_pixels[i];

  if (!source_image->matte)

    source->opacity=OpaqueOpacity;

  else

    if (source_image->colorspace == CMYKColorspace)

      source->opacity=source_indexes[i];

}

/*

  Apply composition updates to the canvas image.

*/

static inline void

ApplyPacketUpdates(PixelPacket * restrict update_pixels,

                   IndexPacket * restrict update_indexes,

                   const Image * restrict update_image,

                   const PixelPacket * restrict composite,

                   const long i

                   )

{

  if (update_image->colorspace != CMYKColorspace)

    {

      /*

        RGB stores opacity in 'opacity'.

      */

      update_pixels[i]=*composite;

    }

  else

    {

      /*

        CMYK(A) stores K in 'opacity' and A in the indexes.

      */

      update_pixels[i].red=composite->red;

      update_pixels[i].green=composite->green;

      update_pixels[i].blue=composite->blue;

      update_indexes[i]=composite->opacity; /* opacity */

    }

}

static MagickPassFail

OverCompositePixels(void *mutable_data,                /* User provided mutable data */

                    const void *immutable_data,        /* User provided immutable data */

                    const Image * restrict source_image,         /* Source image */

                    const PixelPacket * restrict source_pixels,  /* Pixel row in source image */

                    const IndexPacket * restrict source_indexes, /* Pixel row indexes in source image */

                    Image * restrict update_image,               /* Update image */

                    PixelPacket * restrict update_pixels,        /* Pixel row in update image */

                    IndexPacket * restrict update_indexes,       /* Pixel row indexes in update image */

                    const long npixels,                /* Number of pixels in row */

                    ExceptionInfo *exception           /* Exception report */

                    )

{

  register long

    i;

  PixelPacket

    destination,

    source;

  ARG_NOT_USED(mutable_data);

  ARG_NOT_USED(immutable_data);

  ARG_NOT_USED(exception);

  /*

    The result will be the union of the two image shapes, with

    opaque areas of change-image obscuring base-image in the

    region of overlap.

  */

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

    {

      PrepareSourcePacket(&source,source_pixels,source_image,source_indexes,i);

      PrepareDestinationPacket(&destination,update_pixels,update_image,update_indexes,i);

      AlphaCompositePixel(&destination,&source,source.opacity,&destination,destination.opacity);

      ApplyPacketUpdates(update_pixels,update_indexes,update_image,&destination,i);

    }

  return MagickPass;

}

static MagickPassFail

InCompositePixels(void *mutable_data,                /* User provided mutable data */

                  const void *immutable_data,        /* User provided immutable data */

                  const Image * restrict source_image,         /* Source image */

                  const PixelPacket * restrict source_pixels,  /* Pixel row in source image */

                  const IndexPacket * restrict source_indexes, /* Pixel row indexes in source image */

                  Image * restrict update_image,               /* Update image */

                  PixelPacket * restrict update_pixels,        /* Pixel row in update image */

                  IndexPacket * restrict update_indexes,       /* Pixel row indexes in update image */

                  const long npixels,                /* Number of pixels in row */

                  ExceptionInfo *exception           /* Exception report */

                  )

{

  register long

    i;

  PixelPacket

    destination,

    source;

  ARG_NOT_USED(mutable_data);

  ARG_NOT_USED(immutable_data);

  ARG_NOT_USED(exception);

  /*

    The result is simply change-image cut by the shape of

    base-image. None of the image data of base-image will be

    in the result.

  */

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

    {

      PrepareSourcePacket(&source,source_pixels,source_image,source_indexes,i);

      PrepareDestinationPacket(&destination,update_pixels,update_image,update_indexes,i);

      if (source.opacity == TransparentOpacity)

        {

          destination=source;

        }

      else if (destination.opacity == TransparentOpacity)

        {

        }

      else

        {

          double

            opacity;

          opacity=(double)

            (((double) MaxRGBDouble-source.opacity)*

             (MaxRGBDouble-destination.opacity)/MaxRGBDouble);

          destination.red=(Quantum)

            (((double) MaxRGBDouble-source.opacity)*

             (MaxRGBDouble-destination.opacity)*source.red/MaxRGBDouble/opacity+0.5);

          destination.green=(Quantum)

            (((double) MaxRGBDouble-source.opacity)*

             (MaxRGBDouble-destination.opacity)*source.green/MaxRGBDouble/opacity+0.5);

          destination.blue=(Quantum)

            (((double) MaxRGBDouble-source.opacity)*

             (MaxRGBDouble-destination.opacity)*source.blue/MaxRGBDouble/opacity+0.5);

          destination.opacity=(Quantum) (MaxRGBDouble-opacity+0.5);

        }

      ApplyPacketUpdates(update_pixels,update_indexes,update_image,&destination,i);

    }

  return MagickPass;

}

static MagickPassFail

OutCompositePixels(void *mutable_data,                /* User provided mutable data */

                   const void *immutable_data,        /* User provided immutable data */

                   const Image * restrict source_image,         /* Source image */

                   const PixelPacket * restrict source_pixels,  /* Pixel row in source image */

                   const IndexPacket * restrict source_indexes, /* Pixel row indexes in source image */

                   Image * restrict update_image,               /* Update image */

                   PixelPacket * restrict update_pixels,        /* Pixel row in update image */

                   IndexPacket * restrict update_indexes,       /* Pixel row indexes in update image */

                   const long npixels,                /* Number of pixels in row */

                   ExceptionInfo *exception           /* Exception report */

                   )

{

  register long

    i;

  PixelPacket

    destination,

    source;

  ARG_NOT_USED(mutable_data);

  ARG_NOT_USED(immutable_data);

  ARG_NOT_USED(exception);

  /*

    The resulting image is change-image with the shape of

    base-image cut out.

  */

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

    {

      PrepareSourcePacket(&source,source_pixels,source_image,source_indexes,i);

      PrepareDestinationPacket(&destination,update_pixels,update_image,update_indexes,i);

      if (source.opacity == TransparentOpacity)

        {

          destination=source;

        }

      else if (destination.opacity == OpaqueOpacity)

        {

          destination.opacity=TransparentOpacity;

        }

      else

        {

          double

            opacity;

          opacity=(double)

            (MaxRGBDouble-source.opacity)*destination.opacity/MaxRGBDouble;

          destination.red=(Quantum)

            (((double) MaxRGBDouble-source.opacity)*

             destination.opacity*source.red/MaxRGBDouble/opacity+0.5);

          destination.green=(Quantum)

            (((double) MaxRGBDouble-source.opacity)*

             destination.opacity*source.green/MaxRGBDouble/opacity+0.5);

          destination.blue=(Quantum)

            (((double) MaxRGBDouble-source.opacity)*

             destination.opacity*source.blue/MaxRGBDouble/opacity+0.5);

          destination.opacity=(Quantum) (MaxRGBDouble-opacity+0.5);

        }

      ApplyPacketUpdates(update_pixels,update_indexes,update_image,&destination,i);

    }

  return MagickPass;

}

static MagickPassFail

AtopCompositePixels(void *mutable_data,                /* User provided mutable data */

                    const void *immutable_data,        /* User provided immutable data */

                    const Image * restrict source_image,         /* Source image */

                    const PixelPacket * restrict source_pixels,  /* Pixel row in source image */

                    const IndexPacket * restrict source_indexes, /* Pixel row indexes in source image */

                    Image * restrict update_image,               /* Update image */

                    PixelPacket * restrict update_pixels,        /* Pixel row in update image */

                    IndexPacket * restrict update_indexes,       /* Pixel row indexes in update image */

                    const long npixels,                /* Number of pixels in row */

                    ExceptionInfo *exception           /* Exception report */

                    )

{

  register long

    i;

  PixelPacket

    destination,

    source;

  ARG_NOT_USED(mutable_data);

  ARG_NOT_USED(immutable_data);

  ARG_NOT_USED(exception);

  /*

    The result is the same shape as base-image, with

    change-image obscuring base-image where the image shapes

    overlap. Note this differs from over because the portion

    of change-image outside base-image's shape does not appear

    in the result.

  */

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

    {

      PrepareSourcePacket(&source,source_pixels,source_image,source_indexes,i);

      PrepareDestinationPacket(&destination,update_pixels,update_image,update_indexes,i);

      AtopCompositePixel(&destination,&destination,&source);

      ApplyPacketUpdates(update_pixels,update_indexes,update_image,&destination,i);

    }

  return MagickPass;

}

static MagickPassFail

XorCompositePixels(void *mutable_data,                /* User provided mutable data */

                   const void *immutable_data,        /* User provided immutable data */

                   const Image * restrict source_image,         /* Source image */

                   const PixelPacket * restrict source_pixels,  /* Pixel row in source image */

                   const IndexPacket * restrict source_indexes, /* Pixel row indexes in source image */

                   Image * restrict update_image,               /* Update image */

                   PixelPacket * restrict update_pixels,        /* Pixel row in update image */

                   IndexPacket * restrict update_indexes,       /* Pixel row indexes in update image */

                   const long npixels,                /* Number of pixels in row */

                   ExceptionInfo *exception           /* Exception report */

                   )

{

  register long

    i;

  PixelPacket

    destination,

    source;

  ARG_NOT_USED(mutable_data);

  ARG_NOT_USED(immutable_data);

  ARG_NOT_USED(exception);

  /*

    The result is the image data from both change-image and

    base-image that is outside the overlap region. The overlap

    region will be blank.

  */

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

    {

      double gamma;

      double source_alpha;

      double dest_alpha;

      double composite;

      PrepareSourcePacket(&source,source_pixels,source_image,source_indexes,i);

      PrepareDestinationPacket(&destination,update_pixels,update_image,update_indexes,i);

      source_alpha=(double) source.opacity/MaxRGBDouble;

      dest_alpha=(double) destination.opacity/MaxRGBDouble;

      gamma=(1.0-source_alpha)+(1.0-dest_alpha)-

        2.0*(1.0-source_alpha)*(1.0-dest_alpha);

      composite=MaxRGBDouble*(1.0-gamma);

      destination.opacity=RoundDoubleToQuantum(composite);

      gamma=1.0/(gamma <= MagickEpsilon ? 1.0 : gamma);

      composite=((1.0-source_alpha)*source.red*dest_alpha+

                 (1.0-dest_alpha)*destination.red*source_alpha)*gamma;

      destination.red=RoundDoubleToQuantum(composite);

      composite=((1.0-source_alpha)*source.green*dest_alpha+

                 (1.0-dest_alpha)*destination.green*source_alpha)*gamma;

      destination.green=RoundDoubleToQuantum(composite);

      composite=((1.0-source_alpha)*source.blue*dest_alpha+

                 (1.0-dest_alpha)*destination.blue*source_alpha)*gamma;

      destination.blue=RoundDoubleToQuantum(composite);

      ApplyPacketUpdates(update_pixels,update_indexes,update_image,&destination,i);

    }

  return MagickPass;

}

static MagickPassFail

PlusCompositePixels(void *mutable_data,                /* User provided mutable data */

                    const void *immutable_data,        /* User provided immutable data */

                    const Image * restrict source_image,         /* Source image */

                    const PixelPacket * restrict source_pixels,  /* Pixel row in source image */

                    const IndexPacket * restrict source_indexes, /* Pixel row indexes in source image */

                    Image * restrict update_image,               /* Update image */

                    PixelPacket * restrict update_pixels,        /* Pixel row in update image */

                    IndexPacket * restrict update_indexes,       /* Pixel row indexes in update image */

                    const long npixels,                /* Number of pixels in row */

                    ExceptionInfo *exception           /* Exception report */

                    )

{

  register long

    i;

  PixelPacket

    destination,

    source;

  ARG_NOT_USED(mutable_data);

  ARG_NOT_USED(immutable_data);

  ARG_NOT_USED(exception);

  /*

    The result is just the sum of the image data. Output values are

    cropped to MaxRGB (no overflow). This operation is independent of

    the matte channels.

  */

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

    {

      double

        value;

      PrepareSourcePacket(&source,source_pixels,source_image,source_indexes,i);

      PrepareDestinationPacket(&destination,update_pixels,update_image,update_indexes,i);

      value=((double) (MaxRGBDouble-source.opacity)*source.red+(double)

                 (MaxRGBDouble-destination.opacity)*destination.red)/MaxRGBDouble;

      destination.red=RoundDoubleToQuantum(value);

      value=((double) (MaxRGBDouble-source.opacity)*source.green+(double)

                   (MaxRGBDouble-destination.opacity)*destination.green)/MaxRGBDouble;

      destination.green=RoundDoubleToQuantum(value);

      value=((double) (MaxRGBDouble-source.opacity)*source.blue+(double)

                  (MaxRGBDouble-destination.opacity)*destination.blue)/MaxRGBDouble;

      destination.blue=RoundDoubleToQuantum(value);

      value=((double) (MaxRGBDouble-source.opacity)+

                     (double) (MaxRGBDouble-destination.opacity))/MaxRGBDouble;

      destination.opacity=MaxRGB-RoundDoubleToQuantum(value);

      ApplyPacketUpdates(update_pixels,update_indexes,update_image,&destination,i);

    }

  return MagickPass;

}

static MagickPassFail

MinusCompositePixels(void *mutable_data,                /* User provided mutable data */

                     const void *immutable_data,        /* User provided immutable data */

                     const Image * restrict source_image,         /* Source image */

                     const PixelPacket * restrict source_pixels,  /* Pixel row in source image */

                     const IndexPacket * restrict source_indexes, /* Pixel row indexes in source image */

                     Image * restrict update_image,               /* Update image */

                     PixelPacket * restrict update_pixels,        /* Pixel row in update image */

                     IndexPacket * restrict update_indexes,       /* Pixel row indexes in update image */

                     const long npixels,                /* Number of pixels in row */

                     ExceptionInfo *exception           /* Exception report */

                     )

{

  register long

    i;

  PixelPacket

    destination,

    source;

  ARG_NOT_USED(mutable_data);

  ARG_NOT_USED(immutable_data);

  ARG_NOT_USED(exception);

  /*

    The result of change-image - base-image, with underflow cropped to

    zero. The matte channel is ignored (set to opaque, full coverage).

  */

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

    {

      double

        value;

      PrepareSourcePacket(&source,source_pixels,source_image,source_indexes,i);

      PrepareDestinationPacket(&destination,update_pixels,update_image,update_indexes,i);

      value=((double) (MaxRGBDouble-destination.opacity)*destination.red-

             (double) (MaxRGBDouble-source.opacity)*source.red)/MaxRGBDouble;

      destination.red=RoundDoubleToQuantum(value);

      value=((double) (MaxRGBDouble-destination.opacity)*destination.green-

             (double) (MaxRGBDouble-source.opacity)*source.green)/MaxRGBDouble;

      destination.green=RoundDoubleToQuantum(value);

      value=((double) (MaxRGBDouble-destination.opacity)*destination.blue-

             (double) (MaxRGBDouble-source.opacity)*source.blue)/MaxRGBDouble;

      destination.blue=RoundDoubleToQuantum(value);

      value=((double) (MaxRGBDouble-destination.opacity)-

             (double) (MaxRGBDouble-source.opacity))/MaxRGBDouble;

      destination.opacity=MaxRGB-RoundDoubleToQuantum(value);

      ApplyPacketUpdates(update_pixels,update_indexes,update_image,&destination,i);

    }

  return MagickPass;

}

static MagickPassFail

AddCompositePixels(void *mutable_data,                /* User provided mutable data */

                   const void *immutable_data,        /* User provided immutable data */

                   const Image * restrict source_image,         /* Source image */

                   const PixelPacket * restrict source_pixels,  /* Pixel row in source image */

                   const IndexPacket * restrict source_indexes, /* Pixel row indexes in source image */

                   Image * restrict update_image,               /* Update image */

                   PixelPacket * restrict update_pixels,        /* Pixel row in update image */

                   IndexPacket * restrict update_indexes,       /* Pixel row indexes in update image */

                   const long npixels,                /* Number of pixels in row */

                   ExceptionInfo *exception           /* Exception report */

                   )

{

  register long

    i;

  PixelPacket

    destination,

    source;

  ARG_NOT_USED(mutable_data);

  ARG_NOT_USED(immutable_data);

  ARG_NOT_USED(exception);

  /*

    The result of change-image + base-image, with overflow wrapping

    around (mod MaxRGB+1).

  */

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

    {

      double

        value;

      PrepareSourcePacket(&source,source_pixels,source_image,source_indexes,i);

      PrepareDestinationPacket(&destination,update_pixels,update_image,update_indexes,i);

      value=(double) source.red+destination.red;

      if (value > MaxRGBDouble) value -= ((double) MaxRGBDouble+1.0);

      destination.red=RoundDoubleToQuantum(value);

      value=(double) source.green+destination.green;

      if (value > MaxRGBDouble) value -= ((double) MaxRGBDouble+1.0);

      destination.green=RoundDoubleToQuantum(value);

      value=(double) source.blue+destination.blue;

      if (value > MaxRGBDouble) value -= ((double) MaxRGBDouble+1.0);

      destination.blue=RoundDoubleToQuantum(value);

      destination.opacity=OpaqueOpacity;

      ApplyPacketUpdates(update_pixels,update_indexes,update_image,&destination,i);

    }

  return MagickPass;

}

static MagickPassFail

SubtractCompositePixels(void *mutable_data,                /* User provided mutable data */

                        const void *immutable_data,        /* User provided immutable data */

                        const Image * restrict source_image,         /* Source image */

                        const PixelPacket * restrict source_pixels,  /* Pixel row in source image */

                        const IndexPacket * restrict source_indexes, /* Pixel row indexes in source image */

                        Image * restrict update_image,               /* Update image */

                        PixelPacket * restrict update_pixels,        /* Pixel row in update image */

                        IndexPacket * restrict update_indexes,       /* Pixel row indexes in update image */

                        const long npixels,                /* Number of pixels in row */

                        ExceptionInfo *exception           /* Exception report */

                        )

{

  register long

    i;

  PixelPacket

    destination,

    source;

  ARG_NOT_USED(mutable_data);

  ARG_NOT_USED(immutable_data);

  ARG_NOT_USED(exception);

  /*

    The result of change-image - base-image, with underflow wrapping

    around (mod MaxRGB+1). The add and subtract operators can be used

    to perform reversible transformations.

  */

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

    {

      double

        value;

      PrepareSourcePacket(&source,source_pixels,source_image,source_indexes,i);

      PrepareDestinationPacket(&destination,update_pixels,update_image,update_indexes,i);

      value=(double) source.red-destination.red;

      if (value < 0) value += ((double) MaxRGBDouble+1.0);

      destination.red=RoundDoubleToQuantum(value);

      value=(double) source.green-destination.green;

      if (value < 0) value += ((double) MaxRGBDouble+1.0);

      destination.green=RoundDoubleToQuantum(value);

      value=(double) source.blue-destination.blue;

      if (value < 0) value += ((double) MaxRGBDouble+1.0);

      destination.blue=RoundDoubleToQuantum(value);

      destination.opacity=OpaqueOpacity;

      ApplyPacketUpdates(update_pixels,update_indexes,update_image,&destination,i);

    }

  return MagickPass;

}

static MagickPassFail

DifferenceCompositePixels(void *mutable_data,                /* User provided mutable data */

                          const void *immutable_data,        /* User provided immutable data */

                          const Image * restrict source_image,         /* Source image */

                          const PixelPacket * restrict source_pixels,  /* Pixel row in source image */

                          const IndexPacket * restrict source_indexes, /* Pixel row indexes in source image */

                          Image * restrict update_image,               /* Update image */

                          PixelPacket * restrict update_pixels,        /* Pixel row in update image */

                          IndexPacket * restrict update_indexes,       /* Pixel row indexes in update image */

                          const long npixels,                /* Number of pixels in row */

                          ExceptionInfo *exception           /* Exception report */

                          )

{

  register long

    i;

  PixelPacket

    destination,

    source;

  ARG_NOT_USED(mutable_data);

  ARG_NOT_USED(immutable_data);

  ARG_NOT_USED(exception);

  /*

    The result of abs(change-image - base-image). This is useful for

    comparing two very similar images.

  */

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

    {

      double gamma;

      double source_alpha;

      double dest_alpha;

      double composite;

      PrepareSourcePacket(&source,source_pixels,source_image,source_indexes,i);

      PrepareDestinationPacket(&destination,update_pixels,update_image,update_indexes,i);

      source_alpha=(double) source.opacity/MaxRGBDouble;

      dest_alpha=(double) destination.opacity/MaxRGBDouble;

      gamma=(1.0-source_alpha)+(1.0-dest_alpha)-

        (1.0-source_alpha)*(1.0-dest_alpha);

      gamma=gamma < 0.0 ? 0.0 : (gamma > 1.0) ? 1.0 : gamma;

      composite=MaxRGBDouble*(1.0-gamma);

      destination.opacity=RoundDoubleToQuantum(composite);

      gamma=1.0/(fabs(gamma) < MagickEpsilon ? MagickEpsilon : gamma);

      composite=(fabs((double)source.red - (double)destination.red)*

                 (1.0-source_alpha)*(1.0-dest_alpha)+

                 source.red*(1.0-source_alpha)*dest_alpha+

                 destination.red*(1.0-dest_alpha)*source_alpha)*gamma;

      destination.red=RoundDoubleToQuantum(composite);

      composite=(fabs((double)source.green - (double)destination.green)*

                 (1.0-source_alpha)*(1.0-dest_alpha)+

                 source.green*(1.0-source_alpha)*dest_alpha+

                 destination.green*(1.0-dest_alpha)*source_alpha)*gamma;

      destination.green=RoundDoubleToQuantum(composite);

      composite=(fabs((double)source.blue - (double)destination.blue)*

                 (1.0-source_alpha)*(1.0-dest_alpha)+

                 source.blue*(1.0-source_alpha)*dest_alpha+

                 destination.blue*(1.0-dest_alpha)*source_alpha)*gamma;

      destination.blue=RoundDoubleToQuantum(composite);

      ApplyPacketUpdates(update_pixels,update_indexes,update_image,&destination,i);

    }

  return MagickPass;

}

static MagickPassFail

MultiplyCompositePixels(void *mutable_data,                /* User provided mutable data */

                        const void *immutable_data,        /* User provided immutable data */

                        const Image * restrict source_image,         /* Source image */

                        const PixelPacket * restrict source_pixels,  /* Pixel row in source image */

                        const IndexPacket * restrict source_indexes, /* Pixel row indexes in source image */

                        Image * restrict update_image,               /* Update image */

                        PixelPacket * restrict update_pixels,        /* Pixel row in update image */

                        IndexPacket * restrict update_indexes,       /* Pixel row indexes in update image */

                        const long npixels,                /* Number of pixels in row */

                        ExceptionInfo *exception           /* Exception report */

                        )

{

  register long

    i;

  PixelPacket

    destination,

    source;

  ARG_NOT_USED(mutable_data);

  ARG_NOT_USED(immutable_data);

  ARG_NOT_USED(exception);

  /*

    The result of change-image * base-image. This is useful for the

    creation of drop-shadows.

  */

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

    {

      double gamma;

      double source_alpha;

      double dest_alpha;

      double composite;

      PrepareSourcePacket(&source,source_pixels,source_image,source_indexes,i);

      PrepareDestinationPacket(&destination,update_pixels,update_image,update_indexes,i);

      source_alpha=(double) source.opacity/MaxRGBDouble;

      dest_alpha=(double) destination.opacity/MaxRGBDouble;

      gamma=(1.0-source_alpha)+(1.0-dest_alpha)-

        (1.0-source_alpha)*(1.0-dest_alpha);

      gamma=gamma < 0.0 ? 0.0 : (gamma > 1.0) ? 1.0 : gamma;

      composite=MaxRGBDouble*(1.0-gamma);

      destination.opacity=RoundDoubleToQuantum(composite);

      gamma=1.0/(fabs(gamma) < MagickEpsilon ? MagickEpsilon : gamma);

      composite=(((double)source.red*(1.0-source_alpha)*

                  (double)destination.red*(1.0-dest_alpha))/MaxRGBDouble+

                 source.red*(1.0-source_alpha)*dest_alpha+

                 destination.red*(1.0-dest_alpha)*source_alpha)*gamma;

      destination.red=RoundDoubleToQuantum(composite);

      composite=(((double)source.green*(1.0-source_alpha)*

                  (double)destination.green*(1.0-dest_alpha))/MaxRGBDouble+

                 source.green*(1.0-source_alpha)*dest_alpha+

                 destination.green*(1.0-dest_alpha)*source_alpha)*gamma;

      destination.green=RoundDoubleToQuantum(composite);

      composite=(((double)source.blue*(1.0-source_alpha)*

                  (double)destination.blue*(1.0-dest_alpha))/MaxRGBDouble+

                 source.blue*(1.0-source_alpha)*dest_alpha+

                 destination.blue*(1.0-dest_alpha)*source_alpha)*gamma;

      destination.blue=RoundDoubleToQuantum(composite);

      ApplyPacketUpdates(update_pixels,update_indexes,update_image,&destination,i);

    }

  return MagickPass;

}

static MagickPassFail

BumpmapCompositePixels(void *mutable_data,                /* User provided mutable data */

                       const void *immutable_data,        /* User provided immutable data */

                       const Image * restrict source_image,         /* Source image */

                       const PixelPacket * restrict source_pixels,  /* Pixel row in source image */

                       const IndexPacket * restrict source_indexes, /* Pixel row indexes in source image */

                       Image * restrict update_image,               /* Update image */

                       PixelPacket * restrict update_pixels,        /* Pixel row in update image */

                       IndexPacket * restrict update_indexes,       /* Pixel row indexes in update image */

                       const long npixels,                /* Number of pixels in row */

                       ExceptionInfo *exception           /* Exception report */

                       )

{

  register long

    i;

  PixelPacket

    destination,

    source;

  ARG_NOT_USED(mutable_data);

  ARG_NOT_USED(immutable_data);

  ARG_NOT_USED(exception);

  /*

    The result base-image shaded by change-image.

  */

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

    {

      double value;

      double source_intensity;

      PrepareSourcePacket(&source,source_pixels,source_image,source_indexes,i);

      PrepareDestinationPacket(&destination,update_pixels,update_image,update_indexes,i);

      source_intensity=(double) PixelIntensity(&source)/MaxRGBDouble;

      value=source_intensity*destination.red;

      destination.red=RoundDoubleToQuantum(value);

      value=source_intensity*destination.green;

      destination.green=RoundDoubleToQuantum(value);

      value=source_intensity*destination.blue;

      destination.blue=RoundDoubleToQuantum(value);

      value=source_intensity*destination.opacity;

      destination.opacity=RoundDoubleToQuantum(value);

      ApplyPacketUpdates(update_pixels,update_indexes,update_image,&destination,i);

    }

  return MagickPass;

}

static MagickPassFail

CopyCompositePixels(void *mutable_data,                /* User provided mutable data */

                    const void *immutable_data,        /* User provided immutable data */

                    const Image * restrict source_image,         /* Source image */

                    const PixelPacket * restrict source_pixels,  /* Pixel row in source image */

                    const IndexPacket * restrict source_indexes, /* Pixel row indexes in source image */

                    Image * restrict update_image,               /* Update image */

                    PixelPacket * restrict update_pixels,        /* Pixel row in update image */

                    IndexPacket * restrict update_indexes,       /* Pixel row indexes in update image */

                    const long npixels,                /* Number of pixels in row */

                    ExceptionInfo *exception           /* Exception report */

                    )

{

  ARG_NOT_USED(mutable_data);

  ARG_NOT_USED(immutable_data);

  ARG_NOT_USED(exception);

  /*

    The resulting image is base-image replaced with change-image. Here

    the matte information is ignored.

  */

  if ((update_image->colorspace == CMYKColorspace) &&

      (update_image->matte))

    {

      if (source_image->matte)

        {

          (void) memcpy(update_pixels,source_pixels,npixels*sizeof(PixelPacket));

          (void) memcpy(update_indexes,source_indexes,npixels*sizeof(IndexPacket));

        }

      else

        {

          (void) memcpy(update_pixels,source_pixels,npixels*sizeof(PixelPacket));

          (void) memset(update_indexes,OpaqueOpacity,npixels*sizeof(IndexPacket));

        }

    }

  else

    {

      (void) memcpy(update_pixels,source_pixels,npixels*sizeof(PixelPacket));

    }

  return MagickPass;

}

static MagickPassFail

CopyRedCompositePixels(void *mutable_data,                /* User provided mutable data */

                       const void *immutable_data,        /* User provided immutable data */

                       const Image *source_image,         /* Source image */

                       const PixelPacket *source_pixels,  /* Pixel row in source image */

                       const IndexPacket *source_indexes, /* Pixel row indexes in source image */

                       Image *update_image,               /* Update image */

                       PixelPacket *update_pixels,        /* Pixel row in update image */

                       IndexPacket *update_indexes,       /* Pixel row indexes in update image */

                       const long npixels,                /* Number of pixels in row */

                       ExceptionInfo *exception           /* Exception report */