(no commit message)

diff --git a/Magick++/lib/Image.cpp b/Magick++/lib/Image.cpp
index 607d83fcb14adb3423325d0a7d4945320cb227e6..d31bc162029df93787bc798bab66a4a17e5c6611 100644 (file)
--- a/Magick++/lib/Image.cpp
+++ b/Magick++/lib/Image.cpp
@@ -643,12 +643,17 @@ void Magick::Image::colorMatrix (const size_t order_,
   kernel_info=AcquireKernelInfo((const char *) NULL);
   kernel_info->width=order_;
   kernel_info->height=order_;
-  kernel_info->values=(double *) color_matrix_;
-  MagickCore::Image* newImage =
-    ColorMatrixImage( image(), kernel_info, &exceptionInfo );
-  kernel_info->values=(double *) NULL;
+  kernel_info->values=(MagickRealType *)  AcquireAlignedMemory(order_,
+    order_*sizeof(*kernel_info->values));
+  if (kernel_info->values != (MagickRealType *) NULL)
+    {
+      for (ssize_t i=0; i < (order_*order_); i++)
+        kernel_info->values[i]=color_matrix_[i];
+      MagickCore::Image* newImage =
+        ColorMatrixImage( image(), kernel_info, &exceptionInfo );
+      replaceImage( newImage );
+    }
   kernel_info=DestroyKernelInfo(kernel_info);
-  replaceImage( newImage );
   throwException( exceptionInfo );
   (void) DestroyExceptionInfo( &exceptionInfo );
 }
@@ -760,12 +765,17 @@ void Magick::Image::convolve ( const size_t order_,
   kernel_info=AcquireKernelInfo((const char *) NULL);
   kernel_info->width=order_;
   kernel_info->height=order_;
-  kernel_info->values=(double *) kernel_;
-  MagickCore::Image* newImage =
-    ConvolveImage ( image(), kernel_info, &exceptionInfo );
-  kernel_info->values=(double *) NULL;
+  kernel_info->values=(MagickRealType *)  AcquireAlignedMemory(order_,
+    order_*sizeof(*kernel_info->values));
+  if (kernel_info->values != (MagickRealType *) NULL)
+    {
+      for (ssize_t i=0; i < (order_*order_); i++)
+        kernel_info->values[i]=kernel_[i];
+      MagickCore::Image* newImage =
+        ConvolveImage ( image(), kernel_info, &exceptionInfo );
+      replaceImage( newImage );
+    }
   kernel_info=DestroyKernelInfo(kernel_info);
-  replaceImage( newImage );
   throwException( exceptionInfo );
   (void) DestroyExceptionInfo( &exceptionInfo );
 }

diff --git a/Magick++/lib/Magick++/Include.h b/Magick++/lib/Magick++/Include.h
index e81e79e78f90e2d5a61fe82783d8eee145773276..e605e4371adc423e7ac41bd4ad558e484a9b74c7 100644 (file)
--- a/Magick++/lib/Magick++/Include.h
+++ b/Magick++/lib/Magick++/Include.h
@@ -131,6 +131,7 @@ namespace Magick
 {
   // The datatype for an RGB component
   using MagickCore::Quantum;
+  using MagickCore::MagickRealType;
   using MagickCore::MagickSizeType;
 
   // Boolean types
@@ -553,6 +554,7 @@ namespace Magick
   //
   // ImageMagick symbols used in implementation code
   //
+  using MagickCore::AcquireAlignedMemory;
   using MagickCore::AcquireAuthenticCacheView;
   using MagickCore::AcquireExceptionInfo;
   using MagickCore::AcquireVirtualCacheView;

diff --git a/MagickCore/effect.c b/MagickCore/effect.c
index 5885e55e332f084598cf2645a203bbe1511a25b7..7dedd714e69449590f35aa0e2d6294ef35317930 100644 (file)
--- a/MagickCore/effect.c
+++ b/MagickCore/effect.c
@@ -1580,9 +1580,9 @@ MagickExport Image *EdgeImage(const Image *image,const double radius,
     ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
   kernel_info->width=width;
   kernel_info->height=width;
-  kernel_info->values=(double *) AcquireAlignedMemory(kernel_info->width,
-    kernel_info->width*sizeof(*kernel_info->values));
-  if (kernel_info->values == (double *) NULL)
+  kernel_info->values=(MagickRealType *) AcquireAlignedMemory(
+    kernel_info->width,kernel_info->width*sizeof(*kernel_info->values));
+  if (kernel_info->values == (MagickRealType *) NULL)
     {
       kernel_info=DestroyKernelInfo(kernel_info);
       ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
@@ -1593,11 +1593,11 @@ MagickExport Image *EdgeImage(const Image *image,const double radius,
   {
     for (u=(-j); u <= j; u++)
     {
-      kernel_info->values[i]=(-1.0);
+      kernel_info->values[i]=(MagickRealType) (-1.0);
       i++;
     }
   }
-  kernel_info->values[i/2]=(double) (width*width-1.0);
+  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);
@@ -1671,9 +1671,9 @@ MagickExport Image *EmbossImage(const Image *image,const double radius,
     ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
   kernel_info->width=width;
   kernel_info->height=width;
-  kernel_info->values=(double *) AcquireAlignedMemory(kernel_info->width,
-    kernel_info->width*sizeof(*kernel_info->values));
-  if (kernel_info->values == (double *) NULL)
+  kernel_info->values=(MagickRealType *) AcquireAlignedMemory(
+    kernel_info->width,kernel_info->width*sizeof(*kernel_info->values));
+  if (kernel_info->values == (MagickRealType *) NULL)
     {
       kernel_info=DestroyKernelInfo(kernel_info);
       ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
@@ -1685,8 +1685,8 @@ MagickExport Image *EmbossImage(const Image *image,const double radius,
   {
     for (u=(-j); u <= j; u++)
     {
-      kernel_info->values[i]=(double) (((u < 0) || (v < 0) ? -8.0 : 8.0)*
-        exp(-((double) u*u+v*v)/(2.0*MagickSigma*MagickSigma))/
+      kernel_info->values[i]=(MagickRealType) (((u < 0) || (v < 0) ? -8.0 :
+        8.0)*exp(-((double) u*u+v*v)/(2.0*MagickSigma*MagickSigma))/
         (2.0*MagickPI*MagickSigma*MagickSigma));
       if (u != k)
         kernel_info->values[i]=0.0;
@@ -1768,9 +1768,9 @@ MagickExport Image *GaussianBlurImage(const Image *image,const double radius,
   kernel_info->width=width;
   kernel_info->height=width;
   kernel_info->signature=MagickSignature;
-  kernel_info->values=(double *) AcquireAlignedMemory(
+  kernel_info->values=(MagickRealType *) AcquireAlignedMemory(
     kernel_info->width,kernel_info->width*sizeof(*kernel_info->values));
-  if (kernel_info->values == (double *) NULL)
+  if (kernel_info->values == (MagickRealType *) NULL)
     {
       kernel_info=DestroyKernelInfo(kernel_info);
       ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
@@ -1781,7 +1781,7 @@ MagickExport Image *GaussianBlurImage(const Image *image,const double radius,
   {
     for (u=(-j); u <= j; u++)
     {
-      kernel_info->values[i]=(double) (exp(-((double) u*u+v*v)/(2.0*
+      kernel_info->values[i]=(MagickRealType) (exp(-((double) u*u+v*v)/(2.0*
         MagickSigma*MagickSigma))/(2.0*MagickPI*MagickSigma*MagickSigma));
       i++;
     }
@@ -3494,9 +3494,9 @@ MagickExport Image *SharpenImage(const Image *image,const double radius,
   kernel_info->width=width;
   kernel_info->height=width;
   kernel_info->signature=MagickSignature;
-  kernel_info->values=(double *) AcquireAlignedMemory(
+  kernel_info->values=(MagickRealType *) AcquireAlignedMemory(
     kernel_info->width,kernel_info->width*sizeof(*kernel_info->values));
-  if (kernel_info->values == (double *) NULL)
+  if (kernel_info->values == (MagickRealType *) NULL)
     {
       kernel_info=DestroyKernelInfo(kernel_info);
       ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
@@ -3508,7 +3508,7 @@ MagickExport Image *SharpenImage(const Image *image,const double radius,
   {
     for (u=(-j); u <= j; u++)
     {
-      kernel_info->values[i]=(double) (-exp(-((double) u*u+v*v)/(2.0*
+      kernel_info->values[i]=(MagickRealType) (-exp(-((double) u*u+v*v)/(2.0*
         MagickSigma*MagickSigma))/(2.0*MagickPI*MagickSigma*MagickSigma));
       normalize+=kernel_info->values[i];
       i++;
@@ -3516,6 +3516,8 @@ 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);
 }
@@ -3829,6 +3831,8 @@ 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);

diff --git a/MagickCore/enhance.c b/MagickCore/enhance.c
index 5544e135c181a717ade9234548f5d04f8043f522..6441c76cb5164d7b0af473968b74fbc385dd8c09 100644 (file)
--- a/MagickCore/enhance.c
+++ b/MagickCore/enhance.c
@@ -74,6 +74,7 @@
 #include "MagickCore/string_.h"
 #include "MagickCore/string-private.h"
 #include "MagickCore/thread-private.h"
+#include "MagickCore/threshold.h"
 #include "MagickCore/token.h"
 #include "MagickCore/xml-tree.h"
 #include "MagickCore/xml-tree-private.h"
@@ -2292,6 +2293,8 @@ MagickExport MagickBooleanType LevelImage(Image *image,const double black_point,
       }
   }
   image_view=DestroyCacheView(image_view);
+  if (status != MagickFalse)
+    (void) ClampImage(image,exception);
   return(status);
 }
 \f

diff --git a/MagickCore/magick-type.h b/MagickCore/magick-type.h
index 4a12fe87c2e9320c8cffaaeacee7374527485c98..6901c780ce72b02a2250d4847b4a96061261d26d 100644 (file)
--- a/MagickCore/magick-type.h
+++ b/MagickCore/magick-type.h
@@ -115,10 +115,10 @@ typedef unsigned __int64 MagickSizeType;
 #define MagickSizeFormat  "I64u"
 #endif
 
-#if QuantumDepth > 16
-  typedef double SignedQuantum;
+#if defined __arm__ || defined __thumb__
+typedef float MagickRealType;
 #else
-  typedef ssize_t SignedQuantum;
+typedef double MagickRealType;
 #endif
 
 #if defined(_MSC_VER) && (_MSC_VER == 1200)
@@ -127,6 +127,12 @@ typedef MagickOffsetType QuantumAny;
 typedef MagickSizeType QuantumAny;
 #endif
 
+#if QuantumDepth > 16
+  typedef double SignedQuantum;
+#else
+  typedef ssize_t SignedQuantum;
+#endif
+
 #if defined(macintosh)
 #define ExceptionInfo  MagickExceptionInfo
 #endif

diff --git a/MagickCore/morphology.c b/MagickCore/morphology.c
index cbd150e1bc95cb81b7fe66326a03e00abf552768..c2bd1a68f194d46048590f9af610710a8b24504e 100644 (file)
--- a/MagickCore/morphology.c
+++ b/MagickCore/morphology.c
@@ -333,9 +333,9 @@ static KernelInfo *ParseKernelArray(const char *kernel_string)
     }
 
   /* Read in the kernel values from rest of input string argument */
-  kernel->values=(double *) AcquireAlignedMemory(kernel->width,
+  kernel->values=(MagickRealType *) AcquireAlignedMemory(kernel->width,
     kernel->height*sizeof(*kernel->values));
-  if (kernel->values == (double *) NULL)
+  if (kernel->values == (MagickRealType *) NULL)
     return(DestroyKernelInfo(kernel));
   kernel->minimum = +MagickHuge;
   kernel->maximum = -MagickHuge;
@@ -1052,9 +1052,9 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
       {
         kernel->height = kernel->width = (size_t) 1;
         kernel->x = kernel->y = (ssize_t) 0;
-        kernel->values=(double *) AcquireAlignedMemory(1,
+        kernel->values=(MagickRealType *) AcquireAlignedMemory(1,
           sizeof(*kernel->values));
-        if (kernel->values == (double *) NULL)
+        if (kernel->values == (MagickRealType *) NULL)
           return(DestroyKernelInfo(kernel));
         kernel->maximum = kernel->values[0] = args->rho;
         break;
@@ -1076,9 +1076,9 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
           kernel->width = GetOptimalKernelWidth2D(args->rho,sigma2);
         kernel->height = kernel->width;
         kernel->x = kernel->y = (ssize_t) (kernel->width-1)/2;
-        kernel->values=(double *) AcquireAlignedMemory(kernel->width,
+        kernel->values=(MagickRealType *) AcquireAlignedMemory(kernel->width,
           kernel->height*sizeof(*kernel->values));
-        if (kernel->values == (double *) NULL)
+        if (kernel->values == (MagickRealType *) NULL)
           return(DestroyKernelInfo(kernel));
 
         /* WARNING: The following generates a 'sampled gaussian' kernel.
@@ -1167,9 +1167,9 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
         kernel->x = (ssize_t) (kernel->width-1)/2;
         kernel->y = 0;
         kernel->negative_range = kernel->positive_range = 0.0;
-        kernel->values=(double *) AcquireAlignedMemory(kernel->width,
+        kernel->values=(MagickRealType *) AcquireAlignedMemory(kernel->width,
           kernel->height*sizeof(*kernel->values));
-        if (kernel->values == (double *) NULL)
+        if (kernel->values == (MagickRealType *) NULL)
           return(DestroyKernelInfo(kernel));
 
 #if 1
@@ -1253,9 +1253,9 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
         kernel->x = kernel->y = 0;
         kernel->height = 1;
         kernel->negative_range = kernel->positive_range = 0.0;
-        kernel->values=(double *) AcquireAlignedMemory(kernel->width,
+        kernel->values=(MagickRealType *) AcquireAlignedMemory(kernel->width,
           kernel->height*sizeof(*kernel->values));
-        if (kernel->values == (double *) NULL)
+        if (kernel->values == (MagickRealType *) NULL)
           return(DestroyKernelInfo(kernel));
 
         /* A comet blur is half a 1D gaussian curve, so that the object is
@@ -1322,9 +1322,9 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
 
         order_f = fact(kernel->width-1);
 
-        kernel->values=(double *) AcquireAlignedMemory(kernel->width,
+        kernel->values=(MagickRealType *) AcquireAlignedMemory(kernel->width,
           kernel->height*sizeof(*kernel->values));
-        if (kernel->values == (double *) NULL)
+        if (kernel->values == (MagickRealType *) NULL)
           return(DestroyKernelInfo(kernel));
 
         /* set all kernel values within diamond area to scale given */
@@ -1438,8 +1438,8 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
             if (kernel == (KernelInfo *) NULL)
               return(kernel);
             kernel->type = type;
-            kernel->values[3] = +(double) MagickSQ2;
-            kernel->values[5] = -(double) MagickSQ2;
+            kernel->values[3] = +(MagickRealType) MagickSQ2;
+            kernel->values[5] = -(MagickRealType) MagickSQ2;
             CalcKernelMetaData(kernel);     /* recalculate meta-data */
             break;
           case 2:
@@ -1447,8 +1447,8 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
             if (kernel == (KernelInfo *) NULL)
               return(kernel);
             kernel->type = type;
-            kernel->values[1] = kernel->values[3]= +(double) MagickSQ2;
-            kernel->values[5] = kernel->values[7]= -(double) MagickSQ2;
+            kernel->values[1] = kernel->values[3]= +(MagickRealType) MagickSQ2;
+            kernel->values[5] = kernel->values[7]= -(MagickRealType) MagickSQ2;
             CalcKernelMetaData(kernel);     /* recalculate meta-data */
             ScaleKernelInfo(kernel, (double) (1.0/2.0*MagickSQ2), NoValue);
             break;
@@ -1463,8 +1463,8 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
             if (kernel == (KernelInfo *) NULL)
               return(kernel);
             kernel->type = type;
-            kernel->values[3] = +(double) MagickSQ2;
-            kernel->values[5] = -(double) MagickSQ2;
+            kernel->values[3] = +(MagickRealType) MagickSQ2;
+            kernel->values[5] = -(MagickRealType) MagickSQ2;
             CalcKernelMetaData(kernel);     /* recalculate meta-data */
             ScaleKernelInfo(kernel, (double) (1.0/2.0*MagickSQ2), NoValue);
             break;
@@ -1483,8 +1483,8 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
             if (kernel == (KernelInfo *) NULL)
               return(kernel);
             kernel->type = type;
-            kernel->values[0] = +(double) MagickSQ2;
-            kernel->values[8] = -(double) MagickSQ2;
+            kernel->values[0] = +(MagickRealType) MagickSQ2;
+            kernel->values[8] = -(MagickRealType) MagickSQ2;
             CalcKernelMetaData(kernel);
             ScaleKernelInfo(kernel, (double) (1.0/2.0*MagickSQ2), NoValue);
             break;
@@ -1493,8 +1493,8 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
             if (kernel == (KernelInfo *) NULL)
               return(kernel);
             kernel->type = type;
-            kernel->values[2] = -(double) MagickSQ2;
-            kernel->values[6] = +(double) MagickSQ2;
+            kernel->values[2] = -(MagickRealType) MagickSQ2;
+            kernel->values[6] = +(MagickRealType) MagickSQ2;
             CalcKernelMetaData(kernel);
             ScaleKernelInfo(kernel, (double) (1.0/2.0*MagickSQ2), NoValue);
             break;
@@ -1554,9 +1554,9 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
           kernel->width = kernel->height = ((size_t)args->rho)*2+1;
         kernel->x = kernel->y = (ssize_t) (kernel->width-1)/2;
 
-        kernel->values=(double *) AcquireAlignedMemory(kernel->width,
+        kernel->values=(MagickRealType *) AcquireAlignedMemory(kernel->width,
           kernel->height*sizeof(*kernel->values));
-        if (kernel->values == (double *) NULL)
+        if (kernel->values == (MagickRealType *) NULL)
           return(DestroyKernelInfo(kernel));
 
         /* set all kernel values within diamond area to scale given */
@@ -1595,9 +1595,9 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
             kernel->y = (ssize_t) args->psi;
             scale = 1.0;
           }
-        kernel->values=(double *) AcquireAlignedMemory(kernel->width,
+        kernel->values=(MagickRealType *) AcquireAlignedMemory(kernel->width,
           kernel->height*sizeof(*kernel->values));
-        if (kernel->values == (double *) NULL)
+        if (kernel->values == (MagickRealType *) NULL)
           return(DestroyKernelInfo(kernel));
 
         /* set all kernel values to scale given */
@@ -1616,9 +1616,9 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
             kernel->width = kernel->height = ((size_t)args->rho)*2+1;
           kernel->x = kernel->y = (ssize_t) (kernel->width-1)/2;
 
-          kernel->values=(double *) AcquireAlignedMemory(kernel->width,
+          kernel->values=(MagickRealType *) AcquireAlignedMemory(kernel->width,
             kernel->height*sizeof(*kernel->values));
-          if (kernel->values == (double *) NULL)
+          if (kernel->values == (MagickRealType *) NULL)
             return(DestroyKernelInfo(kernel));
 
           for ( i=0, v=-kernel->y; v <= (ssize_t)kernel->y; v++)
@@ -1642,9 +1642,9 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
             kernel->width = kernel->height = (size_t)fabs(args->rho)*2+1;
           kernel->x = kernel->y = (ssize_t) (kernel->width-1)/2;
 
-          kernel->values=(double *) AcquireAlignedMemory(kernel->width,
+          kernel->values=(MagickRealType *) AcquireAlignedMemory(kernel->width,
             kernel->height*sizeof(*kernel->values));
-          if (kernel->values == (double *) NULL)
+          if (kernel->values == (MagickRealType *) NULL)
             return(DestroyKernelInfo(kernel));
 
           for ( i=0, v=-kernel->y; v <= (ssize_t)kernel->y; v++)
@@ -1664,9 +1664,9 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
             kernel->width = kernel->height = ((size_t)args->rho)*2+1;
           kernel->x = kernel->y = (ssize_t) (kernel->width-1)/2;
 
-          kernel->values=(double *) AcquireAlignedMemory(kernel->width,
+          kernel->values=(MagickRealType *) AcquireAlignedMemory(kernel->width,
             kernel->height*sizeof(*kernel->values));
-          if (kernel->values == (double *) NULL)
+          if (kernel->values == (MagickRealType *) NULL)
             return(DestroyKernelInfo(kernel));
 
           /* set all kernel values along axises to given scale */
@@ -1685,9 +1685,9 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
             kernel->width = kernel->height = ((size_t)args->rho)*2+1;
           kernel->x = kernel->y = (ssize_t) (kernel->width-1)/2;
 
-          kernel->values=(double *) AcquireAlignedMemory(kernel->width,
+          kernel->values=(MagickRealType *) AcquireAlignedMemory(kernel->width,
             kernel->height*sizeof(*kernel->values));
-          if (kernel->values == (double *) NULL)
+          if (kernel->values == (MagickRealType *) NULL)
             return(DestroyKernelInfo(kernel));
 
           /* set all kernel values along axises to given scale */
@@ -1726,9 +1726,9 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
 
           kernel->height = kernel->width;
           kernel->x = kernel->y = (ssize_t) (kernel->width-1)/2;
-          kernel->values=(double *) AcquireAlignedMemory(kernel->width,
+          kernel->values=(MagickRealType *) AcquireAlignedMemory(kernel->width,
             kernel->height*sizeof(*kernel->values));
-          if (kernel->values == (double *) NULL)
+          if (kernel->values == (MagickRealType *) NULL)
             return(DestroyKernelInfo(kernel));
 
           /* set a ring of points of 'scale' ( 0.0 for PeaksKernel ) */
@@ -2096,9 +2096,9 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
             kernel->width = kernel->height = ((size_t)args->rho)*2+1;
           kernel->x = kernel->y = (ssize_t) (kernel->width-1)/2;
 
-          kernel->values=(double *) AcquireAlignedMemory(kernel->width,
+          kernel->values=(MagickRealType *) AcquireAlignedMemory(kernel->width,
             kernel->height*sizeof(*kernel->values));
-          if (kernel->values == (double *) NULL)
+          if (kernel->values == (MagickRealType *) NULL)
             return(DestroyKernelInfo(kernel));
 
           for ( i=0, v=-kernel->y; v <= (ssize_t)kernel->y; v++)
@@ -2116,9 +2116,9 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
             kernel->width = kernel->height = ((size_t)args->rho)*2+1;
           kernel->x = kernel->y = (ssize_t) (kernel->width-1)/2;
 
-          kernel->values=(double *) AcquireAlignedMemory(kernel->width,
+          kernel->values=(MagickRealType *) AcquireAlignedMemory(kernel->width,
             kernel->height*sizeof(*kernel->values));
-          if (kernel->values == (double *) NULL)
+          if (kernel->values == (MagickRealType *) NULL)
             return(DestroyKernelInfo(kernel));
 
           for ( i=0, v=-kernel->y; v <= (ssize_t)kernel->y; v++)
@@ -2136,9 +2136,9 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
           kernel->width = kernel->height = ((size_t)args->rho)*2+1;
         kernel->x = kernel->y = (ssize_t) (kernel->width-1)/2;
 
-        kernel->values=(double *) AcquireAlignedMemory(kernel->width,
+        kernel->values=(MagickRealType *) AcquireAlignedMemory(kernel->width,
           kernel->height*sizeof(*kernel->values));
-        if (kernel->values == (double *) NULL)
+        if (kernel->values == (MagickRealType *) NULL)
           return(DestroyKernelInfo(kernel));
 
         for ( i=0, v=-kernel->y; v <= (ssize_t)kernel->y; v++)
@@ -2161,9 +2161,9 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
           kernel->width = kernel->height = ((size_t)args->rho)*2+1;
         kernel->x = kernel->y = (ssize_t) (kernel->width-1)/2;
 
-        kernel->values=(double *) AcquireAlignedMemory(kernel->width,
+        kernel->values=(MagickRealType *) AcquireAlignedMemory(kernel->width,
           kernel->height*sizeof(*kernel->values));
-        if (kernel->values == (double *) NULL)
+        if (kernel->values == (MagickRealType *) NULL)
           return(DestroyKernelInfo(kernel));
 
         for ( i=0, v=-kernel->y; v <= (ssize_t)kernel->y; v++)
@@ -2226,9 +2226,9 @@ MagickExport KernelInfo *CloneKernelInfo(const KernelInfo *kernel)
   *new_kernel=(*kernel); /* copy values in structure */
 
   /* replace the values with a copy of the values */
-  new_kernel->values=(double *) AcquireAlignedMemory(kernel->width,
+  new_kernel->values=(MagickRealType *) AcquireAlignedMemory(kernel->width,
     kernel->height*sizeof(*kernel->values));
-  if (new_kernel->values == (double *) NULL)
+  if (new_kernel->values == (MagickRealType *) NULL)
     return(DestroyKernelInfo(new_kernel));
   for (i=0; i < (ssize_t) (kernel->width*kernel->height); i++)
     new_kernel->values[i]=kernel->values[i];
@@ -2271,7 +2271,7 @@ MagickExport KernelInfo *DestroyKernelInfo(KernelInfo *kernel)
   assert(kernel != (KernelInfo *) NULL);
   if ( kernel->next != (KernelInfo *) NULL )
     kernel->next=DestroyKernelInfo(kernel->next);
-  kernel->values=(double *) RelinquishAlignedMemory(kernel->values);
+  kernel->values=(MagickRealType *) RelinquishAlignedMemory(kernel->values);
   kernel=(KernelInfo *) RelinquishMagickMemory(kernel);
   return(kernel);
 }
@@ -2676,15 +2676,15 @@ static ssize_t MorphologyPrimitive(const Image *image,Image *morphology_image,
         PixelInfo
           result;
 
-        register ssize_t
-          v;
-
-        register const double
+        register const MagickRealType
           *restrict k;
 
         register const Quantum
           *restrict k_pixels;
 
+        register ssize_t
+          v;
+
         /* Copy input image to the output image for unused channels
         * This removes need for 'cloning' a new image every iteration
         */
@@ -2850,22 +2850,22 @@ static ssize_t MorphologyPrimitive(const Image *image,Image *morphology_image,
 
     for (x=0; x < (ssize_t) image->columns; x++)
     {
-       ssize_t
-        v;
-
-      register ssize_t
-        u;
+      PixelInfo
+        result,
+        min,
+        max;
 
-      register const double
+      register const MagickRealType
         *restrict k;
 
       register const Quantum
         *restrict k_pixels;
 
-      PixelInfo
-        result,
-        min,
-        max;
+      register ssize_t
+        u;
+
+      ssize_t
+        v;
 
       /* Copy input image to the output image for unused channels
        * This removes need for 'cloning' a new image every iteration
@@ -3465,20 +3465,20 @@ static ssize_t MorphologyPrimitiveDirect(Image *image,
 
     for (x=0; x < (ssize_t) image->columns; x++)
     {
-      ssize_t
-        v;
-
-      register ssize_t
-        u;
+      PixelInfo
+        result;
 
-      register const double
+      register const MagickRealType
         *restrict k;
 
       register const Quantum
         *restrict k_pixels;
 
-      PixelInfo
-        result;
+      register ssize_t
+        u;
+
+      ssize_t
+        v;
 
       /* Starting Defaults */
       GetPixelInfo(image,&result);
@@ -3651,20 +3651,20 @@ static ssize_t MorphologyPrimitiveDirect(Image *image,
 
     for (x=(ssize_t)image->columns-1; x >= 0; x--)
     {
-      ssize_t
-        v;
-
-      register ssize_t
-        u;
+      PixelInfo
+        result;
 
-      register const double
+      register const MagickRealType
         *restrict k;
 
       register const Quantum
         *restrict k_pixels;
 
-      PixelInfo
-        result;
+      register ssize_t
+        u;
+
+      ssize_t
+        v;
 
       /* Default - previously modified pixel */
       GetPixelInfo(image,&result);
@@ -4537,13 +4537,15 @@ static void RotateKernelInfo(KernelInfo *kernel, double angle)
         }
       else if ( kernel->width == kernel->height )
         { /* Rotate a square array of values by 90 degrees */
-          { register size_t
+          { register ssize_t
               i,j,x,y;
-            register double
+
+            register MagickRealType
               *k,t;
+
             k=kernel->values;
-            for( i=0, x=kernel->width-1;  i<=x;   i++, x--)
-              for( j=0, y=kernel->height-1;  j<y;   j++, y--)
+            for( i=0, x=(ssize_t) kernel->width-1;  i<=x;   i++, x--)
+              for( j=0, y=(ssize_t) kernel->height-1;  j<y;   j++, y--)
                 { t                    = k[i+j*kernel->width];
                   k[i+j*kernel->width] = k[j+x*kernel->width];
                   k[j+x*kernel->width] = k[x+y*kernel->width];
@@ -4574,7 +4576,7 @@ static void RotateKernelInfo(KernelInfo *kernel, double angle)
       double
         t;
 
-      register double
+      register MagickRealType
         *k;
 
       ssize_t
@@ -4866,7 +4868,7 @@ MagickPrivate void ShowKernelInfo(const KernelInfo *kernel)
           (void) FormatLocaleFile(stderr," %*s", GetMagickPrecision()+3, "nan");
         else
           (void) FormatLocaleFile(stderr," %*.*lg", GetMagickPrecision()+3,
-              GetMagickPrecision(), k->values[i]);
+              GetMagickPrecision(), (double) k->values[i]);
       (void) FormatLocaleFile(stderr,"\n");
     }
   }

diff --git a/PerlMagick/Magick.xs b/PerlMagick/Magick.xs
index c3c633072d79b4fd5c0a12a8ec97f8630ef09054..dcbe667919870870e5bacef3d81e1a6e4855442c 100644 (file)
--- a/PerlMagick/Magick.xs
+++ b/PerlMagick/Magick.xs
@@ -9358,9 +9358,9 @@ Mogrify(ref,...)
               order=(size_t) sqrt(av_len(av)+1);
               kernel->width=order;
               kernel->height=order;
-              kernel->values=(double *) AcquireAlignedMemory(order,order*
-                sizeof(*kernel->values));
-              if (kernel->values == (double *) NULL)
+              kernel->values=(MagickRealType *) AcquireAlignedMemory(order,
+                order*sizeof(*kernel->values));
+              if (kernel->values == (MagickRealType *) NULL)
                 {
                   kernel=DestroyKernelInfo(kernel);
                   ThrowPerlException(exception,ResourceLimitFatalError,
@@ -9368,7 +9368,7 @@ Mogrify(ref,...)
                   goto PerlException;
                 }
               for (j=0; (j < (ssize_t) (order*order)) && (j < (av_len(av)+1)); j++)
-                kernel->values[j]=(double) SvNV(*(av_fetch(av,j,0)));
+                kernel->values[j]=(MagickRealType) SvNV(*(av_fetch(av,j,0)));
               for ( ; j < (ssize_t) (order*order); j++)
                 kernel->values[j]=0.0;
             }
@@ -10323,9 +10323,14 @@ Mogrify(ref,...)
             break;
           kernel_info->width=order;
           kernel_info->height=order;
-          kernel_info->values=color_matrix;
-          image=ColorMatrixImage(image,kernel_info,exception);
-          kernel_info->values=(double *) NULL;
+          kernel_info->values=(MagickRealType *) AcquireAlignedMemory(order,
+            order*sizeof(*kernel_info->values));
+          if (kernel_info->values != (MagickRealType *) NULL)
+            {
+              for (i=0; i < (ssize_t) (order*order); i++)
+                kernel_info->values[i]=(MagickRealType) color_matrix[i];
+              image=ColorMatrixImage(image,kernel_info,exception);
+            }
           kernel_info=DestroyKernelInfo(kernel_info);
           color_matrix=(double *) RelinquishMagickMemory(color_matrix);
           break;