From: cristy <urban-warrior@git.imagemagick.org>
Date: Mon, 12 Sep 2011 01:26:56 +0000 (+0000)
Subject: (no commit message)
X-Git-Tag: 7.0.1-0~7027
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=76f512e2793d1009ff3005270814233530ddd6a9;p=imagemagick

---

diff --git a/Magick++/lib/Image.cpp b/Magick++/lib/Image.cpp
index 3bd561a6c..9ae4c158e 100644
--- a/Magick++/lib/Image.cpp
+++ b/Magick++/lib/Image.cpp
@@ -1251,7 +1251,7 @@ void Magick::Image::implode ( const double factor_ )
   ExceptionInfo exceptionInfo;
   GetExceptionInfo( &exceptionInfo );
   MagickCore::Image* newImage =
-    ImplodeImage( image(), factor_, &exceptionInfo );
+    ImplodeImage( image(), factor_, image()->interpolate, &exceptionInfo );
   replaceImage( newImage );
   throwException( exceptionInfo );
   (void) DestroyExceptionInfo( &exceptionInfo );
@@ -2088,7 +2088,7 @@ void Magick::Image::swirl ( const double degrees_ )
   ExceptionInfo exceptionInfo;
   GetExceptionInfo( &exceptionInfo );
   MagickCore::Image* newImage =
-    SwirlImage( image(), degrees_,
+    SwirlImage( image(), degrees_, image()->interpolate,
 		&exceptionInfo);
   replaceImage( newImage );
   throwException( exceptionInfo );
diff --git a/MagickCore/display.c b/MagickCore/display.c
index 2ca2d7826..b86406da2 100644
--- a/MagickCore/display.c
+++ b/MagickCore/display.c
@@ -8553,7 +8553,8 @@ static Image *XMagickCommand(Display *display,XResourceInfo *resource_info,
       XSetCursorState(display,windows,MagickTrue);
       XCheckRefreshWindows(display,windows);
       flags=ParseGeometry(degrees,&geometry_info);
-      swirl_image=SwirlImage(*image,geometry_info.rho,exception);
+      swirl_image=SwirlImage(*image,geometry_info.rho,(*image)->interpolate,
+        exception);
       if (swirl_image != (Image *) NULL)
         {
           *image=DestroyImage(*image);
@@ -8588,7 +8589,8 @@ static Image *XMagickCommand(Display *display,XResourceInfo *resource_info,
       XSetCursorState(display,windows,MagickTrue);
       XCheckRefreshWindows(display,windows);
       flags=ParseGeometry(factor,&geometry_info);
-      implode_image=ImplodeImage(*image,geometry_info.rho,exception);
+      implode_image=ImplodeImage(*image,geometry_info.rho,(*image)->interpolate,
+        exception);
       if (implode_image != (Image *) NULL)
         {
           *image=DestroyImage(*image);
diff --git a/MagickCore/effect.c b/MagickCore/effect.c
index e040844da..ff3b3c7aa 100644
--- a/MagickCore/effect.c
+++ b/MagickCore/effect.c
@@ -2678,7 +2678,8 @@ MagickExport Image *PreviewImage(const Image *image,const PreviewType preview,
       }
       case SwirlPreview:
       {
-        preview_image=SwirlImage(thumbnail,degrees,exception);
+        preview_image=SwirlImage(thumbnail,degrees,image->interpolate,
+          exception);
         (void) FormatLocaleString(label,MaxTextExtent,"swirl %g",degrees);
         degrees+=45.0;
         break;
@@ -2686,7 +2687,8 @@ MagickExport Image *PreviewImage(const Image *image,const PreviewType preview,
       case ImplodePreview:
       {
         degrees+=0.1f;
-        preview_image=ImplodeImage(thumbnail,degrees,exception);
+        preview_image=ImplodeImage(thumbnail,degrees,image->interpolate,
+          exception);
         (void) FormatLocaleString(label,MaxTextExtent,"implode %g",degrees);
         break;
       }
diff --git a/MagickCore/fx.c b/MagickCore/fx.c
index a5cc29670..d02618f18 100644
--- a/MagickCore/fx.c
+++ b/MagickCore/fx.c
@@ -3096,7 +3096,7 @@ MagickExport Image *FxImage(const Image *image,const char *expression,
 %  The format of the ImplodeImage method is:
 %
 %      Image *ImplodeImage(const Image *image,const double amount,
-%        ExceptionInfo *exception)
+%        const PixelInterpolateMethod method,ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
 %
@@ -3108,11 +3108,13 @@ MagickExport Image *FxImage(const Image *image,const char *expression,
 %
 %    o amount:  Define the extent of the implosion.
 %
+%    o method: the pixel interpolation method.
+%
 %    o exception: return any errors or warnings in this structure.
 %
 */
 MagickExport Image *ImplodeImage(const Image *image,const double amount,
-  ExceptionInfo *exception)
+  const PixelInterpolateMethod method,ExceptionInfo *exception)
 {
 #define ImplodeImageTag  "Implode/Image"
 
@@ -3129,9 +3131,6 @@ MagickExport Image *ImplodeImage(const Image *image,const double amount,
   MagickOffsetType
     progress;
 
-  PixelInfo
-    zero;
-
   MagickRealType
     radius;
 
@@ -3151,7 +3150,8 @@ MagickExport Image *ImplodeImage(const Image *image,const double amount,
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   assert(exception != (ExceptionInfo *) NULL);
   assert(exception->signature == MagickSignature);
-  implode_image=CloneImage(image,0,0,MagickTrue,exception);
+  implode_image=CloneImage(image,image->columns,image->rows,MagickTrue,
+    exception);
   if (implode_image == (Image *) NULL)
     return((Image *) NULL);
   if (SetImageStorageClass(implode_image,DirectClass,exception) == MagickFalse)
@@ -3182,7 +3182,6 @@ MagickExport Image *ImplodeImage(const Image *image,const double amount,
   */
   status=MagickTrue;
   progress=0;
-  GetPixelInfo(implode_image,&zero);
   image_view=AcquireCacheView(image);
   implode_view=AcquireCacheView(implode_image);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
@@ -3190,9 +3189,6 @@ MagickExport Image *ImplodeImage(const Image *image,const double amount,
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
-    PixelInfo
-      pixel;
-
     MagickRealType
       distance;
 
@@ -3215,7 +3211,6 @@ MagickExport Image *ImplodeImage(const Image *image,const double amount,
         continue;
       }
     delta.y=scale.y*(double) (y-center.y);
-    pixel=zero;
     for (x=0; x < (ssize_t) image->columns; x++)
     {
       /*
@@ -3235,11 +3230,9 @@ MagickExport Image *ImplodeImage(const Image *image,const double amount,
           if (distance > 0.0)
             factor=pow(sin((double) (MagickPI*sqrt((double) distance)/
               radius/2)),-amount);
-          (void) InterpolatePixelInfo(image,image_view,
-            UndefinedInterpolatePixel,(double) (factor*delta.x/scale.x+
-            center.x),(double) (factor*delta.y/scale.y+center.y),&pixel,
-            exception);
-          SetPixelPixelInfo(implode_image,&pixel,q);
+          status=InterpolatePixelChannels(image,image_view,implode_image,method,
+            (double) (factor*delta.x/scale.x+center.x),(double) (factor*delta.y/
+            scale.y+center.y),q,exception);
         }
       q+=GetPixelChannels(implode_image);
     }
@@ -4303,9 +4296,6 @@ MagickExport Image *SketchImage(const Image *image,const double radius,
   MagickBooleanType
     status;
 
-  PixelInfo
-    zero;
-
   RandomInfo
     **restrict random_info;
 
@@ -4320,7 +4310,6 @@ MagickExport Image *SketchImage(const Image *image,const double radius,
   if (random_image == (Image *) NULL)
     return((Image *) NULL);
   status=MagickTrue;
-  GetPixelInfo(random_image,&zero);
   random_info=AcquireRandomInfoThreadSet();
   random_view=AcquireCacheView(random_image);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
@@ -4331,9 +4320,6 @@ MagickExport Image *SketchImage(const Image *image,const double radius,
     const int
       id = GetOpenMPThreadId();
 
-    PixelInfo
-      pixel;
-
     register ssize_t
       x;
 
@@ -4349,16 +4335,25 @@ MagickExport Image *SketchImage(const Image *image,const double radius,
         status=MagickFalse;
         continue;
       }
-    pixel=zero;
     for (x=0; x < (ssize_t) random_image->columns; x++)
     {
-      pixel.red=(MagickRealType) (QuantumRange*
-        GetPseudoRandomValue(random_info[id]));
-      pixel.green=pixel.red;
-      pixel.blue=pixel.red;
-      if (image->colorspace == CMYKColorspace)
-        pixel.black=pixel.red;
-      SetPixelPixelInfo(random_image,&pixel,q);
+      MagickRealType
+        value;
+
+      register ssize_t
+        i;
+
+      value=GetPseudoRandomValue(random_info[id]);
+      for (i=0; i < (ssize_t) GetPixelChannels(random_image); i++)
+      {
+        PixelTrait
+          traits;
+
+        traits=GetPixelChannelMapTraits(random_image,(PixelChannel) i);
+        if (traits == UndefinedPixelTrait)
+          continue;
+        q[i]=ClampToQuantum(QuantumRange*value);
+      }
       q+=GetPixelChannels(random_image);
     }
     if (SyncCacheViewAuthenticPixels(random_view,exception) == MagickFalse)
@@ -4500,12 +4495,21 @@ MagickExport MagickBooleanType SolarizeImage(Image *image,
       }
     for (x=0; x < (ssize_t) image->columns; x++)
     {
-      if ((MagickRealType) GetPixelRed(image,q) > threshold)
-        SetPixelRed(image,QuantumRange-GetPixelRed(image,q),q);
-      if ((MagickRealType) GetPixelGreen(image,q) > threshold)
-        SetPixelGreen(image,QuantumRange-GetPixelGreen(image,q),q);
-      if ((MagickRealType) GetPixelBlue(image,q) > threshold)
-        SetPixelBlue(image,QuantumRange-GetPixelBlue(image,q),q);
+      register ssize_t
+        i;
+
+      for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+      {
+        PixelTrait
+          traits;
+
+        traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+        if ((traits == UndefinedPixelTrait) ||
+            ((traits & CopyPixelTrait) != 0))
+          continue;
+        if ((MagickRealType) q[i] > threshold)
+          q[i]=QuantumRange-q[i];
+      }
       q+=GetPixelChannels(image);
     }
     if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
@@ -4807,19 +4811,20 @@ MagickExport Image *StereoAnaglyphImage(const Image *left_image,
       exception);
     q=GetVirtualPixels(right_image,0,y,right_image->columns,1,exception);
     r=QueueAuthenticPixels(stereo_image,0,y,stereo_image->columns,1,exception);
-    if ((p == (const Quantum *) NULL) ||
-        (q == (Quantum *) NULL) || (r == (Quantum *) NULL))
+    if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL) ||
+        (r == (Quantum *) NULL))
       break;
     for (x=0; x < (ssize_t) stereo_image->columns; x++)
     {
       SetPixelRed(image,GetPixelRed(left_image,p),r);
-      SetPixelGreen(image,GetPixelGreen(left_image,q),r);
-      SetPixelBlue(image,GetPixelBlue(left_image,q),r);
-      SetPixelAlpha(image,(GetPixelAlpha(left_image,p)+
-        GetPixelAlpha(left_image,q))/2,r);
+      SetPixelGreen(image,GetPixelGreen(right_image,q),r);
+      SetPixelBlue(image,GetPixelBlue(right_image,q),r);
+      if ((GetPixelAlphaTraits(stereo_image) & CopyPixelTrait) != 0)
+        SetPixelAlpha(image,(GetPixelAlpha(left_image,p)+
+          GetPixelAlpha(right_image,q))/2,r);
       p+=GetPixelChannels(left_image);
-      q++;
-      r++;
+      q+=GetPixelChannels(right_image);
+      r+=GetPixelChannels(stereo_image);
     }
     if (SyncAuthenticPixels(stereo_image,exception) == MagickFalse)
       break;
@@ -4860,7 +4865,7 @@ MagickExport Image *StereoAnaglyphImage(const Image *left_image,
 %  The format of the SwirlImage method is:
 %
 %      Image *SwirlImage(const Image *image,double degrees,
-%        ExceptionInfo *exception)
+%        const PixelInterpolateMethod method,ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
 %
@@ -4868,11 +4873,13 @@ MagickExport Image *StereoAnaglyphImage(const Image *left_image,
 %
 %    o degrees: Define the tightness of the swirling effect.
 %
+%    o method: the pixel interpolation method.
+%
 %    o exception: return any errors or warnings in this structure.
 %
 */
 MagickExport Image *SwirlImage(const Image *image,double degrees,
-  ExceptionInfo *exception)
+  const PixelInterpolateMethod method,ExceptionInfo *exception)
 {
 #define SwirlImageTag  "Swirl/Image"
 
@@ -4889,9 +4896,6 @@ MagickExport Image *SwirlImage(const Image *image,double degrees,
   MagickOffsetType
     progress;
 
-  PixelInfo
-    zero;
-
   MagickRealType
     radius;
 
@@ -4911,7 +4915,7 @@ MagickExport Image *SwirlImage(const Image *image,double degrees,
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   assert(exception != (ExceptionInfo *) NULL);
   assert(exception->signature == MagickSignature);
-  swirl_image=CloneImage(image,0,0,MagickTrue,exception);
+  swirl_image=CloneImage(image,image->columns,image->rows,MagickTrue,exception);
   if (swirl_image == (Image *) NULL)
     return((Image *) NULL);
   if (SetImageStorageClass(swirl_image,DirectClass,exception) == MagickFalse)
@@ -4940,7 +4944,6 @@ MagickExport Image *SwirlImage(const Image *image,double degrees,
   */
   status=MagickTrue;
   progress=0;
-  GetPixelInfo(swirl_image,&zero);
   image_view=AcquireCacheView(image);
   swirl_view=AcquireCacheView(swirl_image);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
@@ -4948,9 +4951,6 @@ MagickExport Image *SwirlImage(const Image *image,double degrees,
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
-    PixelInfo
-      pixel;
-
     MagickRealType
       distance;
 
@@ -4973,7 +4973,6 @@ MagickExport Image *SwirlImage(const Image *image,double degrees,
         continue;
       }
     delta.y=scale.y*(double) (y-center.y);
-    pixel=zero;
     for (x=0; x < (ssize_t) image->columns; x++)
     {
       /*
@@ -4994,11 +4993,9 @@ MagickExport Image *SwirlImage(const Image *image,double degrees,
           factor=1.0-sqrt((double) distance)/radius;
           sine=sin((double) (degrees*factor*factor));
           cosine=cos((double) (degrees*factor*factor));
-          (void) InterpolatePixelInfo(image,image_view,
-            UndefinedInterpolatePixel,(double) ((cosine*delta.x-sine*delta.y)/
-            scale.x+center.x),(double) ((sine*delta.x+cosine*delta.y)/scale.y+
-            center.y),&pixel,exception);
-          SetPixelPixelInfo(swirl_image,&pixel,q);
+          status=InterpolatePixelChannels(image,image_view,swirl_image,method,
+            ((cosine*delta.x-sine*delta.y)/scale.x+center.x),(double)
+            ((sine*delta.x+cosine*delta.y)/scale.y+center.y),q,exception);
         }
       q+=GetPixelChannels(swirl_image);
     }
@@ -5114,18 +5111,24 @@ MagickExport Image *TintImage(const Image *image,const char *opacity,
   GetPixelInfo(image,&pixel);
   flags=ParseGeometry(opacity,&geometry_info);
   pixel.red=geometry_info.rho;
+  pixel.green=geometry_info.rho;
+  pixel.blue=geometry_info.rho;
+  pixel.black=geometry_info.rho;
+  pixel.alpha=OpaqueAlpha;
   if ((flags & SigmaValue) != 0)
     pixel.green=geometry_info.sigma;
-  else
-    pixel.green=pixel.red;
   if ((flags & XiValue) != 0)
     pixel.blue=geometry_info.xi;
+  if (image->colorspace == CMYKColorspace)
+    {
+      if ((flags & PsiValue) != 0)
+        pixel.black=geometry_info.psi;
+      if ((flags & ChiValue) != 0)
+        pixel.alpha=geometry_info.chi;
+    }
   else
-    pixel.blue=pixel.red;
-  if ((flags & PsiValue) != 0)
-    pixel.alpha=geometry_info.psi;
-  else
-    pixel.alpha=(MagickRealType) OpaqueAlpha;
+    if ((flags & PsiValue) != 0)
+      pixel.alpha=geometry_info.psi;
   intensity=(MagickRealType) GetPixelInfoIntensity(tint);
   color_vector.red=(MagickRealType) (pixel.red*tint->red/100.0-intensity);
   color_vector.green=(MagickRealType) (pixel.green*tint->green/100.0-intensity);
@@ -5171,35 +5174,35 @@ MagickExport Image *TintImage(const Image *image,const char *opacity,
       MagickRealType
         weight;
 
-      if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
+      if ((GetPixelRedTraits(tint_image) & UpdatePixelTrait) != 0)
         {
           weight=QuantumScale*GetPixelRed(image,p)-0.5;
           pixel.red=(MagickRealType) GetPixelRed(image,p)+
             color_vector.red*(1.0-(4.0*(weight*weight)));
           SetPixelRed(tint_image,ClampToQuantum(pixel.red),q);
         }
-      if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
+      if ((GetPixelGreenTraits(tint_image) & UpdatePixelTrait) != 0)
         {
           weight=QuantumScale*GetPixelGreen(image,p)-0.5;
           pixel.green=(MagickRealType) GetPixelGreen(image,p)+
             color_vector.green*(1.0-(4.0*(weight*weight)));
           SetPixelGreen(tint_image,ClampToQuantum(pixel.green),q);
         }
-      if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
+      if ((GetPixelBlueTraits(tint_image) & UpdatePixelTrait) != 0)
         {
           weight=QuantumScale*GetPixelBlue(image,p)-0.5;
           pixel.blue=(MagickRealType) GetPixelBlue(image,p)+
             color_vector.blue*(1.0-(4.0*(weight*weight)));
           SetPixelBlue(tint_image,ClampToQuantum(pixel.blue),q);
         }
-      if ((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0)
+      if ((GetPixelBlackTraits(tint_image) & UpdatePixelTrait) != 0)
         {
           weight=QuantumScale*GetPixelBlack(image,p)-0.5;
           pixel.black=(MagickRealType) GetPixelBlack(image,p)+
             color_vector.black*(1.0-(4.0*(weight*weight)));
           SetPixelBlack(tint_image,ClampToQuantum(pixel.black),q);
         }
-      if ((GetPixelAlphaTraits(image) & CopyPixelTrait) != 0)
+      if ((GetPixelAlphaTraits(tint_image) & CopyPixelTrait) != 0)
         SetPixelAlpha(tint_image,GetPixelAlpha(image,p),q);
       p+=GetPixelChannels(image);
       q+=GetPixelChannels(tint_image);
diff --git a/MagickCore/fx.h b/MagickCore/fx.h
index f5f60a8e6..e3fb10832 100644
--- a/MagickCore/fx.h
+++ b/MagickCore/fx.h
@@ -44,7 +44,8 @@ extern MagickExport Image
   *ColorizeImage(const Image *,const char *,const PixelPacket,ExceptionInfo *),
   *ColorMatrixImage(const Image *,const KernelInfo *kernel,ExceptionInfo *),
   *FxImage(const Image *,const char *,ExceptionInfo *),
-  *ImplodeImage(const Image *,const double,ExceptionInfo *),
+  *ImplodeImage(const Image *,const double,const PixelInterpolateMethod,
+    ExceptionInfo *),
   *MorphImages(const Image *,const size_t,ExceptionInfo *),
   *PolaroidImage(const Image *,const DrawInfo *,const double,
     const PixelInterpolateMethod,ExceptionInfo *),
@@ -57,7 +58,8 @@ extern MagickExport Image
   *StereoImage(const Image *,const Image *,ExceptionInfo *),
   *StereoAnaglyphImage(const Image *,const Image *,const ssize_t,const ssize_t,
      ExceptionInfo *),
-  *SwirlImage(const Image *,double,ExceptionInfo *),
+  *SwirlImage(const Image *,double,const PixelInterpolateMethod,
+    ExceptionInfo *),
   *TintImage(const Image *,const char *,const PixelInfo *,ExceptionInfo *),
   *VignetteImage(const Image *,const double,const double,const ssize_t,
     const ssize_t,ExceptionInfo *),
diff --git a/MagickWand/magick-image.c b/MagickWand/magick-image.c
index 2da578478..e8954483e 100644
--- a/MagickWand/magick-image.c
+++ b/MagickWand/magick-image.c
@@ -5790,7 +5790,7 @@ WandExport char *MagickIdentifyImage(MagickWand *wand)
 %  The format of the MagickImplodeImage method is:
 %
 %      MagickBooleanType MagickImplodeImage(MagickWand *wand,
-%        const double radius)
+%        const double radius,const PixelInterpolateMethod method)
 %
 %  A description of each parameter follows:
 %
@@ -5798,9 +5798,11 @@ WandExport char *MagickIdentifyImage(MagickWand *wand)
 %
 %    o amount: Define the extent of the implosion.
 %
+%    o method: the pixel interpolation method.
+%
 */
 WandExport MagickBooleanType MagickImplodeImage(MagickWand *wand,
-  const double amount)
+  const double amount,const PixelInterpolateMethod method)
 {
   Image
     *implode_image;
@@ -5811,7 +5813,7 @@ WandExport MagickBooleanType MagickImplodeImage(MagickWand *wand,
     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
   if (wand->images == (Image *) NULL)
     ThrowWandException(WandError,"ContainsNoImages",wand->name);
-  implode_image=ImplodeImage(wand->images,amount,wand->exception);
+  implode_image=ImplodeImage(wand->images,amount,method,wand->exception);
   if (implode_image == (Image *) NULL)
     return(MagickFalse);
   ReplaceImageInList(&wand->images,implode_image);
@@ -11040,7 +11042,8 @@ WandExport MagickBooleanType MagickStripImage(MagickWand *wand)
 %
 %  The format of the MagickSwirlImage method is:
 %
-%      MagickBooleanType MagickSwirlImage(MagickWand *wand,const double degrees)
+%      MagickBooleanType MagickSwirlImage(MagickWand *wand,const double degrees,
+%        const PixelInterpolateMethod method)
 %
 %  A description of each parameter follows:
 %
@@ -11048,9 +11051,11 @@ WandExport MagickBooleanType MagickStripImage(MagickWand *wand)
 %
 %    o degrees: Define the tightness of the swirling effect.
 %
+%    o method: the pixel interpolation method.
+%
 */
 WandExport MagickBooleanType MagickSwirlImage(MagickWand *wand,
-  const double degrees)
+  const double degrees,const PixelInterpolateMethod method)
 {
   Image
     *swirl_image;
@@ -11061,7 +11066,7 @@ WandExport MagickBooleanType MagickSwirlImage(MagickWand *wand,
     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
   if (wand->images == (Image *) NULL)
     ThrowWandException(WandError,"ContainsNoImages",wand->name);
-  swirl_image=SwirlImage(wand->images,degrees,wand->exception);
+  swirl_image=SwirlImage(wand->images,degrees,method,wand->exception);
   if (swirl_image == (Image *) NULL)
     return(MagickFalse);
   ReplaceImageInList(&wand->images,swirl_image);
@@ -11282,12 +11287,21 @@ WandExport MagickBooleanType MagickTintImage(MagickWand *wand,
     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
   if (wand->images == (Image *) NULL)
     ThrowWandException(WandError,"ContainsNoImages",wand->name);
-  (void) FormatLocaleString(percent_opaque,MaxTextExtent,
-    "%g,%g,%g,%g",(double) (100.0*QuantumScale*
-    PixelGetRedQuantum(opacity)),(double) (100.0*QuantumScale*
-    PixelGetGreenQuantum(opacity)),(double) (100.0*QuantumScale*
-    PixelGetBlueQuantum(opacity)),(double) (100.0*QuantumScale*
-    PixelGetOpacityQuantum(opacity)));
+  if (wand->images->colorspace != CMYKColorspace)
+    (void) FormatLocaleString(percent_opaque,MaxTextExtent,
+      "%g,%g,%g,%g",(double) (100.0*QuantumScale*
+      PixelGetRedQuantum(opacity)),(double) (100.0*QuantumScale*
+      PixelGetGreenQuantum(opacity)),(double) (100.0*QuantumScale*
+      PixelGetBlueQuantum(opacity)),(double) (100.0*QuantumScale*
+      PixelGetOpacityQuantum(opacity)));
+  else
+    (void) FormatLocaleString(percent_opaque,MaxTextExtent,
+      "%g,%g,%g,%g,%g",(double) (100.0*QuantumScale*
+      PixelGetCyanQuantum(opacity)),(double) (100.0*QuantumScale*
+      PixelGetMagentaQuantum(opacity)),(double) (100.0*QuantumScale*
+      PixelGetYellowQuantum(opacity)),(double) (100.0*QuantumScale*
+      PixelGetBlackQuantum(opacity)),(double) (100.0*QuantumScale*
+      PixelGetOpacityQuantum(opacity)));
   target=PixelGetPixel(tint);
   tint_image=TintImage(wand->images,percent_opaque,&target,wand->exception);
   if (tint_image == (Image *) NULL)
diff --git a/MagickWand/magick-image.h b/MagickWand/magick-image.h
index d5a72fd86..9af410145 100644
--- a/MagickWand/magick-image.h
+++ b/MagickWand/magick-image.h
@@ -165,7 +165,7 @@ extern WandExport MagickBooleanType
   MagickHaldClutImage(MagickWand *,const MagickWand *),
   MagickHasNextImage(MagickWand *),
   MagickHasPreviousImage(MagickWand *),
-  MagickImplodeImage(MagickWand *,const double),
+  MagickImplodeImage(MagickWand *,const double,const PixelInterpolateMethod),
   MagickImportImagePixels(MagickWand *,const ssize_t,const ssize_t,const size_t,
     const size_t,const char *,const StorageType,const void *),
   MagickInverseFourierTransformImage(MagickWand *,MagickWand *,
@@ -291,7 +291,7 @@ extern WandExport MagickBooleanType
   MagickStatisticImage(MagickWand *,const StatisticType,const size_t,
     const size_t),
   MagickStripImage(MagickWand *),
-  MagickSwirlImage(MagickWand *,const double),
+  MagickSwirlImage(MagickWand *,const double,const PixelInterpolateMethod),
   MagickTintImage(MagickWand *,const PixelWand *,const PixelWand *),
   MagickTransformImageColorspace(MagickWand *,const ColorspaceType),
   MagickTransposeImage(MagickWand *),
diff --git a/MagickWand/mogrify.c b/MagickWand/mogrify.c
index 6dbdfa48a..34241782f 100644
--- a/MagickWand/mogrify.c
+++ b/MagickWand/mogrify.c
@@ -1792,7 +1792,8 @@ WandExport MagickBooleanType MogrifyImage(ImageInfo *image_info,const int argc,
             */
             (void) SyncImageSettings(mogrify_info,*image);
             (void) ParseGeometry(argv[i+1],&geometry_info);
-            mogrify_image=ImplodeImage(*image,geometry_info.rho,exception);
+            mogrify_image=ImplodeImage(*image,geometry_info.rho,
+              interpolate_method,exception);
             break;
           }
         if (LocaleCompare("interline-spacing",option+1) == 0)
@@ -2883,7 +2884,8 @@ WandExport MagickBooleanType MogrifyImage(ImageInfo *image_info,const int argc,
             */
             (void) SyncImageSettings(mogrify_info,*image);
             (void) ParseGeometry(argv[i+1],&geometry_info);
-            mogrify_image=SwirlImage(*image,geometry_info.rho,exception);
+            mogrify_image=SwirlImage(*image,geometry_info.rho,
+              interpolate_method,exception);
             break;
           }
         break;
diff --git a/PerlMagick/Magick.xs b/PerlMagick/Magick.xs
index 4577677f3..fa3a7e15d 100644
--- a/PerlMagick/Magick.xs
+++ b/PerlMagick/Magick.xs
@@ -7688,19 +7688,23 @@ Mogrify(ref,...)
           if ((attribute_flag[5] != 0) || (attribute_flag[6] != 0))
             image->matte_color=fill_color;
           if (attribute_flag[7] != 0)
-            image->compose=(CompositeOperator) argument_list[7].integer_reference;
+            image->compose=(CompositeOperator)
+              argument_list[7].integer_reference;
           image=FrameImage(image,&frame_info,exception);
           break;
         }
         case 16:  /* Implode */
         {
+          PixelInterpolateMethod
+            method;
+
           if (attribute_flag[0] == 0)
             argument_list[0].real_reference=0.5;
+          method=UndefinedInterpolatePixel;
           if (attribute_flag[1] != 0)
-            image->interpolate=(PixelInterpolateMethod)
-              argument_list[1].integer_reference;
+            method=(PixelInterpolateMethod) argument_list[1].integer_reference;
           image=ImplodeImage(image,argument_list[0].real_reference,
-            exception);
+            method,exception);
           break;
         }
         case 17:  /* Magnify */
@@ -7900,12 +7904,16 @@ Mogrify(ref,...)
         }
         case 30:  /* Swirl */
         {
+          PixelInterpolateMethod
+            method;
+
           if (attribute_flag[0] == 0)
             argument_list[0].real_reference=50.0;
+          method=UndefinedInterpolatePixel;
           if (attribute_flag[1] != 0)
-            image->interpolate=(PixelInterpolateMethod)
-              argument_list[1].integer_reference;
-          image=SwirlImage(image,argument_list[0].real_reference,exception);
+            method=(PixelInterpolateMethod) argument_list[1].integer_reference;
+          image=SwirlImage(image,argument_list[0].real_reference,
+            method,exception);
           break;
         }
         case 31:  /* Resize */
diff --git a/coders/msl.c b/coders/msl.c
index cd083b0cc..a11f25ed5 100644
--- a/coders/msl.c
+++ b/coders/msl.c
@@ -3455,7 +3455,7 @@ static void MSLStartElement(void *context,const xmlChar *tag,
               }
             }
           implode_image=ImplodeImage(msl_info->image[n],geometry_info.rho,
-            &msl_info->image[n]->exception);
+            msl_info->image[n]->interpolate,&msl_info->image[n]->exception);
           if (implode_image == (Image *) NULL)
             break;
           msl_info->image[n]=DestroyImage(msl_info->image[n]);
@@ -7029,7 +7029,7 @@ static void MSLStartElement(void *context,const xmlChar *tag,
               }
             }
           swirl_image=SwirlImage(msl_info->image[n],geometry_info.rho,
-            &msl_info->image[n]->exception);
+            msl_info->image[n]->interpolate,&msl_info->image[n]->exception);
           if (swirl_image == (Image *) NULL)
             break;
           msl_info->image[n]=DestroyImage(msl_info->image[n]);