(no commit message)

[imagemagick] / MagickCore / effect.c

diff --git a/MagickCore/effect.c b/MagickCore/effect.c
index fc0aa2d93b5d8b123a076512aa8f872cfcc73517..d873bc8351bf4b20fb93747f07d29dc1d0424524 100644 (file)
--- a/MagickCore/effect.c
+++ b/MagickCore/effect.c
@@ -17,7 +17,7 @@
 %                                 October 1996                                %
 %                                                                             %
 %                                                                             %
-%  Copyright 1999-2012 ImageMagick Studio LLC, a non-profit organization      %
+%  Copyright 1999-2013 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.  You may  %
@@ -180,6 +180,9 @@ MagickExport Image *AdaptiveBlurImage(const Image *image,const double radius,
     *edge_view,
     *image_view;
 
+  double
+    normalize;
+
   Image
     *blur_image,
     *edge_image,
@@ -192,8 +195,7 @@ MagickExport Image *AdaptiveBlurImage(const Image *image,const double radius,
     progress;
 
   MagickRealType
-    **kernel,
-    normalize;
+    **kernel;
 
   register ssize_t
     i;
@@ -275,7 +277,7 @@ MagickExport Image *AdaptiveBlurImage(const Image *image,const double radius,
     }
     if (fabs(normalize) < MagickEpsilon)
       normalize=MagickEpsilon;
-    normalize=MagickEpsilonReciprocal(normalize);
+    normalize=PerceptibleReciprocal(normalize);
     for (k=0; k < (j*j); k++)
       kernel[i][k]=normalize*kernel[i][k];
   }
@@ -374,9 +376,9 @@ MagickExport Image *AdaptiveBlurImage(const Image *image,const double radius,
         ssize_t
           v;
 
-        channel=GetPixelChannelMapChannel(image,i);
-        traits=GetPixelChannelMapTraits(image,channel);
-        blur_traits=GetPixelChannelMapTraits(blur_image,channel);
+        channel=GetPixelChannelChannel(image,i);
+        traits=GetPixelChannelTraits(image,channel);
+        blur_traits=GetPixelChannelTraits(blur_image,channel);
         if ((traits == UndefinedPixelTrait) ||
             (blur_traits == UndefinedPixelTrait))
           continue;
@@ -405,7 +407,7 @@ MagickExport Image *AdaptiveBlurImage(const Image *image,const double radius,
                 pixels+=GetPixelChannels(image);
               }
             }
-            gamma=MagickEpsilonReciprocal(gamma);
+            gamma=PerceptibleReciprocal(gamma);
             SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
             continue;
           }
@@ -423,7 +425,7 @@ MagickExport Image *AdaptiveBlurImage(const Image *image,const double radius,
             pixels+=GetPixelChannels(image);
           }
         }
-        gamma=MagickEpsilonReciprocal(gamma);
+        gamma=PerceptibleReciprocal(gamma);
         SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
       }
       q+=GetPixelChannels(blur_image);
@@ -503,6 +505,9 @@ MagickExport Image *AdaptiveSharpenImage(const Image *image,const double radius,
     *edge_view,
     *image_view;
 
+  double
+    normalize;
+
   Image
     *sharp_image,
     *edge_image,
@@ -515,8 +520,7 @@ MagickExport Image *AdaptiveSharpenImage(const Image *image,const double radius,
     progress;
 
   MagickRealType
-    **kernel,
-    normalize;
+    **kernel;
 
   register ssize_t
     i;
@@ -581,7 +585,7 @@ MagickExport Image *AdaptiveSharpenImage(const Image *image,const double radius,
   {
     kernel[i]=(MagickRealType *) MagickAssumeAligned(AcquireAlignedMemory(
       (size_t) (width-i),(width-i)*sizeof(**kernel)));
-    if (kernel[i] == (double *) NULL)
+    if (kernel[i] == (MagickRealType *) NULL)
       break;
     normalize=0.0;
     j=(ssize_t) (width-i)/2;
@@ -598,7 +602,7 @@ MagickExport Image *AdaptiveSharpenImage(const Image *image,const double radius,
     }
     if (fabs(normalize) < MagickEpsilon)
       normalize=MagickEpsilon;
-    normalize=MagickEpsilonReciprocal(normalize);
+    normalize=PerceptibleReciprocal(normalize);
     for (k=0; k < (j*j); k++)
       kernel[i][k]=normalize*kernel[i][k];
   }
@@ -697,9 +701,9 @@ MagickExport Image *AdaptiveSharpenImage(const Image *image,const double radius,
         ssize_t
           v;
 
-        channel=GetPixelChannelMapChannel(image,i);
-        traits=GetPixelChannelMapTraits(image,channel);
-        sharp_traits=GetPixelChannelMapTraits(sharp_image,channel);
+        channel=GetPixelChannelChannel(image,i);
+        traits=GetPixelChannelTraits(image,channel);
+        sharp_traits=GetPixelChannelTraits(sharp_image,channel);
         if ((traits == UndefinedPixelTrait) ||
             (sharp_traits == UndefinedPixelTrait))
           continue;
@@ -728,7 +732,7 @@ MagickExport Image *AdaptiveSharpenImage(const Image *image,const double radius,
                 pixels+=GetPixelChannels(image);
               }
             }
-            gamma=MagickEpsilonReciprocal(gamma);
+            gamma=PerceptibleReciprocal(gamma);
             SetPixelChannel(sharp_image,channel,ClampToQuantum(gamma*pixel),q);
             continue;
           }
@@ -746,7 +750,7 @@ MagickExport Image *AdaptiveSharpenImage(const Image *image,const double radius,
             pixels+=GetPixelChannels(image);
           }
         }
-        gamma=MagickEpsilonReciprocal(gamma);
+        gamma=PerceptibleReciprocal(gamma);
         SetPixelChannel(sharp_image,channel,ClampToQuantum(gamma*pixel),q);
       }
       q+=GetPixelChannels(sharp_image);
@@ -821,10 +825,12 @@ MagickExport Image *AdaptiveSharpenImage(const Image *image,const double radius,
 
 static MagickRealType *GetBlurKernel(const size_t width,const double sigma)
 {
-  MagickRealType
-    *kernel,
+  double
     normalize;
 
+  MagickRealType
+    *kernel;
+
   register ssize_t
     i;
 
@@ -999,9 +1005,9 @@ MagickExport Image *BlurImage(const Image *image,const double radius,
         register ssize_t
           u;
 
-        channel=GetPixelChannelMapChannel(image,i);
-        traits=GetPixelChannelMapTraits(image,channel);
-        blur_traits=GetPixelChannelMapTraits(blur_image,channel);
+        channel=GetPixelChannelChannel(image,i);
+        traits=GetPixelChannelTraits(image,channel);
+        blur_traits=GetPixelChannelTraits(blur_image,channel);
         if ((traits == UndefinedPixelTrait) ||
             (blur_traits == UndefinedPixelTrait))
           continue;
@@ -1040,7 +1046,7 @@ MagickExport Image *BlurImage(const Image *image,const double radius,
           k++;
           pixels+=GetPixelChannels(image);
         }
-        gamma=MagickEpsilonReciprocal(gamma);
+        gamma=PerceptibleReciprocal(gamma);
         SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
       }
       p+=GetPixelChannels(image);
@@ -1123,9 +1129,9 @@ MagickExport Image *BlurImage(const Image *image,const double radius,
         register ssize_t
           u;
 
-        channel=GetPixelChannelMapChannel(blur_image,i);
-        traits=GetPixelChannelMapTraits(blur_image,channel);
-        blur_traits=GetPixelChannelMapTraits(blur_image,channel);
+        channel=GetPixelChannelChannel(blur_image,i);
+        traits=GetPixelChannelTraits(blur_image,channel);
+        blur_traits=GetPixelChannelTraits(blur_image,channel);
         if ((traits == UndefinedPixelTrait) ||
             (blur_traits == UndefinedPixelTrait))
           continue;
@@ -1165,7 +1171,7 @@ MagickExport Image *BlurImage(const Image *image,const double radius,
           k++;
           pixels+=GetPixelChannels(blur_image);
         }
-        gamma=MagickEpsilonReciprocal(gamma);
+        gamma=PerceptibleReciprocal(gamma);
         SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
       }
       p+=GetPixelChannels(blur_image);
@@ -1282,19 +1288,19 @@ static void Hull(const Image *image,const ssize_t x_offset,
 #endif
   for (y=0; y < (ssize_t) rows; y++)
   {
+    MagickRealType
+      v;
+
     register ssize_t
       i,
       x;
 
-    SignedQuantum
-      v;
-
     i=(2*y+1)+y*columns;
     if (polarity > 0)
       for (x=0; x < (ssize_t) columns; x++)
       {
-        v=(SignedQuantum) p[i];
-        if ((SignedQuantum) r[i] >= (v+ScaleCharToQuantum(2)))
+        v=(MagickRealType) p[i];
+        if ((MagickRealType) r[i] >= (v+ScaleCharToQuantum(2)))
           v+=ScaleCharToQuantum(1);
         q[i]=(Quantum) v;
         i++;
@@ -1302,8 +1308,8 @@ static void Hull(const Image *image,const ssize_t x_offset,
     else
       for (x=0; x < (ssize_t) columns; x++)
       {
-        v=(SignedQuantum) p[i];
-        if ((SignedQuantum) r[i] <= (v-ScaleCharToQuantum(2)))
+        v=(MagickRealType) p[i];
+        if ((MagickRealType) r[i] <= (v-ScaleCharToQuantum(2)))
           v-=ScaleCharToQuantum(1);
         q[i]=(Quantum) v;
         i++;
@@ -1323,16 +1329,16 @@ static void Hull(const Image *image,const ssize_t x_offset,
       i,
       x;
 
-    SignedQuantum
+    MagickRealType
       v;
 
     i=(2*y+1)+y*columns;
     if (polarity > 0)
       for (x=0; x < (ssize_t) columns; x++)
       {
-        v=(SignedQuantum) q[i];
-        if (((SignedQuantum) s[i] >= (v+ScaleCharToQuantum(2))) &&
-            ((SignedQuantum) r[i] > v))
+        v=(MagickRealType) q[i];
+        if (((MagickRealType) s[i] >= (v+ScaleCharToQuantum(2))) &&
+            ((MagickRealType) r[i] > v))
           v+=ScaleCharToQuantum(1);
         p[i]=(Quantum) v;
         i++;
@@ -1340,9 +1346,9 @@ static void Hull(const Image *image,const ssize_t x_offset,
     else
       for (x=0; x < (ssize_t) columns; x++)
       {
-        v=(SignedQuantum) q[i];
-        if (((SignedQuantum) s[i] <= (v-ScaleCharToQuantum(2))) &&
-            ((SignedQuantum) r[i] < v))
+        v=(MagickRealType) q[i];
+        if (((MagickRealType) s[i] <= (v-ScaleCharToQuantum(2))) &&
+            ((MagickRealType) r[i] < v))
           v-=ScaleCharToQuantum(1);
         p[i]=(Quantum) v;
         i++;
@@ -1436,9 +1442,9 @@ MagickExport Image *DespeckleImage(const Image *image,ExceptionInfo *exception)
 
     if (status == MagickFalse)
       continue;
-    channel=GetPixelChannelMapChannel(image,i);
-    traits=GetPixelChannelMapTraits(image,channel);
-    despeckle_traits=GetPixelChannelMapTraits(despeckle_image,channel);
+    channel=GetPixelChannelChannel(image,i);
+    traits=GetPixelChannelTraits(image,channel);
+    despeckle_traits=GetPixelChannelTraits(despeckle_image,channel);
     if ((traits == UndefinedPixelTrait) ||
         (despeckle_traits == UndefinedPixelTrait))
       continue;
@@ -1604,8 +1610,6 @@ MagickExport Image *EdgeImage(const Image *image,const double radius,
   }
   kernel_info->values[i/2]=(MagickRealType) (width*width-1.0);
   edge_image=ConvolveImage(image,kernel_info,exception);
-  if (edge_image != (Image *) NULL)
-    (void) ClampImage(edge_image,exception);
   kernel_info=DestroyKernelInfo(kernel_info);
   return(edge_image);
 }
@@ -1999,9 +2003,9 @@ MagickExport Image *MotionBlurImage(const Image *image,const double radius,
         register ssize_t
           j;
 
-        channel=GetPixelChannelMapChannel(image,i);
-        traits=GetPixelChannelMapTraits(image,channel);
-        blur_traits=GetPixelChannelMapTraits(blur_image,channel);
+        channel=GetPixelChannelChannel(image,i);
+        traits=GetPixelChannelTraits(image,channel);
+        blur_traits=GetPixelChannelTraits(blur_image,channel);
         if ((traits == UndefinedPixelTrait) ||
             (blur_traits == UndefinedPixelTrait))
           continue;
@@ -2046,7 +2050,7 @@ MagickExport Image *MotionBlurImage(const Image *image,const double radius,
           gamma+=(*k)*alpha;
           k++;
         }
-        gamma=MagickEpsilonReciprocal(gamma);
+        gamma=PerceptibleReciprocal(gamma);
         SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
       }
       p+=GetPixelChannels(image);
@@ -2794,9 +2798,9 @@ MagickExport Image *RadialBlurImage(const Image *image,const double angle,
         register ssize_t
           j;
 
-        channel=GetPixelChannelMapChannel(image,i);
-        traits=GetPixelChannelMapTraits(image,channel);
-        blur_traits=GetPixelChannelMapTraits(blur_image,channel);
+        channel=GetPixelChannelChannel(image,i);
+        traits=GetPixelChannelTraits(image,channel);
+        blur_traits=GetPixelChannelTraits(blur_image,channel);
         if ((traits == UndefinedPixelTrait) ||
             (blur_traits == UndefinedPixelTrait))
           continue;
@@ -2824,7 +2828,7 @@ MagickExport Image *RadialBlurImage(const Image *image,const double angle,
               pixel+=r[i];
               gamma++;
             }
-            gamma=MagickEpsilonReciprocal(gamma);
+            gamma=PerceptibleReciprocal(gamma);
             SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
             continue;
           }
@@ -2842,7 +2846,7 @@ MagickExport Image *RadialBlurImage(const Image *image,const double angle,
           pixel+=GetPixelAlpha(image,r)*r[i];
           gamma+=GetPixelAlpha(image,r);
         }
-        gamma=MagickEpsilonReciprocal(gamma);
+        gamma=PerceptibleReciprocal(gamma);
         SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
       }
       p+=GetPixelChannels(image);
@@ -3032,7 +3036,7 @@ MagickExport Image *SelectiveBlurImage(const Image *image,const double radius,
   image_view=AcquireVirtualCacheView(image,exception);
   luminance_view=AcquireVirtualCacheView(luminance_image,exception);
   blur_view=AcquireAuthenticCacheView(blur_image,exception);
-#if defined(MMAGICKCORE_OPENMP_SUPPORT)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
 #endif
@@ -3103,9 +3107,9 @@ MagickExport Image *SelectiveBlurImage(const Image *image,const double radius,
         ssize_t
           v;
 
-        channel=GetPixelChannelMapChannel(image,i);
-        traits=GetPixelChannelMapTraits(image,channel);
-        blur_traits=GetPixelChannelMapTraits(blur_image,channel);
+        channel=GetPixelChannelChannel(image,i);
+        traits=GetPixelChannelTraits(image,channel);
+        blur_traits=GetPixelChannelTraits(blur_image,channel);
         if ((traits == UndefinedPixelTrait) ||
             (blur_traits == UndefinedPixelTrait))
           continue;
@@ -3146,7 +3150,7 @@ MagickExport Image *SelectiveBlurImage(const Image *image,const double radius,
                 SetPixelChannel(blur_image,channel,p[center+i],q);
                 continue;
               }
-            gamma=MagickEpsilonReciprocal(gamma);
+            gamma=PerceptibleReciprocal(gamma);
             SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
             continue;
           }
@@ -3175,7 +3179,7 @@ MagickExport Image *SelectiveBlurImage(const Image *image,const double radius,
             SetPixelChannel(blur_image,channel,p[center+i],q);
             continue;
           }
-        gamma=MagickEpsilonReciprocal(gamma);
+        gamma=PerceptibleReciprocal(gamma);
         SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
       }
       p+=GetPixelChannels(image);
@@ -3382,9 +3386,9 @@ MagickExport Image *ShadeImage(const Image *image,const MagickBooleanType gray,
           shade_traits,
           traits;
 
-        channel=GetPixelChannelMapChannel(image,i);
-        traits=GetPixelChannelMapTraits(image,channel);
-        shade_traits=GetPixelChannelMapTraits(shade_image,channel);
+        channel=GetPixelChannelChannel(image,i);
+        traits=GetPixelChannelTraits(image,channel);
+        shade_traits=GetPixelChannelTraits(shade_image,channel);
         if ((traits == UndefinedPixelTrait) ||
             (shade_traits == UndefinedPixelTrait))
           continue;
@@ -3527,8 +3531,6 @@ MagickExport Image *SharpenImage(const Image *image,const double radius,
   }
   kernel_info->values[i/2]=(double) ((-2.0)*normalize);
   sharp_image=ConvolveImage(image,kernel_info,exception);
-  if (sharp_image != (Image *) NULL)
-    (void) ClampImage(sharp_image,exception);
   kernel_info=DestroyKernelInfo(kernel_info);
   return(sharp_image);
 }
@@ -3590,8 +3592,10 @@ MagickExport Image *SpreadImage(const Image *image,const double radius,
   ssize_t
     y;
 
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
   unsigned long
     key;
+#endif
 
   /*
     Initialize spread image attributes.
@@ -3618,7 +3622,9 @@ MagickExport Image *SpreadImage(const Image *image,const double radius,
   progress=0;
   width=GetOptimalKernelWidth1D(radius,0.5);
   random_info=AcquireRandomInfoThreadSet();
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
   key=GetRandomSecretKey(random_info[0]);
+#endif
   image_view=AcquireVirtualCacheView(image,exception);
   spread_view=AcquireAuthenticCacheView(spread_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
@@ -3803,9 +3809,9 @@ MagickExport Image *UnsharpMaskImage(const Image *image,const double radius,
           traits,
           unsharp_traits;
 
-        channel=GetPixelChannelMapChannel(image,i);
-        traits=GetPixelChannelMapTraits(image,channel);
-        unsharp_traits=GetPixelChannelMapTraits(unsharp_image,channel);
+        channel=GetPixelChannelChannel(image,i);
+        traits=GetPixelChannelTraits(image,channel);
+        unsharp_traits=GetPixelChannelTraits(unsharp_image,channel);
         if ((traits == UndefinedPixelTrait) ||
             (unsharp_traits == UndefinedPixelTrait))
           continue;
@@ -3842,8 +3848,6 @@ MagickExport Image *UnsharpMaskImage(const Image *image,const double radius,
   }
   unsharp_image->type=image->type;
   unsharp_view=DestroyCacheView(unsharp_view);
-  if (unsharp_image != (Image *) NULL)
-    (void) ClampImage(unsharp_image,exception);
   image_view=DestroyCacheView(image_view);
   if (status == MagickFalse)
     unsharp_image=DestroyImage(unsharp_image);