(no commit message)

diff --git a/magick/feature.c b/magick/feature.c
index fa5501bb54c2a40290924226c8c036f07a996783..57c3a1c23cf9492344f5d25bac6b030b31af476e 100644 (file)
--- a/magick/feature.c
+++ b/magick/feature.c
@@ -253,12 +253,12 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
         ScaleQuantumToMap(GetGreenPixelComponent(p));
       grays[ScaleQuantumToMap(GetBluePixelComponent(p))].blue=
         ScaleQuantumToMap(GetBluePixelComponent(p));
-      if (image->matte != MagickFalse)
-        grays[ScaleQuantumToMap(GetOpacityPixelComponent(p))].opacity=
-          ScaleQuantumToMap(GetOpacityPixelComponent(p));
       if (image->colorspace == CMYKColorspace)
         grays[ScaleQuantumToMap(GetIndexPixelComponent(indexes+x))].index=
           ScaleQuantumToMap(GetIndexPixelComponent(indexes+x));
+      if (image->matte != MagickFalse)
+        grays[ScaleQuantumToMap(GetOpacityPixelComponent(p))].opacity=
+          ScaleQuantumToMap(GetOpacityPixelComponent(p));
       p++;
     }
   }
@@ -274,17 +274,17 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
   for (i=0; i <= (ssize_t) MaxMap; i++)
   {
     if (grays[i].red != ~0U)
-      grays[gray.red++].red=grays[i].red;
+      grays[(ssize_t) gray.red++].red=grays[i].red;
     if (grays[i].green != ~0U)
-      grays[gray.green++].green=grays[i].green;
+      grays[(ssize_t) gray.green++].green=grays[i].green;
     if (grays[i].blue != ~0U)
-      grays[gray.blue++].blue=grays[i].blue;
-    if (image->matte != MagickFalse)
-      if (grays[i].opacity != ~0U)
-        grays[gray.opacity++].opacity=grays[i].opacity;
+      grays[(ssize_t) gray.blue++].blue=grays[i].blue;
     if (image->colorspace == CMYKColorspace)
       if (grays[i].index != ~0U)
-        grays[gray.index++].index=grays[i].index;
+        grays[(ssize_t) gray.index++].index=grays[i].index;
+    if (image->matte != MagickFalse)
+      if (grays[i].opacity != ~0U)
+        grays[(ssize_t) gray.opacity++].opacity=grays[i].opacity;
   }
   /*
     Allocate spatial dependence matrix.
@@ -294,12 +294,12 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
     number_grays=gray.green;
   if (gray.blue > number_grays)
     number_grays=gray.blue;
-  if (image->matte != MagickFalse)
-    if (gray.opacity > number_grays)
-      number_grays=gray.opacity;
   if (image->colorspace == CMYKColorspace)
     if (gray.index > number_grays)
       number_grays=gray.index;
+  if (image->matte != MagickFalse)
+    if (gray.opacity > number_grays)
+      number_grays=gray.opacity;
   cooccurrence=(ChannelStatistics **) AcquireQuantumMemory(number_grays,
     sizeof(*cooccurrence));
   density_x=(ChannelStatistics *) AcquireQuantumMemory(2*(number_grays+1),
@@ -400,9 +400,6 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
   */
   status=MagickTrue;
   image_view=AcquireCacheView(image);
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
-  #pragma omp parallel for schedule(dynamic,4) shared(status)
-#endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register const IndexPacket
@@ -415,6 +412,7 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
       x;
 
     ssize_t
+      i,
       offset,
       u,
       v;
@@ -422,7 +420,7 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
     if (status == MagickFalse)
       continue;
     p=GetCacheViewVirtualPixels(image_view,-(ssize_t) distance,y,image->columns+
-      2*distance,distance+2,exception);
+      2*distance,distance+1,exception);
     if (p == (const PixelPacket *) NULL)
       {
         status=MagickFalse;
@@ -495,27 +493,27 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
           v++;
         cooccurrence[u][v].direction[i].blue++;
         cooccurrence[v][u].direction[i].blue++;
-        if (image->matte != MagickFalse)
+        if (image->colorspace == CMYKColorspace)
           {
             u=0;
             v=0;
-            while (grays[u].opacity != ScaleQuantumToMap(GetOpacityPixelComponent(p)))
+            while (grays[u].index != ScaleQuantumToMap(GetIndexPixelComponent(indexes+x)))
               u++;
-            while (grays[v].opacity != ScaleQuantumToMap((p+offset)->opacity))
+            while (grays[v].index != ScaleQuantumToMap(GetIndexPixelComponent(indexes+x+offset)))
               v++;
-            cooccurrence[u][v].direction[i].opacity++;
-            cooccurrence[v][u].direction[i].opacity++;
+            cooccurrence[u][v].direction[i].index++;
+            cooccurrence[v][u].direction[i].index++;
           }
-        if (image->colorspace == CMYKColorspace)
+        if (image->matte != MagickFalse)
           {
             u=0;
             v=0;
-            while (grays[u].index != ScaleQuantumToMap(GetIndexPixelComponent(indexes+x)))
+            while (grays[u].opacity != ScaleQuantumToMap(GetOpacityPixelComponent(p)))
               u++;
-            while (grays[v].index != ScaleQuantumToMap(GetIndexPixelComponent(indexes+x+offset)))
+            while (grays[v].opacity != ScaleQuantumToMap((p+offset)->opacity))
               v++;
-            cooccurrence[u][v].direction[i].index++;
-            cooccurrence[v][u].direction[i].index++;
+            cooccurrence[u][v].direction[i].opacity++;
+            cooccurrence[v][u].direction[i].opacity++;
           }
       }
       p++;
@@ -538,14 +536,14 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
   /*
     Normalize spatial dependence matrix.
   */
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
-  #pragma omp parallel for schedule(dynamic,4) shared(status)
-#endif
   for (i=0; i < 4; i++)
   {
     double
       normalize;
 
+    register ssize_t
+      y;
+
     switch (i)
     {
       case 0:
@@ -582,6 +580,7 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
         break;
       }
     }
+    normalize=1.0/(fabs((double) normalize) <= MagickEpsilon ? 1.0 : normalize);
     for (y=0; y < (ssize_t) number_grays; y++)
     {
       register ssize_t
@@ -589,13 +588,13 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
 
       for (x=0; x < (ssize_t) number_grays; x++)
       {
-        cooccurrence[x][y].direction[i].red/=normalize;
-        cooccurrence[x][y].direction[i].green/=normalize;
-        cooccurrence[x][y].direction[i].blue/=normalize;
-        if (image->matte != MagickFalse)
-          cooccurrence[x][y].direction[i].opacity/=normalize;
+        cooccurrence[x][y].direction[i].red*=normalize;
+        cooccurrence[x][y].direction[i].green*=normalize;
+        cooccurrence[x][y].direction[i].blue*=normalize;
         if (image->colorspace == CMYKColorspace)
-          cooccurrence[x][y].direction[i].index/=normalize;
+          cooccurrence[x][y].direction[i].index*=normalize;
+        if (image->matte != MagickFalse)
+          cooccurrence[x][y].direction[i].opacity*=normalize;
       }
     }
   }
@@ -629,35 +628,35 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
         channel_features[BlueChannel].angular_second_moment[i]+=
           cooccurrence[x][y].direction[i].blue*
           cooccurrence[x][y].direction[i].blue;
-        if (image->matte != MagickFalse)
-          channel_features[OpacityChannel].angular_second_moment[i]+=
-            cooccurrence[x][y].direction[i].opacity*
-            cooccurrence[x][y].direction[i].opacity;
         if (image->colorspace == CMYKColorspace)
           channel_features[BlackChannel].angular_second_moment[i]+=
             cooccurrence[x][y].direction[i].index*
             cooccurrence[x][y].direction[i].index;
+        if (image->matte != MagickFalse)
+          channel_features[OpacityChannel].angular_second_moment[i]+=
+            cooccurrence[x][y].direction[i].opacity*
+            cooccurrence[x][y].direction[i].opacity;
         /*
           Correlation: measure of linear-dependencies in the image.
         */
         sum[y].direction[i].red+=cooccurrence[x][y].direction[i].red;
         sum[y].direction[i].green+=cooccurrence[x][y].direction[i].green;
         sum[y].direction[i].blue+=cooccurrence[x][y].direction[i].blue;
-        if (image->matte != MagickFalse)
-          sum[y].direction[i].opacity+=cooccurrence[x][y].direction[i].opacity;
         if (image->colorspace == CMYKColorspace)
           sum[y].direction[i].index+=cooccurrence[x][y].direction[i].index;
+        if (image->matte != MagickFalse)
+          sum[y].direction[i].opacity+=cooccurrence[x][y].direction[i].opacity;
         correlation.direction[i].red+=x*y*cooccurrence[x][y].direction[i].red;
         correlation.direction[i].green+=x*y*
           cooccurrence[x][y].direction[i].green;
         correlation.direction[i].blue+=x*y*
           cooccurrence[x][y].direction[i].blue;
-        if (image->matte != MagickFalse)
-          correlation.direction[i].opacity+=x*y*
-            cooccurrence[x][y].direction[i].opacity;
         if (image->colorspace == CMYKColorspace)
           correlation.direction[i].index+=x*y*
             cooccurrence[x][y].direction[i].index;
+        if (image->matte != MagickFalse)
+          correlation.direction[i].opacity+=x*y*
+            cooccurrence[x][y].direction[i].opacity;
         /*
           Inverse Difference Moment.
         */
@@ -667,12 +666,12 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
           cooccurrence[x][y].direction[i].green/((y-x)*(y-x)+1);
         channel_features[BlueChannel].inverse_difference_moment[i]+=
           cooccurrence[x][y].direction[i].blue/((y-x)*(y-x)+1);
-        if (image->matte != MagickFalse)
-          channel_features[OpacityChannel].inverse_difference_moment[i]+=
-            cooccurrence[x][y].direction[i].opacity/((y-x)*(y-x)+1);
         if (image->colorspace == CMYKColorspace)
           channel_features[IndexChannel].inverse_difference_moment[i]+=
             cooccurrence[x][y].direction[i].index/((y-x)*(y-x)+1);
+        if (image->matte != MagickFalse)
+          channel_features[OpacityChannel].inverse_difference_moment[i]+=
+            cooccurrence[x][y].direction[i].opacity/((y-x)*(y-x)+1);
         /*
           Sum average.
         */
@@ -682,12 +681,12 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
           cooccurrence[x][y].direction[i].green;
         density_xy[y+x+2].direction[i].blue+=
           cooccurrence[x][y].direction[i].blue;
-        if (image->matte != MagickFalse)
-          density_xy[y+x+2].direction[i].opacity+=
-            cooccurrence[x][y].direction[i].opacity;
         if (image->colorspace == CMYKColorspace)
           density_xy[y+x+2].direction[i].index+=
             cooccurrence[x][y].direction[i].index;
+        if (image->matte != MagickFalse)
+          density_xy[y+x+2].direction[i].opacity+=
+            cooccurrence[x][y].direction[i].opacity;
         /*
           Entropy.
         */
@@ -700,35 +699,35 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
         channel_features[BlueChannel].entropy[i]-=
           cooccurrence[x][y].direction[i].blue*
           log10(cooccurrence[x][y].direction[i].blue+MagickEpsilon);
-        if (image->matte != MagickFalse)
-          channel_features[OpacityChannel].entropy[i]-=
-            cooccurrence[x][y].direction[i].opacity*
-            log10(cooccurrence[x][y].direction[i].opacity+MagickEpsilon);
         if (image->colorspace == CMYKColorspace)
           channel_features[IndexChannel].entropy[i]-=
             cooccurrence[x][y].direction[i].index*
             log10(cooccurrence[x][y].direction[i].index+MagickEpsilon);
+        if (image->matte != MagickFalse)
+          channel_features[OpacityChannel].entropy[i]-=
+            cooccurrence[x][y].direction[i].opacity*
+            log10(cooccurrence[x][y].direction[i].opacity+MagickEpsilon);
         /*
           Information Measures of Correlation.
         */
         density_x[x].direction[i].red+=cooccurrence[x][y].direction[i].red;
         density_x[x].direction[i].green+=cooccurrence[x][y].direction[i].green;
         density_x[x].direction[i].blue+=cooccurrence[x][y].direction[i].blue;
-        if (image->matte != MagickFalse)
-          density_x[x].direction[i].opacity+=
-            cooccurrence[x][y].direction[i].opacity;
         if (image->colorspace == CMYKColorspace)
           density_x[x].direction[i].index+=
             cooccurrence[x][y].direction[i].index;
+        if (image->matte != MagickFalse)
+          density_x[x].direction[i].opacity+=
+            cooccurrence[x][y].direction[i].opacity;
         density_y[y].direction[i].red+=cooccurrence[x][y].direction[i].red;
         density_y[y].direction[i].green+=cooccurrence[x][y].direction[i].green;
         density_y[y].direction[i].blue+=cooccurrence[x][y].direction[i].blue;
-        if (image->matte != MagickFalse)
-          density_y[y].direction[i].opacity+=
-            cooccurrence[x][y].direction[i].opacity;
         if (image->colorspace == CMYKColorspace)
           density_y[y].direction[i].index+=
             cooccurrence[x][y].direction[i].index;
+        if (image->matte != MagickFalse)
+          density_y[y].direction[i].opacity+=
+            cooccurrence[x][y].direction[i].opacity;
       }
       mean.direction[i].red+=y*sum[y].direction[i].red;
       sum_squares.direction[i].red+=y*y*sum[y].direction[i].red;
@@ -736,16 +735,16 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
       sum_squares.direction[i].green+=y*y*sum[y].direction[i].green;
       mean.direction[i].blue+=y*sum[y].direction[i].blue;
       sum_squares.direction[i].blue+=y*y*sum[y].direction[i].blue;
-      if (image->matte != MagickFalse)
-        {
-          mean.direction[i].opacity+=y*sum[y].direction[i].opacity;
-          sum_squares.direction[i].opacity+=y*y*sum[y].direction[i].opacity;
-        }
       if (image->colorspace == CMYKColorspace)
         {
           mean.direction[i].index+=y*sum[y].direction[i].index;
           sum_squares.direction[i].index+=y*y*sum[y].direction[i].index;
         }
+      if (image->matte != MagickFalse)
+        {
+          mean.direction[i].opacity+=y*sum[y].direction[i].opacity;
+          sum_squares.direction[i].opacity+=y*y*sum[y].direction[i].opacity;
+        }
     }
     /*
       Correlation: measure of linear-dependencies in the image.
@@ -768,13 +767,6 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
       (mean.direction[i].blue*mean.direction[i].blue))*sqrt(
       sum_squares.direction[i].blue-(mean.direction[i].blue*
       mean.direction[i].blue)));
-    if (image->matte != MagickFalse)
-      channel_features[OpacityChannel].correlation[i]=
-        (correlation.direction[i].opacity-mean.direction[i].opacity*
-        mean.direction[i].opacity)/(sqrt(sum_squares.direction[i].opacity-
-        (mean.direction[i].opacity*mean.direction[i].opacity))*sqrt(
-        sum_squares.direction[i].opacity-(mean.direction[i].opacity*
-        mean.direction[i].opacity)));
     if (image->colorspace == CMYKColorspace)
       channel_features[IndexChannel].correlation[i]=
         (correlation.direction[i].index-mean.direction[i].index*
@@ -782,6 +774,13 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
         (mean.direction[i].index*mean.direction[i].index))*sqrt(
         sum_squares.direction[i].index-(mean.direction[i].index*
         mean.direction[i].index)));
+    if (image->matte != MagickFalse)
+      channel_features[OpacityChannel].correlation[i]=
+        (correlation.direction[i].opacity-mean.direction[i].opacity*
+        mean.direction[i].opacity)/(sqrt(sum_squares.direction[i].opacity-
+        (mean.direction[i].opacity*mean.direction[i].opacity))*sqrt(
+        sum_squares.direction[i].opacity-(mean.direction[i].opacity*
+        mean.direction[i].opacity)));
   }
   /*
     Compute more texture features.
@@ -805,12 +804,12 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
         x*density_xy[x].direction[i].green;
       channel_features[BlueChannel].sum_average[i]+=
         x*density_xy[x].direction[i].blue;
-      if (image->matte != MagickFalse)
-        channel_features[OpacityChannel].sum_average[i]+=
-          x*density_xy[x].direction[i].opacity;
       if (image->colorspace == CMYKColorspace)
         channel_features[IndexChannel].sum_average[i]+=
           x*density_xy[x].direction[i].index;
+      if (image->matte != MagickFalse)
+        channel_features[OpacityChannel].sum_average[i]+=
+          x*density_xy[x].direction[i].opacity;
       /*
         Sum entropy.
       */
@@ -823,14 +822,14 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
       channel_features[BlueChannel].sum_entropy[i]-=
         density_xy[x].direction[i].blue*
         log10(density_xy[x].direction[i].blue+MagickEpsilon);
-      if (image->matte != MagickFalse)
-        channel_features[OpacityChannel].sum_entropy[i]-=
-          density_xy[x].direction[i].opacity*
-          log10(density_xy[x].direction[i].opacity+MagickEpsilon);
       if (image->colorspace == CMYKColorspace)
         channel_features[IndexChannel].sum_entropy[i]-=
           density_xy[x].direction[i].index*
           log10(density_xy[x].direction[i].index+MagickEpsilon);
+      if (image->matte != MagickFalse)
+        channel_features[OpacityChannel].sum_entropy[i]-=
+          density_xy[x].direction[i].opacity*
+          log10(density_xy[x].direction[i].opacity+MagickEpsilon);
       /*
         Sum variance.
       */
@@ -846,16 +845,16 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
         (x-channel_features[BlueChannel].sum_entropy[i])*
         (x-channel_features[BlueChannel].sum_entropy[i])*
         density_xy[x].direction[i].blue;
-      if (image->matte != MagickFalse)
-        channel_features[OpacityChannel].sum_variance[i]+=
-          (x-channel_features[OpacityChannel].sum_entropy[i])*
-          (x-channel_features[OpacityChannel].sum_entropy[i])*
-          density_xy[x].direction[i].opacity;
       if (image->colorspace == CMYKColorspace)
         channel_features[IndexChannel].sum_variance[i]+=
           (x-channel_features[IndexChannel].sum_entropy[i])*
           (x-channel_features[IndexChannel].sum_entropy[i])*
           density_xy[x].direction[i].index;
+      if (image->matte != MagickFalse)
+        channel_features[OpacityChannel].sum_variance[i]+=
+          (x-channel_features[OpacityChannel].sum_entropy[i])*
+          (x-channel_features[OpacityChannel].sum_entropy[i])*
+          density_xy[x].direction[i].opacity;
     }
   }
   /*
@@ -885,13 +884,13 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
           (y-mean.direction[i].green+1)*cooccurrence[x][y].direction[i].green;
         variance.direction[i].blue+=(y-mean.direction[i].blue+1)*
           (y-mean.direction[i].blue+1)*cooccurrence[x][y].direction[i].blue;
+        if (image->colorspace == CMYKColorspace)
+          variance.direction[i].index+=(y-mean.direction[i].index+1)*
+            (y-mean.direction[i].index+1)*cooccurrence[x][y].direction[i].index;
         if (image->matte != MagickFalse)
           variance.direction[i].opacity+=(y-mean.direction[i].opacity+1)*
             (y-mean.direction[i].opacity+1)*
             cooccurrence[x][y].direction[i].opacity;
-        if (image->colorspace == CMYKColorspace)
-          variance.direction[i].index+=(y-mean.direction[i].index+1)*
-            (y-mean.direction[i].index+1)*cooccurrence[x][y].direction[i].index;
         /*
           Sum average / Difference Variance.
         */
@@ -901,12 +900,12 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
           cooccurrence[x][y].direction[i].green;
         density_xy[MagickAbsoluteValue(y-x)].direction[i].blue+=
           cooccurrence[x][y].direction[i].blue;
-        if (image->matte != MagickFalse)
-          density_xy[MagickAbsoluteValue(y-x)].direction[i].opacity+=
-            cooccurrence[x][y].direction[i].opacity;
         if (image->colorspace == CMYKColorspace)
           density_xy[MagickAbsoluteValue(y-x)].direction[i].index+=
             cooccurrence[x][y].direction[i].index;
+        if (image->matte != MagickFalse)
+          density_xy[MagickAbsoluteValue(y-x)].direction[i].opacity+=
+            cooccurrence[x][y].direction[i].opacity;
         /*
           Information Measures of Correlation.
         */
@@ -916,13 +915,13 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
           log10(cooccurrence[x][y].direction[i].green+MagickEpsilon);
         entropy_xy.direction[i].blue-=cooccurrence[x][y].direction[i].blue*
           log10(cooccurrence[x][y].direction[i].blue+MagickEpsilon);
+        if (image->colorspace == CMYKColorspace)
+          entropy_xy.direction[i].index-=cooccurrence[x][y].direction[i].index*
+            log10(cooccurrence[x][y].direction[i].index+MagickEpsilon);
         if (image->matte != MagickFalse)
           entropy_xy.direction[i].opacity-=
             cooccurrence[x][y].direction[i].opacity*log10(
             cooccurrence[x][y].direction[i].opacity+MagickEpsilon);
-        if (image->colorspace == CMYKColorspace)
-          entropy_xy.direction[i].index-=cooccurrence[x][y].direction[i].index*
-            log10(cooccurrence[x][y].direction[i].index+MagickEpsilon);
         entropy_xy1.direction[i].red-=(cooccurrence[x][y].direction[i].red*
           log10(density_x[x].direction[i].red*density_y[y].direction[i].red+
           MagickEpsilon));
@@ -932,16 +931,16 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
         entropy_xy1.direction[i].blue-=(cooccurrence[x][y].direction[i].blue*
           log10(density_x[x].direction[i].blue*density_y[y].direction[i].blue+
           MagickEpsilon));
-        if (image->matte != MagickFalse)
-          entropy_xy1.direction[i].opacity-=(
-            cooccurrence[x][y].direction[i].opacity*log10(
-            density_x[x].direction[i].opacity*density_y[y].direction[i].opacity+
-            MagickEpsilon));
         if (image->colorspace == CMYKColorspace)
           entropy_xy1.direction[i].index-=(
             cooccurrence[x][y].direction[i].index*log10(
             density_x[x].direction[i].index*density_y[y].direction[i].index+
             MagickEpsilon));
+        if (image->matte != MagickFalse)
+          entropy_xy1.direction[i].opacity-=(
+            cooccurrence[x][y].direction[i].opacity*log10(
+            density_x[x].direction[i].opacity*density_y[y].direction[i].opacity+
+            MagickEpsilon));
         entropy_xy2.direction[i].red-=(density_x[x].direction[i].red*
           density_y[y].direction[i].red*log10(density_x[x].direction[i].red*
           density_y[y].direction[i].red+MagickEpsilon));
@@ -951,16 +950,16 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
         entropy_xy2.direction[i].blue-=(density_x[x].direction[i].blue*
           density_y[y].direction[i].blue*log10(density_x[x].direction[i].blue*
           density_y[y].direction[i].blue+MagickEpsilon));
-        if (image->matte != MagickFalse)
-          entropy_xy2.direction[i].opacity-=(density_x[x].direction[i].opacity*
-            density_y[y].direction[i].opacity*log10(
-            density_x[x].direction[i].opacity*density_y[y].direction[i].opacity+
-            MagickEpsilon));
         if (image->colorspace == CMYKColorspace)
           entropy_xy2.direction[i].index-=(density_x[x].direction[i].index*
             density_y[y].direction[i].index*log10(
             density_x[x].direction[i].index*density_y[y].direction[i].index+
             MagickEpsilon));
+        if (image->matte != MagickFalse)
+          entropy_xy2.direction[i].opacity-=(density_x[x].direction[i].opacity*
+            density_y[y].direction[i].opacity*log10(
+            density_x[x].direction[i].opacity*density_y[y].direction[i].opacity+
+            MagickEpsilon));
       }
     }
     channel_features[RedChannel].variance_sum_of_squares[i]=
@@ -969,12 +968,12 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
       variance.direction[i].green;
     channel_features[BlueChannel].variance_sum_of_squares[i]=
       variance.direction[i].blue;
-    if (image->matte != MagickFalse)
-      channel_features[RedChannel].variance_sum_of_squares[i]=
-        variance.direction[i].opacity;
     if (image->colorspace == CMYKColorspace)
       channel_features[RedChannel].variance_sum_of_squares[i]=
         variance.direction[i].index;
+    if (image->matte != MagickFalse)
+      channel_features[RedChannel].variance_sum_of_squares[i]=
+        variance.direction[i].opacity;
   }
   /*
     Compute more texture features.
@@ -997,22 +996,22 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
       variance.direction[i].red+=density_xy[x].direction[i].red;
       variance.direction[i].green+=density_xy[x].direction[i].green;
       variance.direction[i].blue+=density_xy[x].direction[i].blue;
-      if (image->matte != MagickFalse)
-        variance.direction[i].opacity+=density_xy[x].direction[i].opacity;
       if (image->colorspace == CMYKColorspace)
         variance.direction[i].index+=density_xy[x].direction[i].index;
+      if (image->matte != MagickFalse)
+        variance.direction[i].opacity+=density_xy[x].direction[i].opacity;
       sum_squares.direction[i].red+=density_xy[x].direction[i].red*
         density_xy[x].direction[i].red;
       sum_squares.direction[i].green+=density_xy[x].direction[i].green*
         density_xy[x].direction[i].green;
       sum_squares.direction[i].blue+=density_xy[x].direction[i].blue*
         density_xy[x].direction[i].blue;
-      if (image->matte != MagickFalse)
-        sum_squares.direction[i].opacity+=density_xy[x].direction[i].opacity*
-          density_xy[x].direction[i].opacity;
       if (image->colorspace == CMYKColorspace)
         sum_squares.direction[i].index+=density_xy[x].direction[i].index*
           density_xy[x].direction[i].index;
+      if (image->matte != MagickFalse)
+        sum_squares.direction[i].opacity+=density_xy[x].direction[i].opacity*
+          density_xy[x].direction[i].opacity;
       /*
         Difference entropy.
       */
@@ -1025,14 +1024,14 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
       channel_features[BlueChannel].difference_entropy[i]-=
         density_xy[x].direction[i].blue*
         log10(density_xy[x].direction[i].blue+MagickEpsilon);
-      if (image->matte != MagickFalse)
-        channel_features[OpacityChannel].difference_entropy[i]-=
-          density_xy[x].direction[i].opacity*
-          log10(density_xy[x].direction[i].opacity+MagickEpsilon);
       if (image->colorspace == CMYKColorspace)
         channel_features[IndexChannel].difference_entropy[i]-=
           density_xy[x].direction[i].index*
           log10(density_xy[x].direction[i].index+MagickEpsilon);
+      if (image->matte != MagickFalse)
+        channel_features[OpacityChannel].difference_entropy[i]-=
+          density_xy[x].direction[i].opacity*
+          log10(density_xy[x].direction[i].opacity+MagickEpsilon);
       /*
         Information Measures of Correlation.
       */
@@ -1042,24 +1041,24 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
         log10(density_x[x].direction[i].green+MagickEpsilon));
       entropy_x.direction[i].blue-=(density_x[x].direction[i].blue*
         log10(density_x[x].direction[i].blue+MagickEpsilon));
-      if (image->matte != MagickFalse)
-        entropy_x.direction[i].opacity-=(density_x[x].direction[i].opacity*
-          log10(density_x[x].direction[i].opacity+MagickEpsilon));
       if (image->colorspace == CMYKColorspace)
         entropy_x.direction[i].index-=(density_x[x].direction[i].index*
           log10(density_x[x].direction[i].index+MagickEpsilon));
-      entropy_y.direction[i].red-=(density_y[y].direction[i].red*
-        log10(density_y[y].direction[i].red+MagickEpsilon));
-      entropy_y.direction[i].green-=(density_y[y].direction[i].green*
-        log10(density_y[y].direction[i].green+MagickEpsilon));
-      entropy_y.direction[i].blue-=(density_y[y].direction[i].blue*
-        log10(density_y[y].direction[i].blue+MagickEpsilon));
       if (image->matte != MagickFalse)
-        entropy_y.direction[i].opacity-=(density_y[y].direction[i].opacity*
-          log10(density_y[y].direction[i].opacity+MagickEpsilon));
+        entropy_x.direction[i].opacity-=(density_x[x].direction[i].opacity*
+          log10(density_x[x].direction[i].opacity+MagickEpsilon));
+      entropy_y.direction[i].red-=(density_y[x].direction[i].red*
+        log10(density_y[x].direction[i].red+MagickEpsilon));
+      entropy_y.direction[i].green-=(density_y[x].direction[i].green*
+        log10(density_y[x].direction[i].green+MagickEpsilon));
+      entropy_y.direction[i].blue-=(density_y[x].direction[i].blue*
+        log10(density_y[x].direction[i].blue+MagickEpsilon));
       if (image->colorspace == CMYKColorspace)
-        entropy_y.direction[i].index-=(density_y[y].direction[i].index*
-          log10(density_y[y].direction[i].index+MagickEpsilon));
+        entropy_y.direction[i].index-=(density_y[x].direction[i].index*
+          log10(density_y[x].direction[i].index+MagickEpsilon));
+      if (image->matte != MagickFalse)
+        entropy_y.direction[i].opacity-=(density_y[x].direction[i].opacity*
+          log10(density_y[x].direction[i].opacity+MagickEpsilon));
     }
     /*
       Difference variance.
@@ -1101,16 +1100,16 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
       (entropy_xy.direction[i].blue-entropy_xy1.direction[i].blue)/
       (entropy_x.direction[i].blue > entropy_y.direction[i].blue ?
        entropy_x.direction[i].blue : entropy_y.direction[i].blue);
-    if (image->matte != MagickFalse)
-      channel_features[OpacityChannel].measure_of_correlation_1[i]=
-        (entropy_xy.direction[i].opacity-entropy_xy1.direction[i].opacity)/
-        (entropy_x.direction[i].opacity > entropy_y.direction[i].opacity ?
-         entropy_x.direction[i].opacity : entropy_y.direction[i].opacity);
     if (image->colorspace == CMYKColorspace)
       channel_features[IndexChannel].measure_of_correlation_1[i]=
         (entropy_xy.direction[i].index-entropy_xy1.direction[i].index)/
         (entropy_x.direction[i].index > entropy_y.direction[i].index ?
          entropy_x.direction[i].index : entropy_y.direction[i].index);
+    if (image->matte != MagickFalse)
+      channel_features[OpacityChannel].measure_of_correlation_1[i]=
+        (entropy_xy.direction[i].opacity-entropy_xy1.direction[i].opacity)/
+        (entropy_x.direction[i].opacity > entropy_y.direction[i].opacity ?
+         entropy_x.direction[i].opacity : entropy_y.direction[i].opacity);
     channel_features[RedChannel].measure_of_correlation_2[i]=
       (sqrt(fabs(1.0-exp(-2.0*(entropy_xy2.direction[i].red-
       entropy_xy.direction[i].red)))));
@@ -1120,14 +1119,14 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
     channel_features[BlueChannel].measure_of_correlation_2[i]=
       (sqrt(fabs(1.0-exp(-2.0*(entropy_xy2.direction[i].blue-
       entropy_xy.direction[i].blue)))));
-    if (image->matte != MagickFalse)
-      channel_features[OpacityChannel].measure_of_correlation_2[i]=
-        (sqrt(fabs(1.0-exp(-2.0*(entropy_xy2.direction[i].opacity-
-        entropy_xy.direction[i].opacity)))));
     if (image->colorspace == CMYKColorspace)
       channel_features[IndexChannel].measure_of_correlation_2[i]=
         (sqrt(fabs(1.0-exp(-2.0*(entropy_xy2.direction[i].index-
         entropy_xy.direction[i].index)))));
+    if (image->matte != MagickFalse)
+      channel_features[OpacityChannel].measure_of_correlation_2[i]=
+        (sqrt(fabs(1.0-exp(-2.0*(entropy_xy2.direction[i].opacity-
+        entropy_xy.direction[i].opacity)))));
   }
   /*
     Compute more texture features.
@@ -1161,11 +1160,11 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
               pixel.direction[i].red+=cooccurrence[x][y].direction[i].red;
               pixel.direction[i].green+=cooccurrence[x][y].direction[i].green;
               pixel.direction[i].blue+=cooccurrence[x][y].direction[i].blue;
+              if (image->colorspace == CMYKColorspace)
+                pixel.direction[i].index+=cooccurrence[x][y].direction[i].index;
               if (image->matte != MagickFalse)
                 pixel.direction[i].opacity+=
                   cooccurrence[x][y].direction[i].opacity;
-              if (image->colorspace == CMYKColorspace)
-                pixel.direction[i].index+=cooccurrence[x][y].direction[i].index;
             }
           /*
             Maximum Correlation Coefficient.
@@ -1179,27 +1178,27 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
           Q[z][y].direction[i].blue+=cooccurrence[z][x].direction[i].blue*
             cooccurrence[y][x].direction[i].blue/density_x[z].direction[i].blue/
             density_y[x].direction[i].blue;
+          if (image->colorspace == CMYKColorspace)
+            Q[z][y].direction[i].index+=cooccurrence[z][x].direction[i].index*
+              cooccurrence[y][x].direction[i].index/
+              density_x[z].direction[i].index/density_y[x].direction[i].index;
           if (image->matte != MagickFalse)
             Q[z][y].direction[i].opacity+=
               cooccurrence[z][x].direction[i].opacity*
               cooccurrence[y][x].direction[i].opacity/
               density_x[z].direction[i].opacity/
               density_y[x].direction[i].opacity;
-          if (image->colorspace == CMYKColorspace)
-            Q[z][y].direction[i].index+=cooccurrence[z][x].direction[i].index*
-              cooccurrence[y][x].direction[i].index/
-              density_x[z].direction[i].index/density_y[x].direction[i].index;
         }
       }
       channel_features[RedChannel].contrast[i]+=z*z*pixel.direction[i].red;
       channel_features[GreenChannel].contrast[i]+=z*z*pixel.direction[i].green;
       channel_features[BlueChannel].contrast[i]+=z*z*pixel.direction[i].blue;
-      if (image->matte != MagickFalse)
-        channel_features[OpacityChannel].contrast[i]+=z*z*
-          pixel.direction[i].opacity;
       if (image->colorspace == CMYKColorspace)
         channel_features[BlackChannel].contrast[i]+=z*z*
           pixel.direction[i].index;
+      if (image->matte != MagickFalse)
+        channel_features[OpacityChannel].contrast[i]+=z*z*
+          pixel.direction[i].opacity;
     }
     /*
       Maximum Correlation Coefficient.
@@ -1211,12 +1210,12 @@ MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
       sqrt((double) -1.0);
     channel_features[BlueChannel].maximum_correlation_coefficient[i]=
       sqrt((double) -1.0);
-    if (image->matte != MagickFalse)
-      channel_features[OpacityChannel].maximum_correlation_coefficient[i]=
-        sqrt((double) -1.0);
     if (image->colorspace == CMYKColorspace)
       channel_features[IndexChannel].maximum_correlation_coefficient[i]=
         sqrt((double) -1.0);
+    if (image->matte != MagickFalse)
+      channel_features[OpacityChannel].maximum_correlation_coefficient[i]=
+        sqrt((double) -1.0);
   }
   /*
     Relinquish resources.