(no commit message)

[imagemagick] / MagickCore / pixel-accessor.h

diff --git a/MagickCore/pixel-accessor.h b/MagickCore/pixel-accessor.h
index bab1ef04b10f069d53ee257244186e2fde06aa92..d6054083ee1a37ba91a086dba01f89d496f23cad 100644 (file)
--- a/MagickCore/pixel-accessor.h
+++ b/MagickCore/pixel-accessor.h
@@ -1,5 +1,5 @@
 /*
-  Copyright 1999-2012 ImageMagick Studio LLC, a non-profit organization
+  Copyright 1999-2014 ImageMagick Studio LLC, a non-profit organization
   dedicated to making software imaging solutions freely available.
 
   You may not use this file except in compliance with the License.
@@ -18,18 +18,25 @@
 #ifndef _MAGICKCORE_PIXEL_ACCESSOR_H
 #define _MAGICKCORE_PIXEL_ACCESSOR_H
 
+#include "MagickCore/cache.h"
+#include "MagickCore/cache-view.h"
+#include "MagickCore/color.h"
+#include "MagickCore/colorspace.h"
+#include "MagickCore/gem.h"
+#include "MagickCore/image.h"
+
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
 #endif
 
-#include <math.h>
-#include <MagickCore/cache.h>
-#include <MagickCore/cache-view.h>
-#include <MagickCore/color.h>
-#include <MagickCore/image.h>
-
 #undef index
 
+static inline Quantum GetPixela(const Image *restrict image,
+  const Quantum *restrict pixel)
+{
+  return(pixel[image->channel_map[aPixelChannel].offset]);
+}
+
 static inline Quantum GetPixelAlpha(const Image *restrict image,
   const Quantum *restrict pixel)
 {
@@ -43,11 +50,17 @@ static inline PixelTrait GetPixelAlphaTraits(const Image *restrict image)
   return(image->channel_map[AlphaPixelChannel].traits);
 }
 
+static inline Quantum GetPixelb(const Image *restrict image,
+  const Quantum *restrict pixel)
+{
+  return(pixel[image->channel_map[bPixelChannel].offset]);
+}
+
 static inline Quantum GetPixelBlack(const Image *restrict image,
   const Quantum *restrict pixel)
 {
   if (image->channel_map[BlackPixelChannel].traits == UndefinedPixelTrait)
-    return(0);
+    return((Quantum) 0);
   return(pixel[image->channel_map[BlackPixelChannel].offset]);
 }
 
@@ -82,23 +95,23 @@ static inline Quantum GetPixelChannel(const Image *restrict image,
   const PixelChannel channel,const Quantum *restrict pixel)
 {
   if (image->channel_map[channel].traits == UndefinedPixelTrait)
-    return(0);
+    return((Quantum) 0);
   return(pixel[image->channel_map[channel].offset]);
 }
 
-static inline PixelChannel GetPixelChannelMapChannel(
-  const Image *restrict image,const ssize_t offset)
+static inline PixelChannel GetPixelChannelChannel(const Image *restrict image,
+  const ssize_t offset)
 {
   return(image->channel_map[offset].channel);
 }
 
-static inline ssize_t GetPixelChannelMapOffset(const Image *restrict image,
+static inline ssize_t GetPixelChannelOffset(const Image *restrict image,
   const PixelChannel channel)
 {
   return(image->channel_map[channel].offset);
 }
 
-static inline PixelTrait GetPixelChannelMapTraits(const Image *restrict image,
+static inline PixelTrait GetPixelChannelTraits(const Image *restrict image,
   const PixelChannel channel)
 {
   return(image->channel_map[channel].traits);
@@ -157,7 +170,7 @@ static inline Quantum GetPixelIndex(const Image *restrict image,
   const Quantum *restrict pixel)
 {
   if (image->channel_map[IndexPixelChannel].traits == UndefinedPixelTrait)
-    return(0);
+    return((Quantum) 0);
   return(pixel[image->channel_map[IndexPixelChannel].offset]);
 }
 
@@ -166,74 +179,102 @@ static inline PixelTrait GetPixelIndexTraits(const Image *restrict image)
   return(image->channel_map[IndexPixelChannel].traits);
 }
 
-static inline Quantum GetPixelInfoIntensity(
-  const PixelInfo *restrict pixel_info)
+static inline MagickRealType GetPixelInfoChannel(
+  const PixelInfo *restrict pixel_info,const PixelChannel channel)
 {
-#if !defined(MAGICKCORE_HDRI_SUPPORT)
-  return((Quantum) (0.299*pixel_info->red+0.587*pixel_info->green+0.114*
-    pixel_info->blue+0.5));
-#else
-  return((Quantum) (0.299*pixel_info->red+0.587*pixel_info->green+0.114*
-    pixel_info->blue));
-#endif
+  switch (channel)
+  {
+    case RedPixelChannel: return(pixel_info->red);
+    case GreenPixelChannel: return(pixel_info->green);
+    case BluePixelChannel: return(pixel_info->blue);
+    case BlackPixelChannel: return(pixel_info->black);
+    case AlphaPixelChannel: return(pixel_info->alpha);
+    case IndexPixelChannel: return(pixel_info->index);
+    default: return((MagickRealType) 0.0);
+  }
 }
 
-static inline Quantum GetPixelInfoLuminance(
+static inline MagickRealType GetPixelInfoIntensity(
   const PixelInfo *restrict pixel_info)
 {
-  Quantum
-    luminance;
+  if (pixel_info->colorspace == GRAYColorspace)
+    return(pixel_info->red);
+  return(0.212656*pixel_info->red+0.715158*pixel_info->green+0.072186*
+    pixel_info->blue);
+}
 
-#if !defined(MAGICKCORE_HDRI_SUPPORT)
-  luminance=(Quantum) (0.21267*pixel_info->red+0.71516*pixel_info->green+
-    0.07217*pixel_info->blue+0.5);
-#else
-  luminance=(Quantum) (0.21267*pixel_info->red+0.71516*pixel_info->green+
-    0.07217*pixel_info->blue);
-#endif
-  return((Quantum) luminance);
+static inline MagickRealType GetPixelInfoLuma(const PixelInfo *restrict pixel)
+{
+  MagickRealType
+    blue,
+    green,
+    red;
+
+  if (pixel->colorspace == GRAYColorspace)
+    return(pixel->red);
+  if (pixel->colorspace == sRGBColorspace)
+    return(0.212656*pixel->red+0.715158*pixel->green+0.072186*pixel->blue);
+  red=EncodePixelGamma(pixel->red);
+  green=EncodePixelGamma(pixel->green);
+  blue=EncodePixelGamma(pixel->blue);
+  return(0.212656*red+0.715158*green+0.072186*blue);
 }
 
-static inline Quantum GetPixelIntensity(const Image *restrict image,
+static inline MagickRealType GetPixelInfoLuminance(
+  const PixelInfo *restrict pixel)
+{
+  MagickRealType
+    blue,
+    green,
+    red;
+
+  if (pixel->colorspace == GRAYColorspace)
+    return(pixel->red);
+  if (pixel->colorspace != sRGBColorspace)
+    return(0.212656*pixel->red+0.715158*pixel->green+0.072186*pixel->blue);
+  red=DecodePixelGamma(pixel->red);
+  green=DecodePixelGamma(pixel->green);
+  blue=DecodePixelGamma(pixel->blue);
+  return(0.212656*red+0.715158*green+0.072186*blue);
+}
+
+static inline Quantum GetPixelL(const Image *restrict image,
+  const Quantum *restrict pixel)
+{
+  return(pixel[image->channel_map[LPixelChannel].offset]);
+}
+
+static inline MagickRealType GetPixelLuma(const Image *restrict image,
   const Quantum *restrict pixel)
 {
-#if !defined(MAGICKCORE_HDRI_SUPPORT)
   if (image->colorspace == GRAYColorspace)
-    return(pixel[image->channel_map[GrayPixelChannel].offset]);
-  return((Quantum) (0.299*pixel[image->channel_map[RedPixelChannel].offset]+
-    0.587*pixel[image->channel_map[GreenPixelChannel].offset]+0.114*
-    pixel[image->channel_map[BluePixelChannel].offset]+0.5));
-#else
-  {
-    double
-      alpha,
-      beta;
-
-    alpha=pixel[image->channel_map[RedPixelChannel].offset]-(double)
-      pixel[image->channel_map[GreenPixelChannel].offset];
-    beta=pixel[image->channel_map[GreenPixelChannel].offset]-(double)
-      pixel[image->channel_map[BluePixelChannel].offset];
-    if ((fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
-      return(pixel[image->channel_map[RedPixelChannel].offset]);
-    return((Quantum) (0.299*pixel[image->channel_map[RedPixelChannel].offset]+
-      0.587*pixel[image->channel_map[GreenPixelChannel].offset]+0.114*
-      pixel[image->channel_map[BluePixelChannel].offset]));
-  }
-#endif
+    return((MagickRealType) pixel[image->channel_map[GrayPixelChannel].offset]);
+  return(0.212656f*pixel[image->channel_map[RedPixelChannel].offset]+
+    0.715158f*pixel[image->channel_map[GreenPixelChannel].offset]+
+    0.072186f*pixel[image->channel_map[BluePixelChannel].offset]);  /* Rec709 */
 }
 
-static inline Quantum GetPixelLuminance(const Image *restrict image,
+static inline MagickRealType GetPixelLuminance(const Image *restrict image,
   const Quantum *restrict pixel)
 {
-#if !defined(MAGICKCORE_HDRI_SUPPORT)
-  return((Quantum) (0.21267*pixel[image->channel_map[RedPixelChannel].offset]+
-    0.71516*pixel[image->channel_map[GreenPixelChannel].offset]+0.07217*
-    pixel[image->channel_map[BluePixelChannel].offset]+0.5));
-#else
-  return((Quantum) (0.21267*pixel[image->channel_map[RedPixelChannel].offset]+
-    0.71516*pixel[image->channel_map[GreenPixelChannel].offset]+0.07217*
-    pixel[image->channel_map[BluePixelChannel].offset]));
-#endif
+  MagickRealType
+    blue,
+    green,
+    red;
+
+  if (image->colorspace == GRAYColorspace)
+    return((MagickRealType) pixel[image->channel_map[GrayPixelChannel].offset]);
+  if (image->colorspace != sRGBColorspace)
+    return(0.212656*pixel[image->channel_map[RedPixelChannel].offset]+
+      0.715158*pixel[image->channel_map[GreenPixelChannel].offset]+
+      0.072186*pixel[image->channel_map[BluePixelChannel].offset]);
+  red=DecodePixelGamma((MagickRealType)
+    pixel[image->channel_map[RedPixelChannel].offset]);
+  green=DecodePixelGamma((MagickRealType)
+    pixel[image->channel_map[GreenPixelChannel].offset]);
+  blue=DecodePixelGamma((MagickRealType)
+    pixel[image->channel_map[BluePixelChannel].offset]);
+  return(0.212656*red+0.715158*green+0.072186*blue);  /* Rec709 */
 }
 
 static inline Quantum GetPixelMagenta(const Image *restrict image,
@@ -247,17 +288,25 @@ static inline PixelTrait GetPixelMagentaTraits(const Image *restrict image)
   return(image->channel_map[MagentaPixelChannel].traits);
 }
 
-static inline Quantum GetPixelMask(const Image *restrict image,
+static inline Quantum GetPixelReadMask(const Image *restrict image,
+  const Quantum *restrict pixel)
+{
+  if (image->channel_map[ReadMaskPixelChannel].traits == UndefinedPixelTrait)
+    return((Quantum) QuantumRange);
+  return(pixel[image->channel_map[ReadMaskPixelChannel].offset]);
+}
+
+static inline Quantum GetPixelWriteMask(const Image *restrict image,
   const Quantum *restrict pixel)
 {
-  if (image->channel_map[MaskPixelChannel].traits == UndefinedPixelTrait)
-    return(0);
-  return(pixel[image->channel_map[MaskPixelChannel].offset]);
+  if (image->channel_map[WriteMaskPixelChannel].traits == UndefinedPixelTrait)
+    return((Quantum) QuantumRange);
+  return(pixel[image->channel_map[WriteMaskPixelChannel].offset]);
 }
 
-static inline PixelTrait GetPixelMaskTraits(const Image *restrict image)
+static inline PixelTrait GetPixelReadMaskTraits(const Image *restrict image)
 {
-  return(image->channel_map[MaskPixelChannel].traits);
+  return(image->channel_map[ReadMaskPixelChannel].traits);
 }
 
 static inline size_t GetPixelMetaChannels(const Image *restrict image)
@@ -298,15 +347,15 @@ static inline void GetPixelInfoPixel(const Image *restrict image,
     pixel[image->channel_map[GreenPixelChannel].offset];
   pixel_info->blue=(MagickRealType)
     pixel[image->channel_map[BluePixelChannel].offset];
-  pixel_info->black=0;
+  pixel_info->black=0.0f;
   if (image->channel_map[BlackPixelChannel].traits != UndefinedPixelTrait)
     pixel_info->black=(MagickRealType)
       pixel[image->channel_map[BlackPixelChannel].offset];
-  pixel_info->alpha=OpaqueAlpha;
+  pixel_info->alpha=(MagickRealType) OpaqueAlpha;
   if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
     pixel_info->alpha=(MagickRealType)
       pixel[image->channel_map[AlphaPixelChannel].offset];
-  pixel_info->index=0;
+  pixel_info->index=0.0f;
   if (image->channel_map[IndexPixelChannel].traits != UndefinedPixelTrait)
     pixel_info->index=(MagickRealType)
       pixel[image->channel_map[IndexPixelChannel].offset];
@@ -340,12 +389,41 @@ static inline PixelTrait GetPixelYellowTraits(const Image *restrict image)
   return(image->channel_map[YellowPixelChannel].traits);
 }
 
+static inline MagickRealType AbsolutePixelValue(const MagickRealType x)
+{
+  return(x < 0.0f ? -x : x);
+}
+
+static inline MagickBooleanType IsPixelAtDepth(const Quantum pixel,
+  const QuantumAny range)
+{
+  Quantum
+    quantum;
+
+#if !defined(MAGICKCORE_HDRI_SUPPORT)
+  quantum=(Quantum) (((MagickRealType) QuantumRange*((QuantumAny) 
+    (((MagickRealType) range*pixel)/QuantumRange+0.5)))/range+0.5);
+#else
+  quantum=(Quantum) (((MagickRealType) QuantumRange*((QuantumAny) 
+    (((MagickRealType) range*pixel)/QuantumRange+0.5)))/range);
+#endif
+  return(pixel == quantum ? MagickTrue : MagickFalse);
+}
+
 static inline MagickBooleanType IsPixelEquivalent(const Image *restrict image,
   const Quantum *restrict p,const PixelInfo *restrict q)
 {
-  if (((double) p[image->channel_map[RedPixelChannel].offset] == q->red) &&
-      ((double) p[image->channel_map[GreenPixelChannel].offset] == q->green) &&
-      ((double) p[image->channel_map[BluePixelChannel].offset] == q->blue))
+  MagickRealType
+    blue,
+    green,
+    red;
+
+  red=(MagickRealType) p[image->channel_map[RedPixelChannel].offset];
+  green=(MagickRealType) p[image->channel_map[GreenPixelChannel].offset];
+  blue=(MagickRealType) p[image->channel_map[BluePixelChannel].offset];
+  if ((AbsolutePixelValue(red-q->red) < MagickEpsilon) &&
+      (AbsolutePixelValue(green-q->green) < MagickEpsilon) &&
+      (AbsolutePixelValue(blue-q->blue) < MagickEpsilon))
     return(MagickTrue);
   return(MagickFalse);
 }
@@ -353,52 +431,47 @@ static inline MagickBooleanType IsPixelEquivalent(const Image *restrict image,
 static inline MagickBooleanType IsPixelGray(const Image *restrict image,
   const Quantum *restrict pixel)
 {
-#if !defined(MAGICKCORE_HDRI_SUPPORT)
-  if ((pixel[image->channel_map[RedPixelChannel].offset] ==
-       pixel[image->channel_map[GreenPixelChannel].offset]) &&
-      (pixel[image->channel_map[GreenPixelChannel].offset] ==
-       pixel[image->channel_map[BluePixelChannel].offset]))
+  MagickRealType
+    blue,
+    green,
+    red;
+
+  red=(MagickRealType) pixel[image->channel_map[RedPixelChannel].offset];
+  green=(MagickRealType) pixel[image->channel_map[GreenPixelChannel].offset];
+  blue=(MagickRealType) pixel[image->channel_map[BluePixelChannel].offset];
+  if ((AbsolutePixelValue(red-green) < MagickEpsilon) &&
+      (AbsolutePixelValue(green-blue) < MagickEpsilon))
     return(MagickTrue);
-#else
-  {
-    double
-      alpha,
-      beta;
-
-    alpha=pixel[image->channel_map[RedPixelChannel].offset]-(double)
-      pixel[image->channel_map[GreenPixelChannel].offset];
-    beta=pixel[image->channel_map[GreenPixelChannel].offset]-(double)
-      pixel[image->channel_map[BluePixelChannel].offset];
-    if ((fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
-      return(MagickTrue);
-  }
-#endif
   return(MagickFalse);
 }
 
 static inline MagickBooleanType IsPixelInfoEquivalent(
   const PixelInfo *restrict p,const PixelInfo *restrict q)
 {
-  if ((p->matte != MagickFalse) && (q->matte == MagickFalse) &&
-      (fabs(p->alpha-OpaqueAlpha) > 0.5))
+  if ((p->alpha_trait == BlendPixelTrait) &&
+      (q->alpha_trait != BlendPixelTrait) &&
+      (AbsolutePixelValue(p->alpha-OpaqueAlpha) >= MagickEpsilon))
     return(MagickFalse);
-  if ((q->matte != MagickFalse) && (p->matte == MagickFalse) &&
-      (fabs(q->alpha-OpaqueAlpha)) > 0.5)
+  if ((q->alpha_trait == BlendPixelTrait) &&
+      (p->alpha_trait != BlendPixelTrait) &&
+      (AbsolutePixelValue(q->alpha-OpaqueAlpha)) >= MagickEpsilon)
     return(MagickFalse);
-  if ((p->matte != MagickFalse) && (q->matte != MagickFalse))
+  if ((p->alpha_trait == BlendPixelTrait) &&
+      (q->alpha_trait == BlendPixelTrait))
     {
-      if (fabs(p->alpha-q->alpha) > 0.5)
+      if (AbsolutePixelValue(p->alpha-q->alpha) >= MagickEpsilon)
         return(MagickFalse);
-      if (fabs(p->alpha-TransparentAlpha) <= 0.5)
+      if (AbsolutePixelValue(p->alpha-TransparentAlpha) < MagickEpsilon)
         return(MagickTrue);
     }
-  if (fabs(p->red-q->red) > 0.5)
+  if (AbsolutePixelValue(p->red-q->red) >= MagickEpsilon)
     return(MagickFalse);
-  if (fabs(p->green-q->green) > 0.5)
+  if (AbsolutePixelValue(p->green-q->green) >= MagickEpsilon)
     return(MagickFalse);
-  if (fabs(p->blue-q->blue) > 0.5)
+  if (AbsolutePixelValue(p->blue-q->blue) >= MagickEpsilon)
     return(MagickFalse);
-  if ((p->colorspace == CMYKColorspace) && (fabs(p->black-q->black) > 0.5))
+  if ((p->colorspace == CMYKColorspace) &&
+      (AbsolutePixelValue(p->black-q->black) >= MagickEpsilon))
     return(MagickFalse);
   return(MagickTrue);
 }
@@ -406,80 +479,57 @@ static inline MagickBooleanType IsPixelInfoEquivalent(
 static inline MagickBooleanType IsPixelMonochrome(const Image *restrict image,
   const Quantum *restrict pixel)
 {
-#if !defined(MAGICKCORE_HDRI_SUPPORT)
-  if (((pixel[image->channel_map[RedPixelChannel].offset] == 0) ||
-      (pixel[image->channel_map[RedPixelChannel].offset] == (Quantum) QuantumRange)) &&
-      (pixel[image->channel_map[RedPixelChannel].offset] ==
-       pixel[image->channel_map[GreenPixelChannel].offset]) &&
-      (pixel[image->channel_map[GreenPixelChannel].offset] ==
-       pixel[image->channel_map[BluePixelChannel].offset]))
+  MagickRealType
+    blue,
+    green,
+    red;
+
+  red=(MagickRealType) pixel[image->channel_map[RedPixelChannel].offset];
+  if ((AbsolutePixelValue(red) >= MagickEpsilon) ||
+      (AbsolutePixelValue(red-QuantumRange) >= MagickEpsilon))
+    return(MagickFalse);
+  green=(MagickRealType) pixel[image->channel_map[GreenPixelChannel].offset];
+  blue=(MagickRealType) pixel[image->channel_map[BluePixelChannel].offset];
+  if ((AbsolutePixelValue(red-green) < MagickEpsilon) &&
+      (AbsolutePixelValue(green-blue) < MagickEpsilon))
     return(MagickTrue);
-#else
-  {
-    double
-      alpha,
-      beta;
-
-    alpha=pixel[image->channel_map[RedPixelChannel].offset]-(double)
-      pixel[image->channel_map[GreenPixelChannel].offset];
-    beta=pixel[image->channel_map[GreenPixelChannel].offset]-(double)
-      pixel[image->channel_map[BluePixelChannel].offset];
-    if (((fabs(pixel[image->channel_map[RedPixelChannel].offset]) <= MagickEpsilon) ||
-         (fabs(pixel[image->channel_map[RedPixelChannel].offset]-QuantumRange) <= MagickEpsilon)) &&
-        (fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
-      return(MagickTrue);
-    }
-#endif
   return(MagickFalse);
 }
 
 static inline MagickBooleanType IsPixelInfoGray(
   const PixelInfo *restrict pixel_info)
 {
-#if !defined(MAGICKCORE_HDRI_SUPPORT)
-  if ((pixel_info->red == pixel_info->green) &&
-      (pixel_info->green == pixel_info->blue))
+  if ((pixel_info->colorspace != GRAYColorspace) &&
+      (pixel_info->colorspace != RGBColorspace))
+    return(MagickFalse);
+  if ((AbsolutePixelValue(pixel_info->red-pixel_info->green) < MagickEpsilon) &&
+      (AbsolutePixelValue(pixel_info->green-pixel_info->blue) < MagickEpsilon))
     return(MagickTrue);
-#else
-  {
-    double
-      alpha,
-      beta;
-
-    alpha=pixel_info->red-(double) pixel_info->green;
-    beta=pixel_info->green-(double) pixel_info->blue;
-    if ((fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
-      return(MagickTrue);
-  }
-#endif
   return(MagickFalse);
 }
 
 static inline MagickBooleanType IsPixelInfoMonochrome(
   const PixelInfo *restrict pixel_info)
 {
-#if !defined(MAGICKCORE_HDRI_SUPPORT)
-  if (((pixel_info->red == 0) || (pixel_info->red == (Quantum) QuantumRange)) &&
-      (pixel_info->red == pixel_info->green) &&
-      (pixel_info->green == pixel_info->blue))
+  if ((pixel_info->colorspace != GRAYColorspace) &&
+      (pixel_info->colorspace != RGBColorspace))
+    return(MagickFalse);
+  if ((AbsolutePixelValue(pixel_info->red) >= MagickEpsilon) ||
+      (AbsolutePixelValue(pixel_info->red-QuantumRange) >= MagickEpsilon))
+    return(MagickFalse);
+  if ((AbsolutePixelValue(pixel_info->red-pixel_info->green) < MagickEpsilon) &&
+      (AbsolutePixelValue(pixel_info->green-pixel_info->blue) < MagickEpsilon))
     return(MagickTrue);
-#else
-  {
-    double
-      alpha,
-      beta;
-
-    alpha=pixel_info->red-(double) pixel_info->green;
-    beta=pixel_info->green-(double) pixel_info->blue;
-    if (((fabs(pixel_info->red) <= MagickEpsilon) ||
-         (fabs(pixel_info->red-QuantumRange) <= MagickEpsilon)) &&
-        (fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
-      return(MagickTrue);
-    }
-#endif
   return(MagickFalse);
 }
 
+static inline void SetPixela(const Image *restrict image,
+  const Quantum a,Quantum *restrict pixel)
+{
+  if (image->channel_map[aPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[aPixelChannel].offset]=a;
+}
+
 static inline void SetPixelAlpha(const Image *restrict image,
   const Quantum alpha,Quantum *restrict pixel)
 {
@@ -492,6 +542,36 @@ static inline void SetPixelAlphaTraits(Image *image,const PixelTrait traits)
   image->channel_map[AlphaPixelChannel].traits=traits;
 }
 
+static inline void SetPixelb(const Image *restrict image,
+  const Quantum b,Quantum *restrict pixel)
+{
+  if (image->channel_map[bPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[bPixelChannel].offset]=b;
+}
+
+static inline void SetPixelBackgoundColor(const Image *restrict image,
+  Quantum *restrict pixel)
+{
+  register ssize_t
+    i;
+
+  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+    pixel[i]=0;
+  pixel[image->channel_map[RedPixelChannel].offset]=
+    ClampToQuantum(image->background_color.red);
+  pixel[image->channel_map[GreenPixelChannel].offset]=
+    ClampToQuantum(image->background_color.green);
+  pixel[image->channel_map[BluePixelChannel].offset]=
+    ClampToQuantum(image->background_color.blue);
+  if (image->channel_map[BlackPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[BlackPixelChannel].offset]=
+      ClampToQuantum(image->background_color.black);
+  if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[AlphaPixelChannel].offset]=
+      image->background_color.alpha_trait != BlendPixelTrait ? OpaqueAlpha :
+      ClampToQuantum(image->background_color.alpha);
+}
+
 static inline void SetPixelBlack(const Image *restrict image,
   const Quantum black,Quantum *restrict pixel)
 {
@@ -533,19 +613,19 @@ static inline void SetPixelChannel(const Image *restrict image,
     pixel[image->channel_map[channel].offset]=quantum;
 }
 
-static inline void SetPixelChannelMapChannel(const Image *restrict image,
-  const PixelChannel channel,const ssize_t offset)
+static inline void SetPixelChannelAttributes(const Image *restrict image,
+  const PixelChannel channel,const PixelTrait traits,const ssize_t offset)
 {
   image->channel_map[offset].channel=channel;
   image->channel_map[channel].offset=offset;
+  image->channel_map[channel].traits=traits;
 }
 
-static inline void SetPixelChannelMap(const Image *restrict image,
-  const PixelChannel channel,const PixelTrait traits,const ssize_t offset)
+static inline void SetPixelChannelChannel(const Image *restrict image,
+  const PixelChannel channel,const ssize_t offset)
 {
   image->channel_map[offset].channel=channel;
   image->channel_map[channel].offset=offset;
-  image->channel_map[channel].traits=traits;
 }
 
 static inline void SetPixelChannels(Image *image,const size_t number_channels)
@@ -559,12 +639,6 @@ static inline void SetPixelChannelTraits(Image *image,
   image->channel_map[channel].traits=traits;
 }
 
-static inline void SetPixelChannelMapTraits(Image *image,
-  const PixelChannel channel,const PixelTrait traits)
-{
-  image->channel_map[channel].traits=traits;
-}
-
 static inline void SetPixelCr(const Image *restrict image,const Quantum cr,
   Quantum *restrict pixel)
 {
@@ -629,8 +703,16 @@ static inline void SetPixelInfoPixel(const Image *restrict image,
     pixel[image->channel_map[BlackPixelChannel].offset]=
       ClampToQuantum(pixel_info->black);
   if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
-    pixel[image->channel_map[AlphaPixelChannel].offset]=pixel_info->matte ==
-      MagickFalse ? OpaqueAlpha : ClampToQuantum(pixel_info->alpha);
+    pixel[image->channel_map[AlphaPixelChannel].offset]=
+      pixel_info->alpha_trait != BlendPixelTrait ? OpaqueAlpha :
+      ClampToQuantum(pixel_info->alpha);
+}
+
+static inline void SetPixelL(const Image *restrict image,const Quantum L,
+  Quantum *restrict pixel)
+{
+  if (image->channel_map[LPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[LPixelChannel].offset]=L;
 }
 
 static inline void SetPixelMagenta(const Image *restrict image,
@@ -644,11 +726,18 @@ static inline void SetPixelMagentaTraits(Image *image,const PixelTrait traits)
   image->channel_map[MagentaPixelChannel].traits=traits;
 }
 
-static inline void SetPixelMask(const Image *restrict image,
+static inline void SetPixelReadMask(const Image *restrict image,
+  const Quantum mask,Quantum *restrict pixel)
+{
+  if (image->channel_map[ReadMaskPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[ReadMaskPixelChannel].offset]=mask;
+}
+
+static inline void SetPixelWriteMask(const Image *restrict image,
   const Quantum mask,Quantum *restrict pixel)
 {
-  if (image->channel_map[MaskPixelChannel].traits != UndefinedPixelTrait)
-    pixel[image->channel_map[MaskPixelChannel].offset]=mask;
+  if (image->channel_map[WriteMaskPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[WriteMaskPixelChannel].offset]=mask;
 }
 
 static inline void SetPixelMetacontentExtent(Image *image,const size_t extent)