(no commit message)

diff --git a/coders/msl.c b/coders/msl.c
index 5647efc221ebc261747b0354b4786e91e8e048bc..11b8a0bea8fe3ca0dac6938fe1d98b6708a8e3d7 100644 (file)
--- a/coders/msl.c
+++ b/coders/msl.c
@@ -7060,7 +7060,7 @@ static void MSLStartElement(void *context,const xmlChar *tag,
         */
         {
         BilevelImageChannel(msl_info->image[n],
-          (ChannelType) ((ssize_t) (AllChannels &~ (ssize_t) OpacityChannel)),
+          (ChannelType) ((ssize_t) (CompositeChannels &~ (ssize_t) OpacityChannel)),
           threshold);
         break;
         }

diff --git a/magick/attribute.c b/magick/attribute.c
index 5de333a9a33518db6329ac8f5e23837b8d5eeff5..f70728e42fdfebf990380d66c3e4a60241428bab 100644 (file)
--- a/magick/attribute.c
+++ b/magick/attribute.c
@@ -276,7 +276,7 @@ MagickExport RectangleInfo GetImageBoundingBox(const Image *image,
 */
 MagickExport size_t GetImageDepth(const Image *image,ExceptionInfo *exception)
 {
-  return(GetImageChannelDepth(image,AllChannels,exception));
+  return(GetImageChannelDepth(image,CompositeChannels,exception));
 }
 
 MagickExport size_t GetImageChannelDepth(const Image *image,
@@ -819,7 +819,7 @@ MagickExport MagickBooleanType IsOpaqueImage(const Image *image,
 MagickExport MagickBooleanType SetImageDepth(Image *image,
   const size_t depth)
 {
-  return(SetImageChannelDepth(image,AllChannels,depth));
+  return(SetImageChannelDepth(image,CompositeChannels,depth));
 }
 
 MagickExport MagickBooleanType SetImageChannelDepth(Image *image,

diff --git a/magick/compare.c b/magick/compare.c
index 58df9fcbe200e2f938f28789c2c95d3c1a902a2d..a48fcf80484e3d5db100380ee0320870c8d80175 100644 (file)
--- a/magick/compare.c
+++ b/magick/compare.c
@@ -110,7 +110,7 @@ MagickExport Image *CompareImages(Image *image,const Image *reconstruct_image,
   Image
     *highlight_image;
 
-  highlight_image=CompareImageChannels(image,reconstruct_image,AllChannels,
+  highlight_image=CompareImageChannels(image,reconstruct_image,CompositeChannels,
     metric,distortion,exception);
   return(highlight_image);
 }
@@ -255,7 +255,7 @@ MagickExport Image *CompareImageChannels(Image *image,
       SetMagickPixelPacket(reconstruct_image,q,reconstruct_indexes+x,
         &reconstruct_pixel);
       difference=MagickFalse;
-      if (channel == AllChannels)
+      if (channel == CompositeChannels)
         {
           if (IsMagickColorSimilar(&pixel,&reconstruct_pixel) == MagickFalse)
             difference=MagickTrue;
@@ -347,7 +347,7 @@ MagickExport MagickBooleanType GetImageDistortion(Image *image,
   MagickBooleanType
     status;
 
-  status=GetImageChannelDistortion(image,reconstruct_image,AllChannels,
+  status=GetImageChannelDistortion(image,reconstruct_image,CompositeChannels,
     metric,distortion,exception);
   return(status);
 }
@@ -382,7 +382,7 @@ static MagickBooleanType GetAbsoluteDistortion(const Image *image,
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     double
-      channel_distortion[AllChannels+1];
+      channel_distortion[CompositeChannels+1];
 
     MagickPixelPacket
       pixel,
@@ -434,7 +434,7 @@ static MagickBooleanType GetAbsoluteDistortion(const Image *image,
           if (((channel & IndexChannel) != 0) &&
               (image->colorspace == CMYKColorspace))
             channel_distortion[BlackChannel]++;
-          channel_distortion[AllChannels]++;
+          channel_distortion[CompositeChannels]++;
         }
       p++;
       q++;
@@ -442,7 +442,7 @@ static MagickBooleanType GetAbsoluteDistortion(const Image *image,
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp critical (MagickCore_GetAbsoluteError)
 #endif
-    for (i=0; i <= (ssize_t) AllChannels; i++)
+    for (i=0; i <= (ssize_t) CompositeChannels; i++)
       distortion[i]+=channel_distortion[i];
   }
   reconstruct_view=DestroyCacheView(reconstruct_view);
@@ -498,7 +498,7 @@ static MagickBooleanType GetFuzzDistortion(const Image *image,
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     double
-      channel_distortion[AllChannels+1];
+      channel_distortion[CompositeChannels+1];
 
     register const IndexPacket
       *restrict indexes,
@@ -535,21 +535,21 @@ static MagickBooleanType GetFuzzDistortion(const Image *image,
           distance=QuantumScale*(GetRedPixelComponent(p)-(MagickRealType)
             GetRedPixelComponent(q));
           channel_distortion[RedChannel]+=distance*distance;
-          channel_distortion[AllChannels]+=distance*distance;
+          channel_distortion[CompositeChannels]+=distance*distance;
         }
       if ((channel & GreenChannel) != 0)
         {
           distance=QuantumScale*(GetGreenPixelComponent(p)-(MagickRealType)
             GetGreenPixelComponent(q));
           channel_distortion[GreenChannel]+=distance*distance;
-          channel_distortion[AllChannels]+=distance*distance;
+          channel_distortion[CompositeChannels]+=distance*distance;
         }
       if ((channel & BlueChannel) != 0)
         {
           distance=QuantumScale*(GetBluePixelComponent(p)-(MagickRealType)
             GetBluePixelComponent(q));
           channel_distortion[BlueChannel]+=distance*distance;
-          channel_distortion[AllChannels]+=distance*distance;
+          channel_distortion[CompositeChannels]+=distance*distance;
         }
       if (((channel & OpacityChannel) != 0) && ((image->matte != MagickFalse) ||
           (reconstruct_image->matte != MagickFalse)))
@@ -559,7 +559,7 @@ static MagickBooleanType GetFuzzDistortion(const Image *image,
             (reconstruct_image->matte != MagickFalse ?
             GetOpacityPixelComponent(q): OpaqueOpacity));
           channel_distortion[OpacityChannel]+=distance*distance;
-          channel_distortion[AllChannels]+=distance*distance;
+          channel_distortion[CompositeChannels]+=distance*distance;
         }
       if (((channel & IndexChannel) != 0) &&
           (image->colorspace == CMYKColorspace) &&
@@ -568,7 +568,7 @@ static MagickBooleanType GetFuzzDistortion(const Image *image,
           distance=QuantumScale*(GetIndexPixelComponent(indexes+x)-
             (MagickRealType) GetIndexPixelComponent(reconstruct_indexes+x));
           channel_distortion[BlackChannel]+=distance*distance;
-          channel_distortion[AllChannels]+=distance*distance;
+          channel_distortion[CompositeChannels]+=distance*distance;
         }
       p++;
       q++;
@@ -576,19 +576,19 @@ static MagickBooleanType GetFuzzDistortion(const Image *image,
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp critical (MagickCore_GetMeanSquaredError)
 #endif
-    for (i=0; i <= (ssize_t) AllChannels; i++)
+    for (i=0; i <= (ssize_t) CompositeChannels; i++)
       distortion[i]+=channel_distortion[i];
   }
   reconstruct_view=DestroyCacheView(reconstruct_view);
   image_view=DestroyCacheView(image_view);
-  for (i=0; i <= (ssize_t) AllChannels; i++)
+  for (i=0; i <= (ssize_t) CompositeChannels; i++)
     distortion[i]/=((double) image->columns*image->rows);
   if (((channel & OpacityChannel) != 0) && ((image->matte != MagickFalse) ||
       (reconstruct_image->matte != MagickFalse)))
-    distortion[AllChannels]/=(double) (GetNumberChannels(image,channel)-1);
+    distortion[CompositeChannels]/=(double) (GetNumberChannels(image,channel)-1);
   else
-    distortion[AllChannels]/=(double) GetNumberChannels(image,channel);
-  distortion[AllChannels]=sqrt(distortion[AllChannels]);
+    distortion[CompositeChannels]/=(double) GetNumberChannels(image,channel);
+  distortion[CompositeChannels]=sqrt(distortion[CompositeChannels]);
   return(status);
 }
 
@@ -618,7 +618,7 @@ static MagickBooleanType GetMeanAbsoluteDistortion(const Image *image,
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     double
-      channel_distortion[AllChannels+1];
+      channel_distortion[CompositeChannels+1];
 
     register const IndexPacket
       *restrict indexes,
@@ -655,21 +655,21 @@ static MagickBooleanType GetMeanAbsoluteDistortion(const Image *image,
           distance=QuantumScale*fabs(GetRedPixelComponent(p)-(double)
             GetRedPixelComponent(q));
           channel_distortion[RedChannel]+=distance;
-          channel_distortion[AllChannels]+=distance;
+          channel_distortion[CompositeChannels]+=distance;
         }
       if ((channel & GreenChannel) != 0)
         {
           distance=QuantumScale*fabs(GetGreenPixelComponent(p)-(double)
             GetGreenPixelComponent(q));
           channel_distortion[GreenChannel]+=distance;
-          channel_distortion[AllChannels]+=distance;
+          channel_distortion[CompositeChannels]+=distance;
         }
       if ((channel & BlueChannel) != 0)
         {
           distance=QuantumScale*fabs(GetBluePixelComponent(p)-(double)
             GetBluePixelComponent(q));
           channel_distortion[BlueChannel]+=distance;
-          channel_distortion[AllChannels]+=distance;
+          channel_distortion[CompositeChannels]+=distance;
         }
       if (((channel & OpacityChannel) != 0) &&
           (image->matte != MagickFalse))
@@ -677,7 +677,7 @@ static MagickBooleanType GetMeanAbsoluteDistortion(const Image *image,
           distance=QuantumScale*fabs(GetOpacityPixelComponent(p)-(double)
             GetOpacityPixelComponent(q));
           channel_distortion[OpacityChannel]+=distance;
-          channel_distortion[AllChannels]+=distance;
+          channel_distortion[CompositeChannels]+=distance;
         }
       if (((channel & IndexChannel) != 0) &&
           (image->colorspace == CMYKColorspace))
@@ -685,7 +685,7 @@ static MagickBooleanType GetMeanAbsoluteDistortion(const Image *image,
           distance=QuantumScale*fabs(GetIndexPixelComponent(indexes+x)-(double)
             GetIndexPixelComponent(reconstruct_indexes+x));
           channel_distortion[BlackChannel]+=distance;
-          channel_distortion[AllChannels]+=distance;
+          channel_distortion[CompositeChannels]+=distance;
         }
       p++;
       q++;
@@ -693,14 +693,14 @@ static MagickBooleanType GetMeanAbsoluteDistortion(const Image *image,
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp critical (MagickCore_GetMeanAbsoluteError)
 #endif
-    for (i=0; i <= (ssize_t) AllChannels; i++)
+    for (i=0; i <= (ssize_t) CompositeChannels; i++)
       distortion[i]+=channel_distortion[i];
   }
   reconstruct_view=DestroyCacheView(reconstruct_view);
   image_view=DestroyCacheView(image_view);
-  for (i=0; i <= (ssize_t) AllChannels; i++)
+  for (i=0; i <= (ssize_t) CompositeChannels; i++)
     distortion[i]/=((double) image->columns*image->rows);
-  distortion[AllChannels]/=(double) GetNumberChannels(image,channel);
+  distortion[CompositeChannels]/=(double) GetNumberChannels(image,channel);
   return(status);
 }
 
@@ -773,7 +773,7 @@ static MagickBooleanType GetMeanErrorPerPixel(Image *image,
           distance=fabs(alpha*GetRedPixelComponent(p)-beta*
             GetRedPixelComponent(q));
           distortion[RedChannel]+=distance;
-          distortion[AllChannels]+=distance;
+          distortion[CompositeChannels]+=distance;
           mean_error+=distance*distance;
           if (distance > maximum_error)
             maximum_error=distance;
@@ -784,7 +784,7 @@ static MagickBooleanType GetMeanErrorPerPixel(Image *image,
           distance=fabs(alpha*GetGreenPixelComponent(p)-beta*
             GetGreenPixelComponent(q));
           distortion[GreenChannel]+=distance;
-          distortion[AllChannels]+=distance;
+          distortion[CompositeChannels]+=distance;
           mean_error+=distance*distance;
           if (distance > maximum_error)
             maximum_error=distance;
@@ -795,7 +795,7 @@ static MagickBooleanType GetMeanErrorPerPixel(Image *image,
           distance=fabs(alpha*GetBluePixelComponent(p)-beta*
             GetBluePixelComponent(q));
           distortion[BlueChannel]+=distance;
-          distortion[AllChannels]+=distance;
+          distortion[CompositeChannels]+=distance;
           mean_error+=distance*distance;
           if (distance > maximum_error)
             maximum_error=distance;
@@ -807,7 +807,7 @@ static MagickBooleanType GetMeanErrorPerPixel(Image *image,
           distance=fabs((double) GetOpacityPixelComponent(p)-
             GetOpacityPixelComponent(q));
           distortion[OpacityChannel]+=distance;
-          distortion[AllChannels]+=distance;
+          distortion[CompositeChannels]+=distance;
           mean_error+=distance*distance;
           if (distance > maximum_error)
             maximum_error=distance;
@@ -820,7 +820,7 @@ static MagickBooleanType GetMeanErrorPerPixel(Image *image,
           distance=fabs(alpha*GetIndexPixelComponent(indexes+x)-beta*
             GetIndexPixelComponent(reconstruct_indexes+x));
           distortion[BlackChannel]+=distance;
-          distortion[AllChannels]+=distance;
+          distortion[CompositeChannels]+=distance;
           mean_error+=distance*distance;
           if (distance > maximum_error)
             maximum_error=distance;
@@ -832,7 +832,7 @@ static MagickBooleanType GetMeanErrorPerPixel(Image *image,
   }
   reconstruct_view=DestroyCacheView(reconstruct_view);
   image_view=DestroyCacheView(image_view);
-  image->error.mean_error_per_pixel=distortion[AllChannels]/area;
+  image->error.mean_error_per_pixel=distortion[CompositeChannels]/area;
   image->error.normalized_mean_error=QuantumScale*QuantumScale*mean_error/area;
   image->error.normalized_maximum_error=QuantumScale*maximum_error;
   return(status);
@@ -864,7 +864,7 @@ static MagickBooleanType GetMeanSquaredDistortion(const Image *image,
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     double
-      channel_distortion[AllChannels+1];
+      channel_distortion[CompositeChannels+1];
 
     register const IndexPacket
       *restrict indexes,
@@ -901,21 +901,21 @@ static MagickBooleanType GetMeanSquaredDistortion(const Image *image,
           distance=QuantumScale*(GetRedPixelComponent(p)-(MagickRealType)
             GetRedPixelComponent(q));
           channel_distortion[RedChannel]+=distance*distance;
-          channel_distortion[AllChannels]+=distance*distance;
+          channel_distortion[CompositeChannels]+=distance*distance;
         }
       if ((channel & GreenChannel) != 0)
         {
           distance=QuantumScale*(GetGreenPixelComponent(p)-(MagickRealType)
             GetGreenPixelComponent(q));
           channel_distortion[GreenChannel]+=distance*distance;
-          channel_distortion[AllChannels]+=distance*distance;
+          channel_distortion[CompositeChannels]+=distance*distance;
         }
       if ((channel & BlueChannel) != 0)
         {
           distance=QuantumScale*(GetBluePixelComponent(p)-(MagickRealType)
             GetBluePixelComponent(q));
           channel_distortion[BlueChannel]+=distance*distance;
-          channel_distortion[AllChannels]+=distance*distance;
+          channel_distortion[CompositeChannels]+=distance*distance;
         }
       if (((channel & OpacityChannel) != 0) &&
           (image->matte != MagickFalse))
@@ -923,7 +923,7 @@ static MagickBooleanType GetMeanSquaredDistortion(const Image *image,
           distance=QuantumScale*(GetOpacityPixelComponent(p)-(MagickRealType)
             GetOpacityPixelComponent(q));
           channel_distortion[OpacityChannel]+=distance*distance;
-          channel_distortion[AllChannels]+=distance*distance;
+          channel_distortion[CompositeChannels]+=distance*distance;
         }
       if (((channel & IndexChannel) != 0) &&
           (image->colorspace == CMYKColorspace) &&
@@ -932,7 +932,7 @@ static MagickBooleanType GetMeanSquaredDistortion(const Image *image,
           distance=QuantumScale*(GetIndexPixelComponent(indexes+x)-
             (MagickRealType) GetIndexPixelComponent(reconstruct_indexes+x));
           channel_distortion[BlackChannel]+=distance*distance;
-          channel_distortion[AllChannels]+=distance*distance;
+          channel_distortion[CompositeChannels]+=distance*distance;
         }
       p++;
       q++;
@@ -940,14 +940,14 @@ static MagickBooleanType GetMeanSquaredDistortion(const Image *image,
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp critical (MagickCore_GetMeanSquaredError)
 #endif
-    for (i=0; i <= (ssize_t) AllChannels; i++)
+    for (i=0; i <= (ssize_t) CompositeChannels; i++)
       distortion[i]+=channel_distortion[i];
   }
   reconstruct_view=DestroyCacheView(reconstruct_view);
   image_view=DestroyCacheView(image_view);
-  for (i=0; i <= (ssize_t) AllChannels; i++)
+  for (i=0; i <= (ssize_t) CompositeChannels; i++)
     distortion[i]/=((double) image->columns*image->rows);
-  distortion[AllChannels]/=(double) GetNumberChannels(image,channel);
+  distortion[CompositeChannels]/=(double) GetNumberChannels(image,channel);
   return(status);
 }
 
@@ -987,7 +987,7 @@ static MagickBooleanType GetNormalizedCrossCorrelationDistortion(
   reconstruct_statistics=GetImageChannelStatistics(reconstruct_image,exception);
   status=MagickTrue;
   progress=0;
-  for (i=0; i <= (ssize_t) AllChannels; i++)
+  for (i=0; i <= (ssize_t) CompositeChannels; i++)
     distortion[i]=0.0;
   area=1.0/((MagickRealType) image->columns*image->rows);
   image_view=AcquireCacheView(image);
@@ -1064,7 +1064,7 @@ static MagickBooleanType GetNormalizedCrossCorrelationDistortion(
   /*
     Divide by the standard deviation.
   */
-  for (i=0; i < (ssize_t) AllChannels; i++)
+  for (i=0; i < (ssize_t) CompositeChannels; i++)
   {
     MagickRealType
       gamma;
@@ -1074,20 +1074,20 @@ static MagickBooleanType GetNormalizedCrossCorrelationDistortion(
     gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
     distortion[i]=QuantumRange*gamma*distortion[i];
   }
-  distortion[AllChannels]=0.0;
+  distortion[CompositeChannels]=0.0;
   if ((channel & RedChannel) != 0)
-    distortion[AllChannels]+=distortion[RedChannel]*distortion[RedChannel];
+    distortion[CompositeChannels]+=distortion[RedChannel]*distortion[RedChannel];
   if ((channel & GreenChannel) != 0)
-    distortion[AllChannels]+=distortion[GreenChannel]*distortion[GreenChannel];
+    distortion[CompositeChannels]+=distortion[GreenChannel]*distortion[GreenChannel];
   if ((channel & BlueChannel) != 0)
-    distortion[AllChannels]+=distortion[BlueChannel]*distortion[BlueChannel];
+    distortion[CompositeChannels]+=distortion[BlueChannel]*distortion[BlueChannel];
   if (((channel & OpacityChannel) != 0) && (image->matte != MagickFalse))
-    distortion[AllChannels]+=distortion[OpacityChannel]*
+    distortion[CompositeChannels]+=distortion[OpacityChannel]*
       distortion[OpacityChannel];
   if (((channel & IndexChannel) != 0) &&
       (image->colorspace == CMYKColorspace))
-    distortion[AllChannels]+=distortion[BlackChannel]*distortion[BlackChannel];
-  distortion[AllChannels]=sqrt(distortion[AllChannels]/GetNumberChannels(image,
+    distortion[CompositeChannels]+=distortion[BlackChannel]*distortion[BlackChannel];
+  distortion[CompositeChannels]=sqrt(distortion[CompositeChannels]/GetNumberChannels(image,
     channel));
   /*
     Free resources.
@@ -1122,7 +1122,7 @@ static MagickBooleanType GetPeakAbsoluteDistortion(const Image *image,
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     double
-      channel_distortion[AllChannels+1];
+      channel_distortion[CompositeChannels+1];
 
     register const IndexPacket
       *restrict indexes,
@@ -1160,8 +1160,8 @@ static MagickBooleanType GetPeakAbsoluteDistortion(const Image *image,
             GetRedPixelComponent(q));
           if (distance > channel_distortion[RedChannel])
             channel_distortion[RedChannel]=distance;
-          if (distance > channel_distortion[AllChannels])
-            channel_distortion[AllChannels]=distance;
+          if (distance > channel_distortion[CompositeChannels])
+            channel_distortion[CompositeChannels]=distance;
         }
       if ((channel & GreenChannel) != 0)
         {
@@ -1169,8 +1169,8 @@ static MagickBooleanType GetPeakAbsoluteDistortion(const Image *image,
             GetGreenPixelComponent(q));
           if (distance > channel_distortion[GreenChannel])
             channel_distortion[GreenChannel]=distance;
-          if (distance > channel_distortion[AllChannels])
-            channel_distortion[AllChannels]=distance;
+          if (distance > channel_distortion[CompositeChannels])
+            channel_distortion[CompositeChannels]=distance;
         }
       if ((channel & BlueChannel) != 0)
         {
@@ -1178,8 +1178,8 @@ static MagickBooleanType GetPeakAbsoluteDistortion(const Image *image,
             GetBluePixelComponent(q));
           if (distance > channel_distortion[BlueChannel])
             channel_distortion[BlueChannel]=distance;
-          if (distance > channel_distortion[AllChannels])
-            channel_distortion[AllChannels]=distance;
+          if (distance > channel_distortion[CompositeChannels])
+            channel_distortion[CompositeChannels]=distance;
         }
       if (((channel & OpacityChannel) != 0) &&
           (image->matte != MagickFalse))
@@ -1188,8 +1188,8 @@ static MagickBooleanType GetPeakAbsoluteDistortion(const Image *image,
             GetOpacityPixelComponent(q));
           if (distance > channel_distortion[OpacityChannel])
             channel_distortion[OpacityChannel]=distance;
-          if (distance > channel_distortion[AllChannels])
-            channel_distortion[AllChannels]=distance;
+          if (distance > channel_distortion[CompositeChannels])
+            channel_distortion[CompositeChannels]=distance;
         }
       if (((channel & IndexChannel) != 0) &&
           (image->colorspace == CMYKColorspace) &&
@@ -1199,8 +1199,8 @@ static MagickBooleanType GetPeakAbsoluteDistortion(const Image *image,
             GetIndexPixelComponent(reconstruct_indexes+x));
           if (distance > channel_distortion[BlackChannel])
             channel_distortion[BlackChannel]=distance;
-          if (distance > channel_distortion[AllChannels])
-            channel_distortion[AllChannels]=distance;
+          if (distance > channel_distortion[CompositeChannels])
+            channel_distortion[CompositeChannels]=distance;
         }
       p++;
       q++;
@@ -1208,7 +1208,7 @@ static MagickBooleanType GetPeakAbsoluteDistortion(const Image *image,
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp critical (MagickCore_GetPeakAbsoluteError)
 #endif
-    for (i=0; i <= (ssize_t) AllChannels; i++)
+    for (i=0; i <= (ssize_t) CompositeChannels; i++)
       if (channel_distortion[i] > distortion[i])
         distortion[i]=channel_distortion[i];
   }
@@ -1243,8 +1243,8 @@ static MagickBooleanType GetPeakSignalToNoiseRatio(const Image *image,
       (image->colorspace == CMYKColorspace))
     distortion[BlackChannel]=20.0*log10((double) 1.0/sqrt(
       distortion[BlackChannel]));
-  distortion[AllChannels]=20.0*log10((double) 1.0/sqrt(
-    distortion[AllChannels]));
+  distortion[CompositeChannels]=20.0*log10((double) 1.0/sqrt(
+    distortion[CompositeChannels]));
   return(status);
 }
 
@@ -1269,7 +1269,7 @@ static MagickBooleanType GetRootMeanSquaredDistortion(const Image *image,
   if (((channel & IndexChannel) != 0) &&
       (image->colorspace == CMYKColorspace))
     distortion[BlackChannel]=sqrt(distortion[BlackChannel]);
-  distortion[AllChannels]=sqrt(distortion[AllChannels]);
+  distortion[CompositeChannels]=sqrt(distortion[CompositeChannels]);
   return(status);
 }
 
@@ -1302,7 +1302,7 @@ MagickExport MagickBooleanType GetImageChannelDistortion(Image *image,
   /*
     Get image distortion.
   */
-  length=AllChannels+1UL;
+  length=CompositeChannels+1UL;
   channel_distortion=(double *) AcquireQuantumMemory(length,
     sizeof(*channel_distortion));
   if (channel_distortion == (double *) NULL)
@@ -1367,7 +1367,7 @@ MagickExport MagickBooleanType GetImageChannelDistortion(Image *image,
       break;
     }
   }
-  *distortion=channel_distortion[AllChannels];
+  *distortion=channel_distortion[CompositeChannels];
   channel_distortion=(double *) RelinquishMagickMemory(channel_distortion);
   return(status);
 }
@@ -1435,7 +1435,7 @@ MagickExport double *GetImageChannelDistortions(Image *image,
   /*
     Get image distortion.
   */
-  length=AllChannels+1UL;
+  length=CompositeChannels+1UL;
   channel_distortion=(double *) AcquireQuantumMemory(length,
     sizeof(*channel_distortion));
   if (channel_distortion == (double *) NULL)
@@ -1447,31 +1447,31 @@ MagickExport double *GetImageChannelDistortions(Image *image,
   {
     case AbsoluteErrorMetric:
     {
-      status=GetAbsoluteDistortion(image,reconstruct_image,AllChannels,
+      status=GetAbsoluteDistortion(image,reconstruct_image,CompositeChannels,
         channel_distortion,exception);
       break;
     }
     case FuzzErrorMetric:
     {
-      status=GetFuzzDistortion(image,reconstruct_image,AllChannels,
+      status=GetFuzzDistortion(image,reconstruct_image,CompositeChannels,
         channel_distortion,exception);
       break;
     }
     case MeanAbsoluteErrorMetric:
     {
-      status=GetMeanAbsoluteDistortion(image,reconstruct_image,AllChannels,
+      status=GetMeanAbsoluteDistortion(image,reconstruct_image,CompositeChannels,
         channel_distortion,exception);
       break;
     }
     case MeanErrorPerPixelMetric:
     {
-      status=GetMeanErrorPerPixel(image,reconstruct_image,AllChannels,
+      status=GetMeanErrorPerPixel(image,reconstruct_image,CompositeChannels,
         channel_distortion,exception);
       break;
     }
     case MeanSquaredErrorMetric:
     {
-      status=GetMeanSquaredDistortion(image,reconstruct_image,AllChannels,
+      status=GetMeanSquaredDistortion(image,reconstruct_image,CompositeChannels,
         channel_distortion,exception);
       break;
     }
@@ -1479,24 +1479,24 @@ MagickExport double *GetImageChannelDistortions(Image *image,
     default:
     {
       status=GetNormalizedCrossCorrelationDistortion(image,reconstruct_image,
-        AllChannels,channel_distortion,exception);
+        CompositeChannels,channel_distortion,exception);
       break;
     }
     case PeakAbsoluteErrorMetric:
     {
-      status=GetPeakAbsoluteDistortion(image,reconstruct_image,AllChannels,
+      status=GetPeakAbsoluteDistortion(image,reconstruct_image,CompositeChannels,
         channel_distortion,exception);
       break;
     }
     case PeakSignalToNoiseRatioMetric:
     {
-      status=GetPeakSignalToNoiseRatio(image,reconstruct_image,AllChannels,
+      status=GetPeakSignalToNoiseRatio(image,reconstruct_image,CompositeChannels,
         channel_distortion,exception);
       break;
     }
     case RootMeanSquaredErrorMetric:
     {
-      status=GetRootMeanSquaredDistortion(image,reconstruct_image,AllChannels,
+      status=GetRootMeanSquaredDistortion(image,reconstruct_image,CompositeChannels,
         channel_distortion,exception);
       break;
     }
@@ -1800,8 +1800,8 @@ static double GetNCCDistortion(const Image *image,
   /*
     Divide by the standard deviation.
   */
-  gamma=image_statistics[AllChannels].standard_deviation*
-    reconstruct_statistics[AllChannels].standard_deviation;
+  gamma=image_statistics[CompositeChannels].standard_deviation*
+    reconstruct_statistics[CompositeChannels].standard_deviation;
   gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
   distortion=QuantumRange*gamma*distortion;
   number_channels=3;

diff --git a/magick/feature.c b/magick/feature.c
index 6b4a2aa38e12fd97475e72583e857f0976a6cc41..a5c89c15a593112f22dfa9aefa6d6277287e6b41 100644 (file)
--- a/magick/feature.c
+++ b/magick/feature.c
@@ -193,7 +193,7 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   if ((image->columns < (distance+1)) || (image->rows < (distance+1)))
     return((ChannelFeatures *) NULL);
-  length=AllChannels+1UL;
+  length=CompositeChannels+1UL;
   channel_features=(ChannelFeatures *) AcquireQuantumMemory(length,
     sizeof(*channel_features));
   if (channel_features == (ChannelFeatures *) NULL)

diff --git a/magick/identify.c b/magick/identify.c
index 02de8e8197cf7abadbbdc20474fbb5ab9eb726a6..853541dc8de030c37b3f9d092b319ee5825882c7 100644 (file)
--- a/magick/identify.c
+++ b/magick/identify.c
@@ -534,7 +534,7 @@ MagickExport MagickBooleanType IdentifyImage(Image *image,FILE *file,
       if (colorspace != GRAYColorspace)
         {
           (void) fprintf(file,"  Image statistics:\n");
-          (void) PrintChannelStatistics(file,AllChannels,"Overall",1.0/scale,
+          (void) PrintChannelStatistics(file,CompositeChannels,"Overall",1.0/scale,
             channel_statistics);
         }
       channel_statistics=(ChannelStatistics *) RelinquishMagickMemory(

diff --git a/magick/magick-type.h b/magick/magick-type.h
index 8d0ed69b99362d4694da4ee42f3be38ef1b7599c..5d4f4608c8e51098dcd7bbb4e49d093b3aaf3db2 100644 (file)
--- a/magick/magick-type.h
+++ b/magick/magick-type.h
@@ -148,6 +148,7 @@ typedef enum
   MatteChannel = 0x0008,     /* deprecated */
   BlackChannel = 0x0020,
   IndexChannel = 0x0020,
+  CompositeChannels = 0x002F,
   AllChannels = ~0UL,
   /*
     Special purpose channel types.

diff --git a/magick/option.c b/magick/option.c
index 755022ec4d8b76e0d0de938e655fb56589fa8d0b..e9a73e738b2767216246dc3a9a914ed034ddc879 100644 (file)
--- a/magick/option.c
+++ b/magick/option.c
@@ -118,7 +118,7 @@ static const OptionInfo
   ChannelOptions[] =
   {
     { "Undefined", UndefinedChannel, UndefinedOptionFlag, MagickTrue },
-    { "All", AllChannels, UndefinedOptionFlag, MagickFalse },
+    { "All", CompositeChannels, UndefinedOptionFlag, MagickFalse },
     { "Alpha", OpacityChannel, UndefinedOptionFlag, MagickFalse },
     { "Black", BlackChannel, UndefinedOptionFlag, MagickFalse },
     { "Blue", BlueChannel, UndefinedOptionFlag, MagickFalse },

diff --git a/magick/paint.c b/magick/paint.c
index 210bbb0e9c9ae09727aaa512a7c6226d78180bff..0dd9702953400b004de95de7ef0845e1606d7337 100644 (file)
--- a/magick/paint.c
+++ b/magick/paint.c
@@ -761,7 +761,7 @@ MagickExport MagickBooleanType OpaquePaintImage(Image *image,
   const MagickPixelPacket *target,const MagickPixelPacket *fill,
   const MagickBooleanType invert)
 {
-  return(OpaquePaintImageChannel(image,AllChannels,target,fill,invert));
+  return(OpaquePaintImageChannel(image,CompositeChannels,target,fill,invert));
 }
 
 MagickExport MagickBooleanType OpaquePaintImageChannel(Image *image,

diff --git a/magick/statistic.c b/magick/statistic.c
index 1f6ca542d7ea0fd9cb8cf632aed12b33111120d2..16cbcd3bc4aa334be35fae1466be360068770c01 100644 (file)
--- a/magick/statistic.c
+++ b/magick/statistic.c
@@ -409,7 +409,7 @@ MagickExport MagickBooleanType EvaluateImage(Image *image,
   MagickBooleanType
     status;
 
-  status=EvaluateImageChannel(image,AllChannels,op,value,exception);
+  status=EvaluateImageChannel(image,CompositeChannels,op,value,exception);
   return(status);
 }
 
@@ -955,7 +955,7 @@ MagickExport MagickBooleanType FunctionImage(Image *image,
   MagickBooleanType
     status;
 
-  status=FunctionImageChannel(image,AllChannels,function,number_parameters,
+  status=FunctionImageChannel(image,CompositeChannels,function,number_parameters,
     parameters,exception);
   return(status);
 }
@@ -1097,7 +1097,7 @@ MagickExport MagickBooleanType FunctionImageChannel(Image *image,
 MagickExport MagickBooleanType GetImageExtrema(const Image *image,
   size_t *minima,size_t *maxima,ExceptionInfo *exception)
 {
-  return(GetImageChannelExtrema(image,AllChannels,minima,maxima,exception));
+  return(GetImageChannelExtrema(image,CompositeChannels,minima,maxima,exception));
 }
 
 MagickExport MagickBooleanType GetImageChannelExtrema(const Image *image,
@@ -1161,7 +1161,7 @@ MagickExport MagickBooleanType GetImageMean(const Image *image,double *mean,
   MagickBooleanType
     status;
 
-  status=GetImageChannelMean(image,AllChannels,mean,standard_deviation,
+  status=GetImageChannelMean(image,CompositeChannels,mean,standard_deviation,
     exception);
   return(status);
 }
@@ -1184,13 +1184,13 @@ MagickExport MagickBooleanType GetImageChannelMean(const Image *image,
   if (channel_statistics == (ChannelStatistics *) NULL)
     return(MagickFalse);
   channels=0;
-  channel_statistics[AllChannels].mean=0.0;
-  channel_statistics[AllChannels].standard_deviation=0.0;
+  channel_statistics[CompositeChannels].mean=0.0;
+  channel_statistics[CompositeChannels].standard_deviation=0.0;
   if ((channel & RedChannel) != 0)
     {
-      channel_statistics[AllChannels].mean+=
+      channel_statistics[CompositeChannels].mean+=
         channel_statistics[RedChannel].mean;
-      channel_statistics[AllChannels].standard_deviation+=
+      channel_statistics[CompositeChannels].standard_deviation+=
         channel_statistics[RedChannel].variance-
         channel_statistics[RedChannel].mean*
         channel_statistics[RedChannel].mean;
@@ -1198,9 +1198,9 @@ MagickExport MagickBooleanType GetImageChannelMean(const Image *image,
     }
   if ((channel & GreenChannel) != 0)
     {
-      channel_statistics[AllChannels].mean+=
+      channel_statistics[CompositeChannels].mean+=
         channel_statistics[GreenChannel].mean;
-      channel_statistics[AllChannels].standard_deviation+=
+      channel_statistics[CompositeChannels].standard_deviation+=
         channel_statistics[GreenChannel].variance-
         channel_statistics[GreenChannel].mean*
         channel_statistics[GreenChannel].mean;
@@ -1208,9 +1208,9 @@ MagickExport MagickBooleanType GetImageChannelMean(const Image *image,
     }
   if ((channel & BlueChannel) != 0)
     {
-      channel_statistics[AllChannels].mean+=
+      channel_statistics[CompositeChannels].mean+=
         channel_statistics[BlueChannel].mean;
-      channel_statistics[AllChannels].standard_deviation+=
+      channel_statistics[CompositeChannels].standard_deviation+=
         channel_statistics[BlueChannel].variance-
         channel_statistics[BlueChannel].mean*
         channel_statistics[BlueChannel].mean;
@@ -1219,9 +1219,9 @@ MagickExport MagickBooleanType GetImageChannelMean(const Image *image,
   if (((channel & OpacityChannel) != 0) &&
       (image->matte != MagickFalse))
     {
-      channel_statistics[AllChannels].mean+=
+      channel_statistics[CompositeChannels].mean+=
         channel_statistics[OpacityChannel].mean;
-      channel_statistics[AllChannels].standard_deviation+=
+      channel_statistics[CompositeChannels].standard_deviation+=
         channel_statistics[OpacityChannel].variance-
         channel_statistics[OpacityChannel].mean*
         channel_statistics[OpacityChannel].mean;
@@ -1230,19 +1230,19 @@ MagickExport MagickBooleanType GetImageChannelMean(const Image *image,
   if (((channel & IndexChannel) != 0) &&
       (image->colorspace == CMYKColorspace))
     {
-      channel_statistics[AllChannels].mean+=
+      channel_statistics[CompositeChannels].mean+=
         channel_statistics[BlackChannel].mean;
-      channel_statistics[AllChannels].standard_deviation+=
+      channel_statistics[CompositeChannels].standard_deviation+=
         channel_statistics[BlackChannel].variance-
         channel_statistics[BlackChannel].mean*
         channel_statistics[BlackChannel].mean;
       channels++;
     }
-  channel_statistics[AllChannels].mean/=channels;
-  channel_statistics[AllChannels].standard_deviation=
-    sqrt(channel_statistics[AllChannels].standard_deviation/channels);
-  *mean=channel_statistics[AllChannels].mean;
-  *standard_deviation=channel_statistics[AllChannels].standard_deviation;
+  channel_statistics[CompositeChannels].mean/=channels;
+  channel_statistics[CompositeChannels].standard_deviation=
+    sqrt(channel_statistics[CompositeChannels].standard_deviation/channels);
+  *mean=channel_statistics[CompositeChannels].mean;
+  *standard_deviation=channel_statistics[CompositeChannels].standard_deviation;
   channel_statistics=(ChannelStatistics *) RelinquishMagickMemory(
     channel_statistics);
   return(MagickTrue);
@@ -1288,7 +1288,7 @@ MagickExport MagickBooleanType GetImageKurtosis(const Image *image,
   MagickBooleanType
     status;
 
-  status=GetImageChannelKurtosis(image,AllChannels,kurtosis,skewness,
+  status=GetImageChannelKurtosis(image,CompositeChannels,kurtosis,skewness,
     exception);
   return(status);
 }
@@ -1445,7 +1445,7 @@ MagickExport MagickBooleanType GetImageChannelKurtosis(const Image *image,
 MagickExport MagickBooleanType GetImageRange(const Image *image,
   double *minima,double *maxima,ExceptionInfo *exception)
 {
-  return(GetImageChannelRange(image,AllChannels,minima,maxima,exception));
+  return(GetImageChannelRange(image,CompositeChannels,minima,maxima,exception));
 }
 
 MagickExport MagickBooleanType GetImageChannelRange(const Image *image,
@@ -1588,14 +1588,14 @@ MagickExport ChannelStatistics *GetImageChannelStatistics(const Image *image,
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
-  length=AllChannels+1UL;
+  length=CompositeChannels+1UL;
   channel_statistics=(ChannelStatistics *) AcquireQuantumMemory(length,
     sizeof(*channel_statistics));
   if (channel_statistics == (ChannelStatistics *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(channel_statistics,0,length*
     sizeof(*channel_statistics));
-  for (i=0; i <= AllChannels; i++)
+  for (i=0; i <= CompositeChannels; i++)
   {
     channel_statistics[i].depth=1;
     channel_statistics[i].maxima=(-1.0E-37);
@@ -1756,7 +1756,7 @@ MagickExport ChannelStatistics *GetImageChannelStatistics(const Image *image,
     }
   }
   area=(double) image->columns*image->rows;
-  for (i=0; i < AllChannels; i++)
+  for (i=0; i < CompositeChannels; i++)
   {
     channel_statistics[i].sum/=area;
     channel_statistics[i].sum_squared/=area;
@@ -1768,25 +1768,25 @@ MagickExport ChannelStatistics *GetImageChannelStatistics(const Image *image,
       channel_statistics[i].variance-(channel_statistics[i].mean*
       channel_statistics[i].mean));
   }
-  for (i=0; i < AllChannels; i++)
+  for (i=0; i < CompositeChannels; i++)
   {
-    channel_statistics[AllChannels].depth=(size_t) MagickMax((double)
-      channel_statistics[AllChannels].depth,(double)
+    channel_statistics[CompositeChannels].depth=(size_t) MagickMax((double)
+      channel_statistics[CompositeChannels].depth,(double)
       channel_statistics[i].depth);
-    channel_statistics[AllChannels].minima=MagickMin(
-      channel_statistics[AllChannels].minima,channel_statistics[i].minima);
-    channel_statistics[AllChannels].maxima=MagickMax(
-      channel_statistics[AllChannels].maxima,channel_statistics[i].maxima);
-    channel_statistics[AllChannels].sum+=channel_statistics[i].sum;
-    channel_statistics[AllChannels].sum_squared+=
+    channel_statistics[CompositeChannels].minima=MagickMin(
+      channel_statistics[CompositeChannels].minima,channel_statistics[i].minima);
+    channel_statistics[CompositeChannels].maxima=MagickMax(
+      channel_statistics[CompositeChannels].maxima,channel_statistics[i].maxima);
+    channel_statistics[CompositeChannels].sum+=channel_statistics[i].sum;
+    channel_statistics[CompositeChannels].sum_squared+=
       channel_statistics[i].sum_squared;
-    channel_statistics[AllChannels].sum_cubed+=channel_statistics[i].sum_cubed;
-    channel_statistics[AllChannels].sum_fourth_power+=
+    channel_statistics[CompositeChannels].sum_cubed+=channel_statistics[i].sum_cubed;
+    channel_statistics[CompositeChannels].sum_fourth_power+=
       channel_statistics[i].sum_fourth_power;
-    channel_statistics[AllChannels].mean+=channel_statistics[i].mean;
-    channel_statistics[AllChannels].variance+=channel_statistics[i].variance-
+    channel_statistics[CompositeChannels].mean+=channel_statistics[i].mean;
+    channel_statistics[CompositeChannels].variance+=channel_statistics[i].variance-
       channel_statistics[i].mean*channel_statistics[i].mean;
-    channel_statistics[AllChannels].standard_deviation+=
+    channel_statistics[CompositeChannels].standard_deviation+=
       channel_statistics[i].variance-channel_statistics[i].mean*
       channel_statistics[i].mean;
   }
@@ -1795,17 +1795,17 @@ MagickExport ChannelStatistics *GetImageChannelStatistics(const Image *image,
     channels++;
   if (image->colorspace == CMYKColorspace)
     channels++;
-  channel_statistics[AllChannels].sum/=channels;
-  channel_statistics[AllChannels].sum_squared/=channels;
-  channel_statistics[AllChannels].sum_cubed/=channels;
-  channel_statistics[AllChannels].sum_fourth_power/=channels;
-  channel_statistics[AllChannels].mean/=channels;
-  channel_statistics[AllChannels].variance/=channels;
-  channel_statistics[AllChannels].standard_deviation=
-    sqrt(channel_statistics[AllChannels].standard_deviation/channels);
-  channel_statistics[AllChannels].kurtosis/=channels;
-  channel_statistics[AllChannels].skewness/=channels;
-  for (i=0; i <= AllChannels; i++)
+  channel_statistics[CompositeChannels].sum/=channels;
+  channel_statistics[CompositeChannels].sum_squared/=channels;
+  channel_statistics[CompositeChannels].sum_cubed/=channels;
+  channel_statistics[CompositeChannels].sum_fourth_power/=channels;
+  channel_statistics[CompositeChannels].mean/=channels;
+  channel_statistics[CompositeChannels].variance/=channels;
+  channel_statistics[CompositeChannels].standard_deviation=
+    sqrt(channel_statistics[CompositeChannels].standard_deviation/channels);
+  channel_statistics[CompositeChannels].kurtosis/=channels;
+  channel_statistics[CompositeChannels].skewness/=channels;
+  for (i=0; i <= CompositeChannels; i++)
   {
     if (channel_statistics[i].standard_deviation == 0.0)
       continue;

diff --git a/magick/threshold.c b/magick/threshold.c
index 35e2a5b24d5f5fba26dea654bdd97b051fda2df0..a40c5f1d39727d153fb0272e150bf11f9dc46388 100644 (file)
--- a/magick/threshold.c
+++ b/magick/threshold.c
@@ -1704,7 +1704,7 @@ MagickExport MagickBooleanType RandomThresholdImageChannel(Image *image,
   */
   status=MagickTrue;
   progress=0;
-  if (channel == AllChannels)
+  if (channel == CompositeChannels)
     {
       if (AcquireImageColormap(image,2) == MagickFalse)
         ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",

diff --git a/tests/validate.c b/tests/validate.c
index a090a2b08373eef4bf838b4f0f988c1c0031fa23..d2fc7b406612923ce41ed4631e123aba921c68b8 100644 (file)
--- a/tests/validate.c
+++ b/tests/validate.c
@@ -598,7 +598,7 @@ static size_t ValidateImageFormatsInMemory(ImageInfo *image_info,
         fuzz+=0.3;
       fuzz+=MagickEpsilon;
       difference_image=CompareImageChannels(reference_image,reconstruct_image,
-        AllChannels,MeanSquaredErrorMetric,&distortion,exception);
+        CompositeChannels,MeanSquaredErrorMetric,&distortion,exception);
       reconstruct_image=DestroyImage(reconstruct_image);
       reference_image=DestroyImage(reference_image);
       if (difference_image == (Image *) NULL)
@@ -806,7 +806,7 @@ static size_t ValidateImageFormatsOnDisk(ImageInfo *image_info,
         fuzz+=0.3;
       fuzz+=MagickEpsilon;
       difference_image=CompareImageChannels(reference_image,reconstruct_image,
-        AllChannels,MeanSquaredErrorMetric,&distortion,exception);
+        CompositeChannels,MeanSquaredErrorMetric,&distortion,exception);
       reconstruct_image=DestroyImage(reconstruct_image);
       reference_image=DestroyImage(reference_image);
       if (difference_image == (Image *) NULL)
@@ -977,7 +977,7 @@ static size_t ValidateImportExportPixels(ImageInfo *image_info,
         Compare reference to reconstruct image.
       */
       difference_image=CompareImageChannels(reference_image,reconstruct_image,
-        AllChannels,MeanSquaredErrorMetric,&distortion,exception);
+        CompositeChannels,MeanSquaredErrorMetric,&distortion,exception);
       reconstruct_image=DestroyImage(reconstruct_image);
       reference_image=DestroyImage(reference_image);
       if (difference_image == (Image *) NULL)

diff --git a/wand/compare.c b/wand/compare.c
index adf6ff2853d1373af48bcb1fb45bf47a4731e8d8..f1cdd3f186dd05f326db57e42359a98e4891dd49 100644 (file)
--- a/wand/compare.c
+++ b/wand/compare.c
@@ -271,7 +271,7 @@ WandExport MagickBooleanType CompareImageCommand(ImageInfo *image_info,
     }
   if (argc < 3)
     return(CompareUsage());
-  channels=AllChannels;
+  channels=CompositeChannels;
   difference_image=NewImageList();
   similarity_image=NewImageList();
   dissimilarity_threshold=DefaultDissimilarityThreshold;
@@ -1117,8 +1117,8 @@ WandExport MagickBooleanType CompareImageCommand(ImageInfo *image_info,
                 }
               }
               (void) fprintf(stderr,"    all: %g (%g)\n",
-                QuantumRange*channel_distortion[AllChannels],
-                channel_distortion[AllChannels]);
+                QuantumRange*channel_distortion[CompositeChannels],
+                channel_distortion[CompositeChannels]);
               break;
             }
             case AbsoluteErrorMetric:
@@ -1167,13 +1167,13 @@ WandExport MagickBooleanType CompareImageCommand(ImageInfo *image_info,
                 }
               }
               (void) fprintf(stderr,"    all: %g\n",
-                channel_distortion[AllChannels]);
+                channel_distortion[CompositeChannels]);
               break;
             }
             case MeanErrorPerPixelMetric:
             {
               (void) fprintf(stderr,"    %g (%g, %g)\n",
-                channel_distortion[AllChannels],
+                channel_distortion[CompositeChannels],
                 image->error.normalized_mean_error,
                 image->error.normalized_maximum_error);
               break;

diff --git a/wand/wandtest.c b/wand/wandtest.c
index 9ac55c75bf65a2a49c408d0f06eebe9cd3db7947..9cc42b62467d4635cbd82f2cff8c1b3b08bc7730 100644 (file)
--- a/wand/wandtest.c
+++ b/wand/wandtest.c
@@ -507,7 +507,7 @@ int main(int argc,char **argv)
   border=NewPixelWand();
   (void) PixelSetColor(background,"green");
   (void) PixelSetColor(border,"black");
-  status=MagickFloodfillPaintImage(magick_wand,AllChannels,background,
+  status=MagickFloodfillPaintImage(magick_wand,CompositeChannels,background,
     0.01*QuantumRange,border,0,0,MagickFalse);
   if (status == MagickFalse)
     ThrowAPIException(magick_wand);