rmagick 2.5.2 → 2.6.0

data/ext/RMagick/rmfill.c

@@ -1,4 +1,4 @@
-/* $Id: rmfill.c,v 1.29 2008/05/28 22:40:15 rmagick Exp $ */
+/* $Id: rmfill.c,v 1.30 2008/09/02 23:40:19 rmagick Exp $ */
 /*============================================================================\
 |                Copyright (C) 2008 by Timothy P. Hunter
 | Name:     rmfill.c
@@ -511,7 +511,7 @@ TextureFill_initialize(VALUE self, VALUE texture_arg)
 
     Data_Get_Struct(self, rm_TextureFill, fill);
 
-    texture_image = ImageList_cur_image(texture_arg);
+    texture_image = rm_cur_image(texture_arg);
 
     // Bump the reference count on the texture image.
     texture = rm_check_destroyed(texture_image);

data/ext/RMagick/rmilist.c

@@ -1,4 +1,4 @@
-/* $Id: rmilist.c,v 1.73 2008/07/13 14:31:37 rmagick Exp $ */
+/* $Id: rmilist.c,v 1.84 2008/09/10 22:08:55 rmagick Exp $ */
 /*============================================================================\
 |                Copyright (C) 2008 by Timothy P. Hunter
 | Name:     rmilist.c
@@ -16,6 +16,54 @@ static void imagelist_push(VALUE, VALUE);
 static VALUE ImageList_new(void);
 
 
+
+/*
+    Method:     ImageList#affinity(affinity_image=nil, dither_method=RiemersmaDitherMethod)
+    Purpose:    Call AffinityImages
+    Note:       See Image_affinity. Immediate - modifies images in-place
+*/
+VALUE
+ImageList_affinity(int argc, VALUE *argv, VALUE self)
+{
+#if defined(HAVE_AFFINITYIMAGES)
+    Image *images, *affinity_image = NULL;
+    QuantizeInfo quantize_info;
+
+    images = images_from_imagelist(self);
+
+    if (argc > 0 && argv[0] != Qnil)
+    {
+        volatile VALUE t = rm_cur_image(argv[0]);
+        affinity_image = rm_check_destroyed(t);
+    }
+
+    GetQuantizeInfo(&quantize_info);
+
+    if (argc > 1)
+    {
+        VALUE_TO_ENUM(argv[1], quantize_info.dither_method, DitherMethod);
+        quantize_info.dither = MagickTrue;
+    }
+    if (argc > 2)
+    {
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc);
+    }
+
+    (void) AffinityImages(&quantize_info, images, affinity_image);
+    rm_check_image_exception(images, RetainOnError);
+    rm_split(images);
+
+    return self;
+#else
+    self = self;
+    argc = argc;
+    argv = argv;
+    rm_not_implemented();
+    return(VALUE)0;
+#endif
+}
+
+
 /*
     Method:     ImageList#animate(<delay>)
     Purpose:    repeatedly display the images in the images array to an XWindow
@@ -62,6 +110,7 @@ ImageList_animate(int argc, VALUE *argv, VALUE self)
     return self;
 }
 
+
 /*
     Method:     ImageList#append(stack)
     Purpose:    Append all the images by calling ImageAppend
@@ -92,6 +141,7 @@ ImageList_append(VALUE self, VALUE stack_arg)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     ImageList#average
     Purpose:    Average all images together by calling AverageImages
@@ -117,6 +167,7 @@ ImageList_average(VALUE self)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     ImageList#coalesce
     Purpose:    call CoalesceImages
@@ -234,6 +285,7 @@ ImageList_deconstruct(VALUE self)
     return rm_imagelist_from_images(new_images);
 }
 
+
 /*
     Method:     ImageList#display
     Purpose:    Display all the images to an X window screen.
@@ -259,6 +311,7 @@ ImageList_display(VALUE self)
     return self;
 }
 
+
 /*
     Method:     ImageList#flatten_images
     Purpose:    merge all the images into a single image
@@ -329,7 +382,6 @@ ImageList_fx(int argc, VALUE *argv, VALUE self)
 }
 
 
-
 /*
     Method:     ImageList#map(reference, dither=false)
     Purpose:    Call MapImages
@@ -344,12 +396,16 @@ ImageList_map(int argc, VALUE *argv, VALUE self)
     volatile VALUE scene, new_imagelist, t;
     ExceptionInfo exception;
 
+#if defined(HAVE_AFFINITYIMAGES)
+    rb_warning("ImageList#map is deprecated. Use ImageList#affinity instead.");
+#endif
+
     switch (argc)
     {
         case 2:
             dither = RTEST(argv[1]);
         case 1:
-            t = ImageList_cur_image(argv[0]);
+            t = rm_cur_image(argv[0]);
             map = rm_check_destroyed(t);
             break;
         default:
@@ -386,6 +442,7 @@ ImageList_map(int argc, VALUE *argv, VALUE self)
     return new_imagelist;
 }
 
+
 /*
     Method:     ImageList#montage <{parm block}>
     Purpose:    Call MontageImages
@@ -436,6 +493,7 @@ ImageList_montage(VALUE self)
     return rm_imagelist_from_images(new_images);
 }
 
+
 /*
     Method:     ImageList#morph(number_images)
     Purpose:    requires a minimum of two images. The first image is
@@ -475,6 +533,7 @@ ImageList_morph(VALUE self, VALUE nimages)
     return rm_imagelist_from_images(new_images);
 }
 
+
 /*
     Method:     ImageList#mosaic
     Purpose:    merge all the images into a single image
@@ -706,6 +765,7 @@ imagelist_scene_eq(VALUE imagelist, VALUE scene)
     return scene;
 }
 
+
 /*
     Static:    imagelist_length
     Purpose:   return the # of images in an imagelist
@@ -717,6 +777,7 @@ imagelist_length(VALUE imagelist)
     return RARRAY_LEN(images);
 }
 
+
 /*
     Static:     imagelist_push
     Purpose:    push an image onto the end of the imagelist
@@ -780,7 +841,15 @@ ImageList_quantize(int argc, VALUE *argv, VALUE self)
         case 4:
             quantize_info.tree_depth = (unsigned long)NUM2INT(argv[3]);
         case 3:
+#if defined(HAVE_TYPE_DITHERMETHOD)
+            if (rb_obj_is_kind_of(argv[2], Class_DitherMethod))
+            {
+                VALUE_TO_ENUM(argv[2], quantize_info.dither_method, DitherMethod);
+                quantize_info.dither = quantize_info.dither_method != NoDitherMethod;
+            }
+#else
             quantize_info.dither = (MagickBooleanType) RTEST(argv[2]);
+#endif
         case 2:
             VALUE_TO_ENUM(argv[1], quantize_info.colorspace, ColorspaceType);
         case 1:
@@ -826,6 +895,7 @@ ImageList_quantize(int argc, VALUE *argv, VALUE self)
     return new_imagelist;
 }
 
+
 /*
     Method:     ImageList#to_blob
     Purpose:    returns the imagelist as a blob (a String)
@@ -867,9 +937,11 @@ ImageList_to_blob(VALUE self)
     // doesn't support multi-image files.
     info->adjoin = MagickTrue;
     blob = ImagesToBlob(info, images, &length, &exception);
-    if (exception.severity != UndefinedException)
+    if (blob && exception.severity >= ErrorException)
     {
         magick_free((void*)blob);
+        blob = NULL;
+        length = 0;
     }
     rm_split(images);
     CHECK_EXCEPTION()
@@ -888,17 +960,6 @@ ImageList_to_blob(VALUE self)
 }
 
 
-/*
- *  Static:     file_arg_rescue
- *  Purpose:    called when `arg_to_str' raised an exception
-*/
-static VALUE file_arg_rescue(VALUE arg)
-{
-    rb_raise(rb_eTypeError, "argument must be path name or open file (%s given)",
-             rb_class2name(CLASS_OF(arg)));
-}
-
-
 /*
   Method:   ImageList#write(file)
   Purpose:  Write all the images to the specified file. If the file format
@@ -914,8 +975,6 @@ ImageList_write(VALUE self, VALUE file)
     Info *info;
     const MagickInfo *m;
     volatile VALUE info_obj;
-    char *filename;
-    long filename_l;
     unsigned long scene;
     ExceptionInfo exception;
 
@@ -933,21 +992,14 @@ ImageList_write(VALUE self, VALUE file)
     }
     else
     {
-        // Convert arg to string. Catch exceptions.
-        file = rb_rescue(rb_String, file, file_arg_rescue, file);
-
-        // Copy the filename to the Info and to the Image.
-        filename = rm_str2cstr(file, &filename_l);
-        filename_l = min(filename_l, MaxTextExtent-1);
-        memcpy(info->filename, filename, (size_t)filename_l);
-        info->filename[filename_l] = '\0';
+        add_format_prefix(info, file);
         SetImageInfoFile(info, NULL);
     }
 
     // Convert the images array to an images sequence.
     images = images_from_imagelist(self);
 
-    // Copy the filename into each images. Set a scene number to be used if
+    // Copy the filename into each image. Set a scene number to be used if
     // writing multiple files. (Ref: ImageMagick's utilities/convert.c
     for (scene = 0, img = images; img; img = GetNextImageInList(img))
     {
@@ -955,13 +1007,11 @@ ImageList_write(VALUE self, VALUE file)
         strcpy(img->filename, info->filename);
     }
 
+    // Find out if the format supports multi-images files.
     GetExceptionInfo(&exception);
     (void) SetImageInfo(info, MagickTrue, &exception);
     rm_check_exception(&exception, images, RetainOnError);
-    (void) DestroyExceptionInfo(&exception);
 
-    // Find out if the format supports multi-images files.
-    GetExceptionInfo(&exception);
     m = GetMagickInfo(info->magick, &exception);
     rm_check_exception(&exception, images, RetainOnError);
     (void) DestroyExceptionInfo(&exception);

data/ext/RMagick/rmimage.c

@@ -1,4 +1,4 @@
-/* $Id: rmimage.c,v 1.298 2008/07/13 21:18:28 rmagick Exp $ */
+/* $Id: rmimage.c,v 1.319 2008/09/10 22:16:58 rmagick Exp $ */
 /*============================================================================\
 |                Copyright (C) 2008 by Timothy P. Hunter
 | Name:     rmimage.c
@@ -37,11 +37,9 @@ static const char *BlackPointCompensationKey = "PROFILE:black-point-compensation
     Static:     adaptive_method
     Purpose:    call Adaptive(Blur|Sharpen)Image
 */
-static VALUE adaptive_method(
-                            int argc,
-                            VALUE *argv,
-                            VALUE self,
-                            Image *fp(const Image *, const double, const double, ExceptionInfo *))
+static VALUE
+adaptive_method(int argc, VALUE *argv, VALUE self
+                , Image *fp(const Image *, const double, const double, ExceptionInfo *))
 {
     Image *image, *new_image;
     double radius = 0.0;
@@ -81,11 +79,9 @@ static VALUE adaptive_method(
     Static:     adaptive_channel_method
     Purpose:    call Adaptive(Blur|Sharpen)ImageChannel
 */
-static VALUE adaptive_channel_method(
-                                    int argc,
-                                    VALUE *argv,
-                                    VALUE self,
-                                    Image *fp(const Image *, const ChannelType, const double, const double, ExceptionInfo *))
+static VALUE
+adaptive_channel_method(int argc, VALUE *argv, VALUE self
+                        , Image *fp(const Image *, const ChannelType, const double, const double, ExceptionInfo *))
 {
     Image *image, *new_image;
     double radius = 0.0;
@@ -434,7 +430,7 @@ Image_add_profile(VALUE self, VALUE name)
         if (profile)
         {
             (void)ProfileImage(image, profile_name, GetStringInfoDatum(profile)
-                             , GetStringInfoLength(profile), MagickFalse);
+                               , GetStringInfoLength(profile), MagickFalse);
             if (image->exception.severity >= ErrorException)
             {
                 break;
@@ -573,6 +569,56 @@ Image_alpha_eq(VALUE self, VALUE type)
 }
 
 
+
+/*
+     Method:    Image#affinity(affinity_image, dither_method=RiemersmaDitherMethod)
+     Purpose:   Call AffinityImage
+     Notes:     Immediate - modifies image in-place
+*/
+VALUE
+Image_affinity(int argc, VALUE *argv, VALUE self)
+{
+#if defined(HAVE_AFFINITYIMAGE)
+    Image *image, *affinity_image;
+    QuantizeInfo quantize_info;
+
+    image = rm_check_frozen(self);
+    if (argc > 0)
+    {
+        volatile VALUE t = rm_cur_image(argv[0]);
+        affinity_image = rm_check_destroyed(t);
+    }
+
+    GetQuantizeInfo(&quantize_info);
+
+    switch (argc)
+    {
+        case 2:
+            VALUE_TO_ENUM(argv[1], quantize_info.dither_method, DitherMethod);
+            quantize_info.dither = MagickTrue;
+            break;
+        case 1:
+            break;
+        default:
+            rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc);
+            break;
+    }
+
+
+    (void) AffinityImage(&quantize_info, image, affinity_image);
+    rm_check_image_exception(image, RetainOnError);
+
+    return self;
+#else
+    self = self;
+    argc = argc;
+    argv = argv;
+    rm_not_implemented();
+    return(VALUE)0;
+#endif
+}
+
+
 /*
     Method:     Image#affine_transform(affine_matrix)
     Purpose:    transforms an image as dictated by the affine matrix argument
@@ -718,10 +764,7 @@ Image_aset(VALUE self, VALUE key_arg, VALUE attr_arg)
     Purpose:    Handle #transverse, #transform methods
 */
 static VALUE
-crisscross(
-          int bang,
-          VALUE self,
-          Image *fp(const Image *, ExceptionInfo *))
+crisscross(int bang, VALUE self, Image *fp(const Image *, ExceptionInfo *))
 {
     Image *image, *new_image;
     ExceptionInfo exception;
@@ -754,7 +797,8 @@ crisscross(
                 automatically orient image based on EXIF orientation value
     Notes:      See mogrify.c in ImageMagick 6.2.8.
 */
-static VALUE auto_orient(int bang, VALUE self)
+static VALUE
+auto_orient(int bang, VALUE self)
 {
     Image *image;
     volatile VALUE new_image;
@@ -815,6 +859,7 @@ Image_auto_orient(VALUE self)
     return auto_orient(False, self);
 }
 
+
 /*
     Returns nil if the image is already properly oriented
 */
@@ -855,7 +900,8 @@ Image_background_color_eq(VALUE self, VALUE color)
     Method:     Image#base_columns
     Purpose:    Return the number of rows (before transformations)
 */
-VALUE Image_base_columns(VALUE self)
+VALUE
+Image_base_columns(VALUE self)
 {
     Image *image = rm_check_destroyed(self);
     return INT2FIX(image->magick_columns);
@@ -866,7 +912,8 @@ VALUE Image_base_columns(VALUE self)
     Purpose:    Return the image filename (before transformations)
     Notes:      If there is no base filename, return the current filename.
 */
-VALUE Image_base_filename(VALUE self)
+VALUE
+Image_base_filename(VALUE self)
 {
     Image *image = rm_check_destroyed(self);
     if (*image->magick_filename)
@@ -883,7 +930,8 @@ VALUE Image_base_filename(VALUE self)
     Method:     Image#base_rows
     Purpose:    Return the number of rows (before transformations)
 */
-VALUE Image_base_rows(VALUE self)
+VALUE
+Image_base_rows(VALUE self)
 {
     Image *image = rm_check_destroyed(self);
     return INT2FIX(image->magick_rows);
@@ -895,14 +943,16 @@ VALUE Image_base_rows(VALUE self)
                 Image#bias = a number between 0.0 and 1.0 or "NN%"
     Purpose:    Get/set image bias (used when convolving an image)
 */
-VALUE Image_bias(VALUE self)
+VALUE
+Image_bias(VALUE self)
 {
     Image *image = rm_check_destroyed(self);
     return rb_float_new(image->bias);
 }
 
 
-VALUE Image_bias_eq(VALUE self, VALUE pct)
+VALUE
+Image_bias_eq(VALUE self, VALUE pct)
 {
     Image *image;
     double bias;
@@ -1008,12 +1058,7 @@ Image_black_threshold(int argc, VALUE *argv, VALUE self)
                 offsets are relative to
 */
 static void
-get_relative_offsets(
-                    VALUE grav,
-                    Image *image,
-                    Image *mark,
-                    long *x_offset,
-                    long *y_offset)
+get_relative_offsets(VALUE grav, Image *image, Image *mark, long *x_offset, long *y_offset)
 {
     MagickEnum *m_enum;
     GravityType gravity;
@@ -1067,12 +1112,8 @@ get_relative_offsets(
     Purpose:    compute watermark offsets from gravity type
 */
 static void
-get_offsets_from_gravity(
-                        GravityType gravity,
-                        Image *image,
-                        Image *mark,
-                        long *x_offset,
-                        long *y_offset)
+get_offsets_from_gravity(GravityType gravity, Image *image, Image *mark
+                         , long *x_offset, long *y_offset)
 {
 
     switch (gravity)
@@ -1125,7 +1166,8 @@ get_offsets_from_gravity(
     Purpose:    called from rb_protect, returns the number if obj is really
                 a numeric value.
 */
-static VALUE check_for_long_value(VALUE obj)
+static VALUE
+check_for_long_value(VALUE obj)
 {
     long t;
     t = NUM2LONG(obj);
@@ -1138,13 +1180,9 @@ static VALUE check_for_long_value(VALUE obj)
     Static:     get_composite_offsets
     Purpose:    compute x- and y-offset of source image for a compositing method
 */
-static void get_composite_offsets(
-                                 int argc,
-                                 VALUE *argv,
-                                 Image *dest,
-                                 Image *src,
-                                 long *x_offset,
-                                 long *y_offset)
+static void
+get_composite_offsets(int argc, VALUE *argv, Image *dest, Image *src
+                      , long *x_offset, long *y_offset)
 {
     GravityType gravity;
     int exc = 0;
@@ -1199,11 +1237,7 @@ static void get_composite_offsets(
                 is far in excess of what xMagick will allow.
 */
 static void
-blend_geometry(
-              char *geometry,
-              size_t geometry_l,
-              double src_percent,
-              double dst_percent)
+blend_geometry(char *geometry, size_t geometry_l, double src_percent, double dst_percent)
 {
     size_t sz = 0;
     int fw, prec;
@@ -1259,14 +1293,8 @@ blend_geometry(
 
 
 static VALUE
-special_composite(
-                 Image *image,
-                 Image *overlay,
-                 double image_pct,
-                 double overlay_pct,
-                 long x_off,
-                 long y_off,
-                 CompositeOperator op)
+special_composite(Image *image, Image *overlay, double image_pct, double overlay_pct
+                  , long x_off, long y_off, CompositeOperator op)
 {
     Image *new_image;
     char geometry[20];
@@ -1305,7 +1333,7 @@ Image_blend(int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 to 6)", argc);
     }
 
-    ovly = ImageList_cur_image(argv[0]);
+    ovly = rm_cur_image(argv[0]);
     overlay = rm_check_destroyed(ovly);
 
     if (argc > 3)
@@ -1398,12 +1426,8 @@ Image_blur_image(int argc, VALUE *argv, VALUE self)
     Purpose:    surrounds the image with a border of the specified width,
                 height, and named color
 */
-static VALUE border(
-                   int bang,
-                   VALUE self,
-                   VALUE width,
-                   VALUE height,
-                   VALUE color)
+static VALUE
+border(int bang, VALUE self, VALUE width, VALUE height, VALUE color)
 {
     Image *image, *new_image;
     PixelPacket old_border;
@@ -1441,11 +1465,7 @@ static VALUE border(
 }
 
 VALUE
-Image_border_bang(
-                 VALUE self,
-                 VALUE width,
-                 VALUE height,
-                 VALUE color)
+Image_border_bang(VALUE self, VALUE width, VALUE height, VALUE color)
 {
     (void) rm_check_frozen(self);
     return border(True, self, width, height, color);
@@ -1453,11 +1473,7 @@ Image_border_bang(
 
 
 VALUE
-Image_border(
-            VALUE self,
-            VALUE width,
-            VALUE height,
-            VALUE color)
+Image_border(VALUE self, VALUE width, VALUE height, VALUE color)
 {
     (void) rm_check_destroyed(self);
     return border(False, self, width, height, color);
@@ -1475,6 +1491,7 @@ Image_border_color(VALUE self)
     return PixelPacket_to_Color_Name(image, &image->border_color);
 }
 
+
 /*
     Method:     Image#border_color=
     Purpose:    Set the the border color
@@ -1492,7 +1509,8 @@ Image_border_color_eq(VALUE self, VALUE color)
     Method:     Image#bounding_box
     Purpose:    returns the bounding box of an image canvas
 */
-VALUE Image_bounding_box(VALUE self)
+VALUE
+Image_bounding_box(VALUE self)
 {
     Image *image;
     RectangleInfo box;
@@ -1518,10 +1536,7 @@ VALUE Image_bounding_box(VALUE self)
     Purpose:    do a screen capture
 */
 VALUE
-Image_capture(
-             int argc,
-             VALUE *argv,
-             VALUE self)
+Image_capture(int argc, VALUE *argv, VALUE self)
 {
     Image *image;
     ImageInfo *image_info;
@@ -1582,7 +1597,7 @@ Image_change_geometry(VALUE self, VALUE geom_arg)
     volatile VALUE ary;
 
     image = rm_check_destroyed(self);
-    geom_str = rb_funcall(geom_arg, rm_ID_to_s, 0);
+    geom_str = rm_to_s(geom_arg);
     geometry = StringValuePtr(geom_str);
 
     memset(&rect, 0, sizeof(rect));
@@ -1785,17 +1800,13 @@ Image_check_destroyed(VALUE self)
                 the removed portion
 */
 VALUE
-Image_chop(
-          VALUE self,
-          VALUE x,
-          VALUE y,
-          VALUE width,
-          VALUE height)
+Image_chop(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
 {
     (void) rm_check_destroyed(self);
     return xform_image(False, self, x, y, width, height, ChopImage);
 }
 
+
 /*
     Method:     Image#chromaticity
     Purpose:    Return the red, green, blue, and white-point chromaticity
@@ -1808,6 +1819,7 @@ Image_chromaticity(VALUE self)
     return ChromaticityInfo_new(&image->chromaticity);
 }
 
+
 /*
     Method:     Image#chromaticity=
     Purpose:    Set the red, green, blue, and white-point chromaticity
@@ -1840,11 +1852,11 @@ Image_clone(VALUE self)
     return clone;
 }
 
+
 /*
     Method:     Image#clut_channel
     Purpose:    Equivalent to -clut option.
 */
-
 VALUE
 Image_clut_channel(int argc, VALUE *argv, VALUE self)
 {
@@ -1891,6 +1903,7 @@ Image_clut_channel(int argc, VALUE *argv, VALUE self)
 #endif
 }
 
+
 /*
     Method:     Image_color_histogram(VALUE self);
     Purpose:    Call GetImageHistogram
@@ -1959,14 +1972,14 @@ Image_color_histogram(VALUE self)
 }
 
 
-
 /*
     Static:     set_profile(target_image, name, profile_image)
     Purpose:    The `profile_image' argument is an IPTC or ICC profile. Store
                 all the profiles in the profile in the target image.
                 Called from Image_color_profile_eq and Image_iptc_profile_eq
 */
-static VALUE set_profile(VALUE self, const char *name, VALUE profile)
+static VALUE
+set_profile(VALUE self, const char *name, VALUE profile)
 {
     Image *image, *profile_image;
     ImageInfo *info;
@@ -2051,6 +2064,7 @@ Image_color_profile(VALUE self)
 
 }
 
+
 /*
     Method:     Image#color_profile=(String)
     Purpose:    Set the ICC color profile. The argument is a string.
@@ -2068,6 +2082,7 @@ Image_color_profile_eq(VALUE self, VALUE profile)
     return self;
 }
 
+
 /*
     Method:     Image#color_flood_fill(target_color, fill_color, x, y, method)
     Purpose:    changes the color value of any pixel that matches target_color
@@ -2076,13 +2091,8 @@ Image_color_profile_eq(VALUE self, VALUE profile)
                 Accepts either the FloodfillMethod or the FillToBorderMethod
 */
 VALUE
-Image_color_flood_fill(
-                      VALUE self,
-                      VALUE target_color,
-                      VALUE fill_color,
-                      VALUE xv,
-                      VALUE yv,
-                      VALUE method)
+Image_color_flood_fill( VALUE self, VALUE target_color, VALUE fill_color
+                        , VALUE xv, VALUE yv, VALUE method)
 {
     Image *image, *new_image;
     PixelPacket target;
@@ -2124,26 +2134,26 @@ Image_color_flood_fill(
 
 #if defined(HAVE_FLOODFILLPAINTIMAGE)
     {
-    MagickPixelPacket target_mpp;
-    MagickBooleanType invert;
+        MagickPixelPacket target_mpp;
+        MagickBooleanType invert;
 
-    GetMagickPixelPacket(new_image, &target_mpp);
-    if (fill_method == FillToBorderMethod)
-    {
-        invert = MagickTrue;
-        target_mpp.red   = (MagickRealType) image->border_color.red;
-        target_mpp.green = (MagickRealType) image->border_color.green;
-        target_mpp.blue  = (MagickRealType) image->border_color.blue;
-    }
-    else
-    {
-        invert = MagickFalse;
-        target_mpp.red   = (MagickRealType) target.red;
-        target_mpp.green = (MagickRealType) target.green;
-        target_mpp.blue  = (MagickRealType) target.blue;
-    }
+        GetMagickPixelPacket(new_image, &target_mpp);
+        if (fill_method == FillToBorderMethod)
+        {
+            invert = MagickTrue;
+            target_mpp.red   = (MagickRealType) image->border_color.red;
+            target_mpp.green = (MagickRealType) image->border_color.green;
+            target_mpp.blue  = (MagickRealType) image->border_color.blue;
+        }
+        else
+        {
+            invert = MagickFalse;
+            target_mpp.red   = (MagickRealType) target.red;
+            target_mpp.green = (MagickRealType) target.green;
+            target_mpp.blue  = (MagickRealType) target.blue;
+        }
 
-    (void) FloodfillPaintImage(new_image, DefaultChannels, draw_info, &target_mpp, x, y, invert);
+        (void) FloodfillPaintImage(new_image, DefaultChannels, draw_info, &target_mpp, x, y, invert);
     }
 #else
     (void) ColorFloodfillImage(new_image, draw_info, target, x, y, (PaintMethod)fill_method);
@@ -2154,6 +2164,7 @@ Image_color_flood_fill(
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#colorize(r, g, b, target)
     Purpose:    blends the fill color specified by "target" with each pixel in
@@ -2161,10 +2172,7 @@ Image_color_flood_fill(
                 component.
 */
 VALUE
-Image_colorize(
-              int argc,
-              VALUE *argv,
-              VALUE self)
+Image_colorize(int argc, VALUE *argv, VALUE self)
 {
     Image *image, *new_image;
     double red, green, blue, matte;
@@ -2313,6 +2321,7 @@ Image_colorspace(VALUE self)
     return ColorspaceType_new(image->colorspace);
 }
 
+
 /*
     Method:     Image#colorspace=Magick::ColorspaceType
     Purpose:    Set the image's colorspace
@@ -2406,7 +2415,7 @@ VALUE Image_combine(int argc, VALUE *argv, VALUE self)
 
 
 /*
-    Method:     Image#compare_channel(ref_image, metric [, channel...])
+    Method:     Image#compare_channel(ref_image, metric [, channel...]) { optional arguments }
     Purpose:    compares one or more channels in two images and returns
                 the specified distortion metric and a comparison image.
     Notes:      If no channels are specified, the default is AllChannels.
@@ -2419,11 +2428,14 @@ VALUE Image_combine(int argc, VALUE *argv, VALUE self)
                 arguments have names that end in _channel.  So I renamed
                 the method to compare_channel but kept channel_compare as
                 an alias.
+
+                The optional arguments are specified thusly:
+                    self.highlight_color color
+                    self.lowlight-color color
+                where color is either a color name or a Pixel.
 */
-VALUE Image_compare_channel(
-                           int argc,
-                           VALUE *argv,
-                           VALUE self)
+VALUE
+Image_compare_channel(int argc, VALUE *argv, VALUE self)
 {
     Image *image, *r_image, *difference_image;
     double distortion;
@@ -2445,7 +2457,9 @@ VALUE Image_compare_channel(
         rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or more)", argc);
     }
 
-    ref = ImageList_cur_image(argv[0]);
+    rm_get_optional_arguments(self);
+
+    ref = rm_cur_image(argv[0]);
     r_image = rm_check_destroyed(ref);
 
     VALUE_TO_ENUM(argv[1], metric_type, MetricType);
@@ -2475,7 +2489,8 @@ VALUE Image_compare_channel(
     Method:     Image#compose -> composite_op
     Purpose:    Return the composite operator attribute
 */
-VALUE Image_compose(VALUE self)
+VALUE
+Image_compose(VALUE self)
 {
     Image *image = rm_check_destroyed(self);
     return CompositeOperator_new(image->compose);
@@ -2486,9 +2501,8 @@ VALUE Image_compose(VALUE self)
     Method:     Image#compose=composite_op
     Purpose:    Set the composite operator attribute
 */
-VALUE Image_compose_eq(
-                      VALUE self,
-                      VALUE compose_arg)
+VALUE
+Image_compose_eq(VALUE self, VALUE compose_arg)
 {
     Image *image = rm_check_frozen(self);
     VALUE_TO_ENUM(compose_arg, image->compose, CompositeOperator);
@@ -2508,12 +2522,8 @@ VALUE Image_compose_eq(
     Returns:    new composited image, or nil
 */
 
-static VALUE composite(
-                      int bang,
-                      int argc,
-                      VALUE *argv,
-                      VALUE self,
-                      ChannelType channels)
+static VALUE
+composite(int bang, int argc, VALUE *argv, VALUE self, ChannelType channels)
 {
     Image *image, *new_image;
     Image *comp_image;
@@ -2536,7 +2546,7 @@ static VALUE composite(
     }
 
 
-    comp = ImageList_cur_image(argv[0]);
+    comp = rm_cur_image(argv[0]);
     comp_image = rm_check_destroyed(comp);
 
     switch (argc)
@@ -2664,19 +2674,15 @@ static VALUE composite(
 }
 
 
-VALUE Image_composite_bang(
-                          int argc,
-                          VALUE *argv,
-                          VALUE self)
+VALUE
+Image_composite_bang(int argc, VALUE *argv, VALUE self)
 {
     return composite(True, argc, argv, self, DefaultChannels);
 }
 
 
-VALUE Image_composite(
-                     int argc,
-                     VALUE *argv,
-                     VALUE self)
+VALUE
+Image_composite(int argc, VALUE *argv, VALUE self)
 {
     return composite(False, argc, argv, self, DefaultChannels);
 }
@@ -2688,10 +2694,7 @@ VALUE Image_composite(
                 dictated by the affine transform.
 */
 VALUE
-Image_composite_affine(
-                      VALUE self,
-                      VALUE source,
-                      VALUE affine_matrix)
+Image_composite_affine(VALUE self, VALUE source, VALUE affine_matrix)
 {
     Image *image, *composite_image, *new_image;
     AffineMatrix affine;
@@ -2736,18 +2739,110 @@ composite_channel(int bang, int argc, VALUE *argv, VALUE self)
 }
 
 
-VALUE Image_composite_channel(int argc, VALUE *argv, VALUE self)
+VALUE
+Image_composite_channel(int argc, VALUE *argv, VALUE self)
 {
     return composite_channel(False, argc, argv, self);
 }
 
 
-VALUE Image_composite_channel_bang(int argc, VALUE *argv, VALUE self)
+VALUE
+Image_composite_channel_bang(int argc, VALUE *argv, VALUE self)
 {
     return composite_channel(True, argc, argv, self);
 }
 
 
+/*
+    Method:     Image#composite_tiled(src [, composite_op = Magick::OverCompositeOp][, channel...])
+    Purpose:    Emulate the -tile option to the composite command.
+    Returns:    new image
+    Notes:      Ref: wand/composite.c (6.2.4)
+*/
+static VALUE
+composite_tiled(int bang, int argc, VALUE *argv, VALUE self)
+{
+    Image *image;
+    Image *comp_image;
+    CompositeOperator operator = OverCompositeOp;
+    long x, y;
+    unsigned long columns;
+    ChannelType channels;
+    MagickStatusType status;
+
+    // Ensure image and composite_image aren't destroyed.
+    if (bang)
+    {
+        image = rm_check_frozen(self);
+    }
+    else
+    {
+        image = rm_check_destroyed(self);
+    }
+
+    if (argc > 0)
+    {
+        comp_image = rm_check_destroyed(rm_cur_image(argv[0]));
+    }
+
+    channels = extract_channels(&argc, argv);
+
+    switch (argc)
+    {
+        case 2:
+            VALUE_TO_ENUM(argv[1], operator, CompositeOperator);
+        case 1:
+            break;
+        case 0:
+            rb_raise(rb_eArgError, "wrong number of arguments (0 for 1 or more)");
+            break;
+        default:
+            raise_ChannelType_error(argv[argc-1]);
+            break;
+    }
+
+    if (!bang)
+    {
+        image = rm_clone_image(image);
+    }
+
+#if defined(HAVE_SETIMAGEARTIFACT)
+    (void) SetImageArtifact(comp_image,"modify-outside-overlay", "false");
+#else
+    (void) SetImageAttribute(comp_image, "[modify-outside-overlay]", "false");
+#endif
+
+    status = MagickTrue;
+    columns = comp_image->columns;
+
+    // Tile
+    for (y = 0; y < (long) image->rows; y += comp_image->rows)
+    {
+        for (x = 0; status == MagickTrue && x < (long) image->columns; x += columns)
+        {
+            status = CompositeImageChannel(image, channels, operator, comp_image, x, y);
+            rm_check_image_exception(image, bang ? RetainOnError: DestroyOnError);
+        }
+    }
+
+    return bang ? self : rm_image_new(image);
+}
+
+
+VALUE
+Image_composite_tiled(int argc, VALUE *argv, VALUE self)
+{
+    return composite_tiled(False, argc, argv, self);
+}
+
+
+VALUE
+Image_composite_tiled_bang(int argc, VALUE *argv, VALUE self)
+{
+    return composite_tiled(True, argc, argv, self);
+}
+
+
 /*
     Method:     Image#compression
                 Image#compression=
@@ -2952,12 +3047,8 @@ Image_contrast(int argc, VALUE *argv, VALUE self)
     Purpose:    Convert percentages to #pixels. If the white-point (2nd)
                 argument is not supplied set it to #pixels - black-point.
 */
-static void get_black_white_point(
-                                 Image *image,
-                                 int argc,
-                                 VALUE *argv,
-                                 double *black_point,
-                                 double *white_point)
+static void
+get_black_white_point(Image *image, int argc, VALUE *argv, double *black_point, double *white_point)
 {
     double pixels;
 
@@ -3043,10 +3134,7 @@ Image_contrast_stretch_channel(int argc, VALUE *argv, VALUE self)
                 "kernel" is an order**2 array of doubles
 */
 VALUE
-Image_convolve(
-              VALUE self,
-              VALUE order_arg,
-              VALUE kernel_arg)
+Image_convolve(VALUE self, VALUE order_arg, VALUE kernel_arg)
 {
     Image *image, *new_image;
     double *kernel;
@@ -3087,10 +3175,7 @@ Image_convolve(
  *  Purpose:    call ConvolveImageChannel
 */
 VALUE
-Image_convolve_channel(
-                      int argc,
-                      VALUE *argv,
-                      VALUE self)
+Image_convolve_channel(int argc, VALUE *argv, VALUE self)
 {
     Image *image, *new_image;
     double *kernel;
@@ -3182,6 +3267,7 @@ Image_crop(int argc, VALUE *argv, VALUE self)
     return cropper(False, argc, argv, self);
 }
 
+
 VALUE
 Image_crop_bang(int argc, VALUE *argv, VALUE self)
 {
@@ -3189,6 +3275,7 @@ Image_crop_bang(int argc, VALUE *argv, VALUE self)
     return cropper(True, argc, argv, self);
 }
 
+
 /*
     Method:     Image#cycle_colormap
     Purpose:    Call CycleColormapImage
@@ -3209,6 +3296,7 @@ Image_cycle_colormap(VALUE self, VALUE amount)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#density
     Purpose:    Get the x & y resolutions.
@@ -3226,6 +3314,7 @@ Image_density(VALUE self)
     return rb_str_new2(density);
 }
 
+
 /*
     Method:     Image#density="XxY"
                 Image#density=aGeometry
@@ -3293,31 +3382,6 @@ Image_density_eq(VALUE self, VALUE density_arg)
     return self;
 }
 
-/*
-    Method:     Image#depth
-    Purpose:    Return the image depth (8 or 16).
-    Note:       If all pixels have lower-order bytes equal to higher-order
-                bytes, the depth will be reported as 8 even if the depth
-                field in the Image structure says 16.
-*/
-VALUE
-Image_depth(VALUE self)
-{
-    Image *image;
-    unsigned long depth = 0;
-    ExceptionInfo exception;
-
-    image = rm_check_destroyed(self);
-    GetExceptionInfo(&exception);
-
-    depth = GetImageDepth(image, &exception);
-    CHECK_EXCEPTION()
-
-    (void) DestroyExceptionInfo(&exception);
-
-    return INT2FIX(depth);
-}
-
 
 /*
     Method:     Image#decipher(passphrase)
@@ -3353,7 +3417,52 @@ Image_decipher(VALUE self, VALUE passphrase)
     self = self;
     passphrase = passphrase;
     rm_not_implemented();
-    return (VALUE)0;
+    return(VALUE)0;
+#endif
+}
+
+
+/*
+    Method:     value = Image#define(artifact, value)
+    Purpose:    Call SetImageArtifact
+    Note:       Normally a script should never call this method. Any calls
+                to SetImageArtifact will be part of the methods in which they're
+                needed, or be called via the OptionalMethodArguments class.
+*/
+VALUE
+Image_define(VALUE self, VALUE artifact, VALUE value)
+{
+#if defined(HAVE_SETIMAGEARTIFACT)
+    Image *image;
+    char *key, *val;
+    MagickBooleanType status;
+
+    image = rm_check_frozen(self);
+    artifact = rb_String(artifact);
+    key = StringValuePtr(artifact);
+
+    if (value == Qnil)
+    {
+        (void) DeleteImageArtifact(image, key);
+    }
+    else
+    {
+        value = rb_String(value);
+        val = StringValuePtr(value);
+        status = SetImageArtifact(image, key, val);
+        if (!status)
+        {
+            rb_raise(rb_eNoMemError, "not enough memory to continue");
+        }
+    }
+
+    return value;
+#else
+    rm_not_implemented();
+    artifact = artifact;
+    value = value;
+    self = self;
+    return(VALUE)0;
 #endif
 }
 
@@ -3376,8 +3485,8 @@ Image_delete_compose_mask(VALUE self)
     // Store a clone of the mask image
 #if defined(HAVE_SETIMAGEMASK)
     {
-    (void) SetImageMask(image, NULL);
-    rm_check_image_exception(image, RetainOnError);
+        (void) SetImageMask(image, NULL);
+        rm_check_image_exception(image, RetainOnError);
     }
 #else
     if (image->clip_mask)
@@ -3407,6 +3516,82 @@ Image_delete_profile(VALUE self, VALUE name)
 }
 
 
+/*
+    Method:     Image#depth
+    Purpose:    Return the image depth (8 or 16).
+    Note:       If all pixels have lower-order bytes equal to higher-order
+                bytes, the depth will be reported as 8 even if the depth
+                field in the Image structure says 16.
+*/
+VALUE
+Image_depth(VALUE self)
+{
+    Image *image;
+    unsigned long depth = 0;
+    ExceptionInfo exception;
+
+    image = rm_check_destroyed(self);
+    GetExceptionInfo(&exception);
+
+    depth = GetImageDepth(image, &exception);
+    CHECK_EXCEPTION()
+
+    (void) DestroyExceptionInfo(&exception);
+
+    return INT2FIX(depth);
+}
+
+
+/*
+    Method:     Image#deskew(threshold=0.40, auto-crop-width)
+    Purpose:    Implement convert -deskew option
+*/
+VALUE
+Image_deskew(int argc, VALUE *argv, VALUE self)
+{
+#if defined(HAVE_DESKEWIMAGE)
+    Image *image, *new_image;
+    double threshold = 40.0 * QuantumRange / 100.0;
+    unsigned long width;
+    char auto_crop_width[20];
+    ExceptionInfo exception;
+
+    image = rm_check_destroyed(self);
+
+    switch (argc)
+    {
+        case 2:
+            width = NUM2ULONG(argv[1]);
+            memset(auto_crop_width, 0, sizeof(auto_crop_width));
+            sprintf(auto_crop_width, "%ld", width);
+            SetImageArtifact(image, "deskew:auto-crop", auto_crop_width);
+        case 1:
+            threshold = rm_percentage(argv[0]) * QuantumRange;
+        case 0:
+            break;
+        default:
+            rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc);
+            break;
+    }
+
+    GetExceptionInfo(&exception);
+    new_image = DeskewImage(image, threshold, &exception);
+    CHECK_EXCEPTION()
+    rm_ensure_result(new_image);
+
+    (void) DestroyExceptionInfo(&exception);
+
+    return rm_image_new(new_image);
+#else
+    self = self;        // defeat "unused parameter" message
+    argv = argv;
+    argc = argc;
+    rm_not_implemented();
+    return(VALUE)0;
+#endif
+}
+
+
 /*
     Method:     Image#despeckle
     Purpose:    reduces the speckle noise in an image while preserving the
@@ -3437,7 +3622,8 @@ Image_despeckle(VALUE self)
     Method:     Image#destroy!
     Purpose:    Free all the memory associated with an image
 */
-VALUE Image_destroy_bang(VALUE self)
+VALUE
+Image_destroy_bang(VALUE self)
 {
     Image *image;
 
@@ -3453,7 +3639,8 @@ VALUE Image_destroy_bang(VALUE self)
     Method:     Image#destroyed?
     Purpose:    Returns true if the image has been destroyed, false otherwise
 */
-VALUE Image_destroyed_q(VALUE self)
+VALUE
+Image_destroyed_q(VALUE self)
 {
     Image *image;
 
@@ -3471,14 +3658,15 @@ VALUE Image_destroyed_q(VALUE self)
                 [2] normalized maximum error
     Notes:      "other" can be either an Image or an Image
 */
-VALUE Image_difference(VALUE self, VALUE other)
+VALUE
+Image_difference(VALUE self, VALUE other)
 {
     Image *image;
     Image *image2;
     volatile VALUE mean, nmean, nmax;
 
     image = rm_check_destroyed(self);
-    other = ImageList_cur_image(other);
+    other = rm_cur_image(other);
     image2 = rm_check_destroyed(other);
 
     (void) IsImagesEqual(image, image2);
@@ -3515,7 +3703,7 @@ Image_displace(int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 to 6)", argc);
     }
 
-    dmap = ImageList_cur_image(argv[0]);
+    dmap = rm_cur_image(argv[0]);
     displacement_map = rm_check_destroyed(dmap);
 
     if (argc > 3)
@@ -3636,11 +3824,13 @@ Image_dispatch(int argc, VALUE *argv, VALUE self)
     return pixels_ary;
 }
 
+
 /*
     Method:     Image#display
     Purpose:    display the image to an X window screen
 */
-VALUE Image_display(VALUE self)
+VALUE
+Image_display(VALUE self)
 {
     Image *image;
     Info *info;
@@ -3662,6 +3852,7 @@ VALUE Image_display(VALUE self)
     return self;
 }
 
+
 /*
     Method:     Image#dispose
     Purpose:    Return the dispose attribute as a DisposeType enum
@@ -3673,6 +3864,7 @@ Image_dispose(VALUE self)
     return DisposeType_new(image->dispose);
 }
 
+
 /*
     Method:     Image#dispose=
     Purpose:    Set the dispose attribute
@@ -3709,7 +3901,7 @@ Image_dissolve(int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 to 6)", argc);
     }
 
-    ovly = ImageList_cur_image(argv[0]);
+    ovly = rm_cur_image(argv[0]);
     overlay = rm_check_destroyed(ovly);
 
     if (argc > 3)
@@ -3732,17 +3924,23 @@ Image_dissolve(int argc, VALUE *argv, VALUE self)
     }
 
     composite_image =  special_composite(image, overlay, src_percent, dst_percent
-                                       , x_offset, y_offset, DissolveCompositeOp);
+                                         , x_offset, y_offset, DissolveCompositeOp);
 
     return composite_image;
 }
 
 
 /*
- *  Method:     Image#distort(type, points, bestfit=false)
+ *  Method:     Image#distort(type, points, bestfit=false) { optional arguments }
  *  Purpose:    Call DistortImage
  *  Notes:      points is an Array of Numeric values
+ *              optional arguments are
+ *                self.define "distort:viewport", WxH+X+Y
+ *                self.define "distort:scale", N
+ *                self.verbose true
 */
+
+
 VALUE
 Image_distort(int argc, VALUE *argv, VALUE self)
 {
@@ -3756,6 +3954,7 @@ Image_distort(int argc, VALUE *argv, VALUE self)
     ExceptionInfo exception;
 
     image = rm_check_destroyed(self);
+    rm_get_optional_arguments(self);
 
     switch (argc)
     {
@@ -3824,7 +4023,7 @@ Image_distortion_channel(int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or more)", argc);
     }
 
-    rec = ImageList_cur_image(argv[0]);
+    rec = rm_cur_image(argv[0]);
     reconstruct = rm_check_destroyed(rec);
     VALUE_TO_ENUM(argv[1], metric, MetricType);
     GetExceptionInfo(&exception);
@@ -3837,6 +4036,7 @@ Image_distortion_channel(int argc, VALUE *argv, VALUE self)
     return rb_float_new(distortion);
 }
 
+
 /*
     Method:     Image#_dump(aDepth)
     Purpose:    implement marshalling
@@ -3896,6 +4096,7 @@ Image__dump(VALUE self, VALUE depth)
     return rb_str_cat(str, (char *)blob, (long)length);
 }
 
+
 /*
     Method:     Image#dup
     Purpose:    Construct a new image object and call initialize_copy
@@ -3914,6 +4115,7 @@ Image_dup(VALUE self)
     return rb_funcall(dup, rm_ID_initialize_copy, 1, self);
 }
 
+
 /*
     Method:  Image#each_profile
     Purpose: Iterate over image profiles
@@ -3953,6 +4155,7 @@ Image_each_profile(VALUE self)
     return val;
 }
 
+
 /*
     Method:     Image#edge(radius=0)
     Purpose:    finds edges in an image. "radius" defines the radius of the
@@ -3991,16 +4194,13 @@ Image_edge(int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 /*
     Static:     effect_image
     Purpose:    call one of the effects methods
 */
 static VALUE
-effect_image(
-            VALUE self,
-            int argc,
-            VALUE *argv,
-            effector_t effector)
+effect_image(VALUE self, int argc, VALUE *argv, effector_t effector)
 {
     Image *image, *new_image;
     ExceptionInfo exception;
@@ -4037,6 +4237,7 @@ effect_image(
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#emboss(radius=0.0, sigma=1.0)
     Purpose:    creates a grayscale image with a three-dimensional effect
@@ -4082,7 +4283,7 @@ Image_encipher(VALUE self, VALUE passphrase)
     self = self;
     passphrase = passphrase;
     rm_not_implemented();
-    return (VALUE)0;
+    return(VALUE)0;
 #endif
 }
 
@@ -4135,6 +4336,7 @@ Image_enhance(VALUE self)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#equalize
     Purpose:    applies a histogram equalization to the image
@@ -4157,6 +4359,7 @@ Image_equalize(VALUE self)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#equalize_channel
     Purpose:    call EqualizeImageChannel
@@ -4191,10 +4394,11 @@ Image_equalize_channel(int argc, VALUE *argv, VALUE self)
     argv = argv;
     self = self;
     rm_not_implemented();
-    return (VALUE) 0;
+    return(VALUE) 0;
 #endif
 }
 
+
 /*
     Method:     Image#erase!
     Purpose:    reset the image to the background color
@@ -4212,6 +4416,7 @@ Image_erase_bang(VALUE self)
     return self;
 }
 
+
 /*
     Method:     Image#excerpt(x, y, width, height)
     Purpose:    lightweight crop
@@ -4258,6 +4463,7 @@ excerpt(int bang, VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
 #endif
 }
 
+
 VALUE
 Image_excerpt(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
 {
@@ -4265,6 +4471,7 @@ Image_excerpt(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
     return excerpt(False, self, x, y, width, height);
 }
 
+
 VALUE
 Image_excerpt_bang(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
 {
@@ -4272,6 +4479,7 @@ Image_excerpt_bang(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
     return excerpt(True, self, x, y, width, height);
 }
 
+
 /*
     Method:     Image#export_pixels(x=0, y=0, cols=self.columns, rows=self.rows, map="RGB")
     Purpose:    extract image pixels in the form of an array
@@ -4527,6 +4735,7 @@ Image_export_pixels_to_str(int argc, VALUE *argv, VALUE self)
     return string;
 }
 
+
 /*
     Method:     Image#extract_info, extract_info=
     Purpose:    the extract_info attribute accessors
@@ -4538,6 +4747,7 @@ Image_extract_info(VALUE self)
     return Rectangle_from_RectangleInfo(&image->extract_info);
 }
 
+
 VALUE
 Image_extract_info_eq(VALUE self, VALUE rect)
 {
@@ -4572,6 +4782,7 @@ Image_filter(VALUE self)
     return FilterTypes_new(image->filter);
 }
 
+
 VALUE
 Image_filter_eq(VALUE self, VALUE filter)
 {
@@ -4604,7 +4815,7 @@ Image_find_similar_region(int argc, VALUE *argv, VALUE self)
         case 2:
             x = NUM2LONG(argv[1]);
         case 1:
-            targ = ImageList_cur_image(argv[0]);
+            targ = rm_cur_image(argv[0]);
             target = rm_check_destroyed(targ);
             break;
         default:
@@ -4665,6 +4876,7 @@ flipflop(int bang, VALUE self, flipper_t flipflopper)
     return rm_image_new(new_image);
 }
 
+
 VALUE
 Image_flip(VALUE self)
 {
@@ -4672,6 +4884,7 @@ Image_flip(VALUE self)
     return flipflop(False, self, FlipImage);
 }
 
+
 VALUE
 Image_flip_bang(VALUE self)
 {
@@ -4679,6 +4892,7 @@ Image_flip_bang(VALUE self)
     return flipflop(True, self, FlipImage);
 }
 
+
 /*
     Method:     Image#flop
                 Image#flop!
@@ -4694,6 +4908,7 @@ Image_flop(VALUE self)
     return flipflop(False, self, FlopImage);
 }
 
+
 VALUE
 Image_flop_bang(VALUE self)
 {
@@ -4840,6 +5055,7 @@ Image_frame(int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image.from_blob(blob) <{ parm block }>
     Purpose:    Call BlobToImage
@@ -4875,14 +5091,17 @@ Image_from_blob(VALUE class, VALUE blob_arg)
     return array_from_images(images);
 }
 
+
 DEF_ATTR_READER(Image, fuzz, dbl)
 
+
 /*
     Method:     Image#fuzz=number
                 Image#fuzz=NN%
     Notes:      See Info#fuzz.
 */
-VALUE Image_fuzz_eq(VALUE self, VALUE fuzz)
+VALUE
+Image_fuzz_eq(VALUE self, VALUE fuzz)
 {
     Image *image = rm_check_frozen(self);
     image->fuzz = rm_fuzz_to_dbl(fuzz);
@@ -4979,6 +5198,7 @@ Image_gamma_correct(int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#gaussian_blur(radius, sigma)
     Purpose:    blur the image
@@ -5037,6 +5257,7 @@ Image_gaussian_blur_channel(int argc, VALUE *argv, VALUE self)
 */
 DEF_ATTR_READER(Image, geometry, str)
 
+
 VALUE
 Image_geometry_eq(
                  VALUE self,
@@ -5056,7 +5277,7 @@ Image_geometry_eq(
     }
 
 
-    geom_str = rb_funcall(geometry, rm_ID_to_s, 0);
+    geom_str = rm_to_s(geometry);
     geom = StringValuePtr(geom_str);
     if (!IsGeometry(geom))
     {
@@ -5078,12 +5299,7 @@ Image_geometry_eq(
                 store_pixels calls GetImagePixels, then SyncImage
 */
 VALUE
-Image_get_pixels(
-                VALUE self,
-                VALUE x_arg,
-                VALUE y_arg,
-                VALUE cols_arg,
-                VALUE rows_arg)
+Image_get_pixels(VALUE self, VALUE x_arg, VALUE y_arg, VALUE cols_arg, VALUE rows_arg)
 {
     Image *image;
     const PixelPacket *pixels;
@@ -5133,7 +5349,8 @@ Image_get_pixels(
 }
 
 
-static VALUE has_attribute(VALUE self, MagickBooleanType (attr_test)(const Image *, ExceptionInfo *))
+static VALUE
+has_attribute(VALUE self, MagickBooleanType (attr_test)(const Image *, ExceptionInfo *))
 {
     Image *image;
     ExceptionInfo exception;
@@ -5377,6 +5594,7 @@ Image_import_pixels(int argc, VALUE *argv, VALUE self)
     return self;
 }
 
+
 /*
     Method:     Image#inspect
     Purpose:    Overrides Object#inspect - returns a string description of the
@@ -5385,7 +5603,8 @@ Image_import_pixels(int argc, VALUE *argv, VALUE self)
     Notes:      this is essentially the IdentifyImage except the description is
                 built in a char buffer instead of being written to a file.
 */
-static void build_inspect_string(Image *image, char *buffer, size_t len)
+static void
+build_inspect_string(Image *image, char *buffer, size_t len)
 {
     unsigned long quantum_depth;
     int x = 0;                  // # bytes used in buffer
@@ -5578,6 +5797,7 @@ Image_iptc_profile_eq(VALUE self, VALUE profile)
     return self;
 }
 
+
 /*
     These are undocumented methods. The writer is
     called only by Image#iterations=.
@@ -5629,6 +5849,7 @@ Image_level2(int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#level_channel(aChannelType, black=0, white=QuantumRange, gamma=1.0)
     Purpose:    similar to Image#level but applies to a single channel only
@@ -5654,26 +5875,163 @@ Image_level_channel(int argc, VALUE *argv, VALUE self)
             black_point = NUM2DBL(argv[1]);
             white_point = NUM2DBL(argv[2]);
             break;
-        case 4:
-            black_point = NUM2DBL(argv[1]);
-            white_point = NUM2DBL(argv[2]);
-            gamma_val   = NUM2DBL(argv[3]);
+        case 4:
+            black_point = NUM2DBL(argv[1]);
+            white_point = NUM2DBL(argv[2]);
+            gamma_val   = NUM2DBL(argv[3]);
+            break;
+        default:
+            rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 to 4)", argc);
+            break;
+    }
+
+    VALUE_TO_ENUM(argv[0], channel, ChannelType);
+
+    new_image = rm_clone_image(image);
+
+    (void) LevelImageChannel(new_image, channel, black_point, white_point, gamma_val);
+    rm_check_image_exception(new_image, DestroyOnError);
+
+    return rm_image_new(new_image);
+}
+
+
+/*
+    Method:     Image#level_colors(black_color="black", white_color="white", invert=true [, channel...])
+    Purpose:    Implement +level_colors blank_color,white_color
+*/
+VALUE
+Image_level_colors(int argc, VALUE *argv, VALUE self)
+{
+#if defined(HAVE_LEVELIMAGECOLORS)
+    Image *image, *new_image;
+    MagickPixelPacket black_color, white_color;
+    ChannelType channels;
+    ExceptionInfo exception;
+    MagickBooleanType invert = MagickTrue;
+    MagickBooleanType status;
+
+    image = rm_check_destroyed(self);
+
+    channels = extract_channels(&argc, argv);
+
+    switch (argc)
+    {
+        case 3:
+            invert = RTEST(argv[2]);
+
+        case 2:
+            Color_to_MagickPixelPacket(image, &white_color, argv[1]);
+            Color_to_MagickPixelPacket(image, &black_color, argv[0]);
+            break;
+
+        case 1:
+            Color_to_MagickPixelPacket(image, &black_color, argv[0]);
+            GetExceptionInfo(&exception);
+
+            GetMagickPixelPacket(image, &white_color);
+            (void) QueryMagickColor("white", &white_color, &exception);
+            CHECK_EXCEPTION()
+
+            DestroyExceptionInfo(&exception);
+
+        case 0:
+            GetExceptionInfo(&exception);
+
+            GetMagickPixelPacket(image, &white_color);
+            (void) QueryMagickColor("white", &white_color, &exception);
+            CHECK_EXCEPTION()
+
+            GetMagickPixelPacket(image, &black_color);
+            (void) QueryMagickColor("black", &black_color, &exception);
+            CHECK_EXCEPTION()
+
+            DestroyExceptionInfo(&exception);
+            break;
+
+        default:
+            raise_ChannelType_error(argv[argc-1]);
+            break;
+    }
+
+    new_image = rm_clone_image(image);
+
+    status = LevelImageColors(new_image, channels, &black_color, &white_color, invert);
+    rm_check_image_exception(new_image, DestroyOnError);
+    if (!status)
+    {
+        rb_raise(rb_eRuntimeError, "LevelImageColors failed for unknown reason.");
+    }
+
+    return rm_image_new(new_image);
+
+#else
+    rm_not_implemented();
+    self = self;
+    argc = argc;
+    argv = argv;
+    return(VALUE)0;
+#endif
+}
+
+
+
+/*
+    Method:     Image#levelize_channel(black_point[, white_point[, gamma=1.0[, channel...]])
+*/
+VALUE
+Image_levelize_channel(int argc, VALUE *argv, VALUE self)
+{
+#if defined(HAVE_LEVELIZEIMAGECHANNEL)
+    Image *image, *new_image;
+    ChannelType channels;
+    double black_point, white_point;
+    double gamma = 1.0;
+    MagickBooleanType status;
+
+    image = rm_check_destroyed(self);
+    channels = extract_channels(&argc, argv);
+    if (argc > 3)
+    {
+        raise_ChannelType_error(argv[argc-1]);
+    }
+
+    switch (argc)
+    {
+        case 3:
+            gamma = NUM2DBL(argv[2]);
+        case 2:
+            white_point = NUM2DBL(argv[1]);
+            black_point = NUM2DBL(argv[0]);
+            break;
+        case 1:
+            black_point = NUM2DBL(argv[0]);
+            white_point = QuantumRange - black_point;
             break;
         default:
-            rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 to 4)", argc);
+            rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or more)", argc);
             break;
     }
 
-    VALUE_TO_ENUM(argv[0], channel, ChannelType);
-
     new_image = rm_clone_image(image);
+    status = LevelizeImageChannel(new_image, channels, black_point, white_point, gamma);
 
-    (void) LevelImageChannel(new_image, channel, black_point, white_point, gamma_val);
     rm_check_image_exception(new_image, DestroyOnError);
-
+    if (!status)
+    {
+        rb_raise(rb_eRuntimeError, "LevelizeImageChannel failed for unknown reason.");
+    }
     return rm_image_new(new_image);
+#else
+    rm_not_implemented();
+    self = self;
+    argc = argc;
+    argv = argv;
+    return(VALUE)0;
+#endif
 }
 
+
 /*
     Method:     Image_linear_stretch(black_point <, white_point>)
     Purpose:    Call LinearStretchImage
@@ -5752,6 +6110,7 @@ Image_liquid_rescale(int argc, VALUE *argv, VALUE self)
 #endif
 }
 
+
 /*
     Method:     Image._load
     Purpose:    implement marshalling
@@ -5860,6 +6219,7 @@ magnify(int bang, VALUE self, magnifier_t magnifier)
     return rm_image_new(new_image);
 }
 
+
 VALUE
 Image_magnify(VALUE self)
 {
@@ -5867,6 +6227,7 @@ Image_magnify(VALUE self)
     return magnify(False, self, MagnifyImage);
 }
 
+
 VALUE
 Image_magnify_bang(VALUE self)
 {
@@ -5874,12 +6235,12 @@ Image_magnify_bang(VALUE self)
     return magnify(True, self, MagnifyImage);
 }
 
+
 /*
     Method:     Image#map(map_image, dither=false)
     Purpose:    Call MapImage
     Returns:    a new image
 */
-
 VALUE
 Image_map(int argc, VALUE *argv, VALUE self)
 {
@@ -5889,6 +6250,11 @@ Image_map(int argc, VALUE *argv, VALUE self)
     unsigned int dither = MagickFalse;
 
     image = rm_check_destroyed(self);
+
+#if defined(HAVE_AFFINITYIMAGE)
+    rb_warning("Image#map is deprecated. Use Image#affinity instead");
+#endif
+
     switch (argc)
     {
         case 2:
@@ -5903,7 +6269,7 @@ Image_map(int argc, VALUE *argv, VALUE self)
 
     new_image = rm_clone_image(image);
 
-    map_obj = ImageList_cur_image(map_arg);
+    map_obj = rm_cur_image(map_arg);
     map = rm_check_destroyed(map_obj);
     (void) MapImage(new_image, map, dither);
     rm_check_image_exception(new_image, DestroyOnError);
@@ -5984,7 +6350,7 @@ Image_mask(int argc, VALUE *argv, VALUE self)
 
     if (mask != Qnil)
     {
-        mask = ImageList_cur_image(mask);
+        mask = rm_cur_image(mask);
         mask_image = rm_check_destroyed(mask);
         clip_mask = rm_clone_image(mask_image);
 
@@ -6118,18 +6484,13 @@ Image_matte_color_eq(VALUE self, VALUE color)
     return self;
 }
 
+
 /*
     Method:     Image#matte_flood_fill(color, opacity, x, y, method_obj)
     Purpose:    Call MatteFloodFillImage
 */
 VALUE
-Image_matte_flood_fill(
-                      VALUE self,
-                      VALUE color,
-                      VALUE opacity,
-                      VALUE x_obj,
-                      VALUE y_obj,
-                      VALUE method_obj)
+Image_matte_flood_fill(VALUE self, VALUE color, VALUE opacity, VALUE x_obj, VALUE y_obj, VALUE method_obj)
 {
     Image *image, *new_image;
     PixelPacket target;
@@ -6161,34 +6522,34 @@ Image_matte_flood_fill(
 
 #if defined(HAVE_FLOODFILLPAINTIMAGE)
     {
-    DrawInfo *draw_info;
-    MagickPixelPacket target_mpp;
-    MagickBooleanType invert;
+        DrawInfo *draw_info;
+        MagickPixelPacket target_mpp;
+        MagickBooleanType invert;
 
-    // FloodfillPaintImage looks for the opacity in the DrawInfo.fill field.
-    draw_info = CloneDrawInfo(NULL, NULL);
-    if (!draw_info)
-    {
-        rb_raise(rb_eNoMemError, "not enough memory to continue");
-    }
-    draw_info->fill.opacity = op;
+        // FloodfillPaintImage looks for the opacity in the DrawInfo.fill field.
+        draw_info = CloneDrawInfo(NULL, NULL);
+        if (!draw_info)
+        {
+            rb_raise(rb_eNoMemError, "not enough memory to continue");
+        }
+        draw_info->fill.opacity = op;
 
-    if (method == FillToBorderMethod)
-    {
-        invert = MagickTrue;
-        target_mpp.red   = (MagickRealType) image->border_color.red;
-        target_mpp.green = (MagickRealType) image->border_color.green;
-        target_mpp.blue  = (MagickRealType) image->border_color.blue;
-    }
-    else
-    {
-        invert = MagickFalse;
-        target_mpp.red   = (MagickRealType) target.red;
-        target_mpp.green = (MagickRealType) target.green;
-        target_mpp.blue  = (MagickRealType) target.blue;
-    }
+        if (method == FillToBorderMethod)
+        {
+            invert = MagickTrue;
+            target_mpp.red   = (MagickRealType) image->border_color.red;
+            target_mpp.green = (MagickRealType) image->border_color.green;
+            target_mpp.blue  = (MagickRealType) image->border_color.blue;
+        }
+        else
+        {
+            invert = MagickFalse;
+            target_mpp.red   = (MagickRealType) target.red;
+            target_mpp.green = (MagickRealType) target.green;
+            target_mpp.blue  = (MagickRealType) target.blue;
+        }
 
-    (void) FloodfillPaintImage(new_image, OpacityChannel, draw_info, &target_mpp, x, y, invert);
+        (void) FloodfillPaintImage(new_image, OpacityChannel, draw_info, &target_mpp, x, y, invert);
     }
 #else
     (void) MatteFloodfillImage(new_image, target, op, x, y, method);
@@ -6198,6 +6559,7 @@ Image_matte_flood_fill(
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#median_filter(radius=0.0)
     Purpose:    applies a digital filter that improves the quality of a noisy
@@ -6236,8 +6598,10 @@ Image_median_filter(int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 DEF_ATTR_READERF(Image, mean_error_per_pixel, error.mean_error_per_pixel, dbl)
 
+
 /*
     Method:     Image#mime_type
     Purpose:    Return the officially registered (or de facto) MIME media-type
@@ -6264,6 +6628,7 @@ Image_mime_type(VALUE self)
     return mime_type;
 }
 
+
 /*
     Method:     Image#minify
                 Image#minify!
@@ -6278,6 +6643,7 @@ Image_minify(VALUE self)
     return magnify(False, self, MinifyImage);
 }
 
+
 VALUE
 Image_minify_bang(VALUE self)
 {
@@ -6285,6 +6651,7 @@ Image_minify_bang(VALUE self)
     return magnify(True, self, MinifyImage);
 }
 
+
 /*
     Method:     Image#modulate(<brightness<, saturation<, hue>>>)
     Purpose:    control the brightness, saturation, and hue of an image
@@ -6330,6 +6697,7 @@ Image_modulate(int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#monitor= proc
     Purpose:    Establish a progress monitor
@@ -6357,8 +6725,6 @@ Image_monitor_eq(VALUE self, VALUE monitor)
 }
 
 
-
-
 /*
     Method:     Image#monochrome?
     Purpose:    return true if all the pixels in the image have the same red,
@@ -6371,6 +6737,7 @@ Image_monochrome_q(VALUE self)
     return has_attribute(self, IsMonochromeImage);
 }
 
+
 /*
     Method:     Image#montage
     Purpose:    Tile size and offset within an image montage.
@@ -6384,11 +6751,8 @@ DEF_ATTR_READER(Image, montage, str)
     Purpose:    called from Image_motion_blur and Image_sketch
 */
 static VALUE
-motion_blur(
-           int argc,
-           VALUE *argv,
-           VALUE self,
-           Image *fp(const Image *, const double, const double, const double, ExceptionInfo *))
+motion_blur(int argc, VALUE *argv, VALUE self
+            , Image *fp(const Image *, const double, const double, const double, ExceptionInfo *))
 {
     Image *image, *new_image;
     double radius = 0.0;
@@ -6478,7 +6842,6 @@ Image_negate(int argc, VALUE *argv, VALUE self)
 }
 
 
-
 /*
  *  Method:     Image#negate_channel(grayscale=false, channel=AllChannels)
  *  Returns     a new image
@@ -6608,6 +6971,7 @@ rm_image_new(Image *image)
     return Data_Wrap_Struct(Class_Image, NULL, rm_image_destroy, image);
 }
 
+
 /*
     Method:     Image#normalize
     Purpose:    enhances the contrast of a color image by adjusting the pixels
@@ -6654,9 +7018,11 @@ Image_normalize_channel(int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 DEF_ATTR_READERF(Image, normalized_mean_error, error.normalized_mean_error, dbl)
 DEF_ATTR_READERF(Image, normalized_maximum_error, error.normalized_maximum_error, dbl)
 
+
 /*
     Method:     Image#number_colors
     Purpose:    return the number of unique colors in the image
@@ -6679,8 +7045,10 @@ Image_number_colors(VALUE self)
     return ULONG2NUM(n);
 }
 
+
 DEF_ATTR_ACCESSOR(Image, offset, long)
 
+
 /*
     Method:     Image#oil_paint(radius=3.0)
     Purpose:    applies a special effect filter that simulates an oil painting
@@ -6716,6 +7084,7 @@ Image_oil_paint(int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#opaque(target-color-name, fill-color-name)
                 Image#opaque(target-pixel, fill-pixel)
@@ -6826,12 +7195,11 @@ Image_opaque_channel(int argc, VALUE *argv, VALUE self)
     argv = argv;
     self = self;
     rm_not_implemented();
-    return (VALUE)0;
+    return(VALUE)0;
 #endif
 }
 
 
-
 /*
     Method:     Image#opaque?
     Purpose:    return true if any of the pixels in the image have an opacity
@@ -6843,6 +7211,7 @@ Image_opaque_q(VALUE self)
     return has_attribute(self, IsOpaqueImage);
 }
 
+
 /*
     Method:     Image#ordered_dither(threshold_map='2x2')
     Purpose:    perform ordered dither on image
@@ -7014,7 +7383,7 @@ Image_paint_transparent(int argc, VALUE *argv, VALUE self)
     argv = argv;
     self = self;
     rm_not_implemented();
-    return (VALUE)0;
+    return(VALUE)0;
 #endif
 }
 
@@ -7030,6 +7399,7 @@ Image_palette_q(VALUE self)
     return has_attribute(self, IsPaletteImage);
 }
 
+
 /*
     Method:     Image.ping(file)
     Purpose:    Call ImagePing
@@ -7042,6 +7412,7 @@ Image_ping(VALUE class, VALUE file_arg)
     return rd_image(class, file_arg, PingImage);
 }
 
+
 /*
     Method:     Image#pixel_color(x, y<, color>)
     Purpose:    Gets/sets the color of the pixel at x,y
@@ -7052,10 +7423,7 @@ Image_ping(VALUE class, VALUE file_arg)
                 Based on Magick++'s Magick::pixelColor methods
 */
 VALUE
-Image_pixel_color(
-                 int argc,
-                 VALUE *argv,
-                 VALUE self)
+Image_pixel_color(int argc, VALUE *argv, VALUE self)
 {
     Image *image;
     PixelPacket old_color, new_color, *pixel;
@@ -7229,8 +7597,6 @@ Image_polaroid(int argc, VALUE *argv, VALUE self)
 }
 
 
-
-
 /*
     Method:     posterize
     Purpose:    call PosterizeImage
@@ -7266,6 +7632,7 @@ Image_posterize(int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:  preview
     Purpose: Call PreviewImage
@@ -7460,7 +7827,15 @@ Image_quantize(int argc, VALUE *argv, VALUE self)
         case 4:
             quantize_info.tree_depth = NUM2UINT(argv[3]);
         case 3:
+#if defined(HAVE_TYPE_DITHERMETHOD)
+            if (rb_obj_is_kind_of(argv[2], Class_DitherMethod))
+            {
+                VALUE_TO_ENUM(argv[2], quantize_info.dither_method, DitherMethod);
+                quantize_info.dither = quantize_info.dither_method != NoDitherMethod;
+            }
+#else
             quantize_info.dither = (MagickBooleanType) RTEST(argv[2]);
+#endif
         case 2:
             VALUE_TO_ENUM(argv[1], quantize_info.colorspace, ColorspaceType);
         case 1:
@@ -7481,7 +7856,6 @@ Image_quantize(int argc, VALUE *argv, VALUE self)
 }
 
 
-
 /*
     Method:     Image#radial_blur(angle)
     Purpose:    Call RadialBlurImage
@@ -7506,6 +7880,7 @@ Image_radial_blur(VALUE self, VALUE angle)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#radial_blur_channel(angle[, channel..])
     Purpose:    Call RadialBlurImageChannel
@@ -7551,10 +7926,7 @@ Image_radial_blur_channel(
     PUrpose:    Call RandomThresholdImageChannel
 */
 VALUE
-Image_random_threshold_channel(
-                              int argc,
-                              VALUE *argv,
-                              VALUE self)
+Image_random_threshold_channel(int argc, VALUE *argv, VALUE self)
 {
     Image *image, *new_image;
     ChannelType channels;
@@ -7577,7 +7949,7 @@ Image_random_threshold_channel(
     }
 
     // Accept any argument that has a to_s method.
-    geom_str = rb_funcall(argv[0], rm_ID_to_s, 0);
+    geom_str = rm_to_s(argv[0]);
     thresholds = StringValuePtr(geom_str);
 
     new_image = rm_clone_image(image);
@@ -7637,6 +8009,7 @@ Image_raise(int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image.read(file)
     Purpose:    Call ReadImage
@@ -7658,6 +8031,7 @@ file_arg_rescue(VALUE arg)
 {
     rb_raise(rb_eTypeError, "argument must be path name or open file (%s given)",
              rb_class2name(CLASS_OF(arg)));
+    return(VALUE)0;
 }
 
 
@@ -7829,7 +8203,8 @@ Image_read_inline(VALUE self, VALUE content)
      Static:    array_from_images
      Purpose:   convert a list of images to an array of Image objects
 */
-static VALUE array_from_images(Image *images)
+static VALUE
+array_from_images(Image *images)
 {
     volatile VALUE image_obj, image_ary;
     Image *image;
@@ -7870,6 +8245,7 @@ Image_reduce_noise(VALUE self, VALUE radius)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#rendering_intent=
     Purpose:    get rendering_intent
@@ -7881,6 +8257,7 @@ Image_rendering_intent(VALUE self)
     return RenderingIntent_new(image->rendering_intent);
 }
 
+
 /*
     Method:     Image#rendering_intent=
     Purpose:    set rendering_intent
@@ -7893,6 +8270,7 @@ Image_rendering_intent_eq(VALUE self, VALUE ri)
     return self;
 }
 
+
 /*
     Method:     Image#resize(scale) or (cols, rows<, filter<, blur>>)
                 Image#resize!(scale) or (cols, rows<, filter<, blur>>)
@@ -7972,6 +8350,7 @@ resize(int bang, int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 VALUE
 Image_resize(int argc, VALUE *argv, VALUE self)
 {
@@ -7979,6 +8358,7 @@ Image_resize(int argc, VALUE *argv, VALUE self)
     return resize(False, argc, argv, self);
 }
 
+
 VALUE
 Image_resize_bang(int argc, VALUE *argv, VALUE self)
 {
@@ -7986,6 +8366,7 @@ Image_resize_bang(int argc, VALUE *argv, VALUE self)
     return resize(True, argc, argv, self);
 }
 
+
 /*
     Method:     Image#roll(x_offset, y_offset)
     Purpose:    offsets an image as defined by x_offset and y_offset
@@ -8072,6 +8453,7 @@ rotate(int bang, int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 VALUE
 Image_rotate(int argc, VALUE *argv, VALUE self)
 {
@@ -8079,6 +8461,7 @@ Image_rotate(int argc, VALUE *argv, VALUE self)
     return rotate(False, argc, argv, self);
 }
 
+
 VALUE
 Image_rotate_bang(int argc, VALUE *argv, VALUE self)
 {
@@ -8086,8 +8469,10 @@ Image_rotate_bang(int argc, VALUE *argv, VALUE self)
     return rotate(True, argc, argv, self);
 }
 
+
 DEF_ATTR_READER(Image, rows, int)
 
+
 /*
     Method:     Image#sample(scale) or (cols, rows)
                 Image#sample!
@@ -8102,6 +8487,7 @@ Image_sample(int argc, VALUE *argv, VALUE self)
     return scale(False, argc, argv, self, SampleImage);
 }
 
+
 VALUE
 Image_sample_bang(int argc, VALUE *argv, VALUE self)
 {
@@ -8109,6 +8495,7 @@ Image_sample_bang(int argc, VALUE *argv, VALUE self)
     return scale(True, argc, argv, self, SampleImage);
 }
 
+
 /*
     Method:     Image#scale(scale) or (cols, rows)
                 Image#scale!
@@ -8123,6 +8510,7 @@ Image_scale(int argc, VALUE *argv, VALUE self)
     return scale(False, argc, argv, self, ScaleImage);
 }
 
+
 VALUE
 Image_scale_bang(int argc, VALUE *argv, VALUE self)
 {
@@ -8130,6 +8518,7 @@ Image_scale_bang(int argc, VALUE *argv, VALUE self)
     return scale(True, argc, argv, self, ScaleImage);
 }
 
+
 /*
     Static:     scale
     Purpose:    Call ScaleImage or SampleImage
@@ -8194,6 +8583,7 @@ scale(int bang, int argc, VALUE *argv, VALUE self, scaler_t scaler)
     return rm_image_new(new_image);
 }
 
+
 DEF_ATTR_READER(Image, scene, ulong)
 
 
@@ -8330,6 +8720,7 @@ Image_segment(int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#opacity=
     Purpose:    Call SetImageOpacity
@@ -8544,6 +8935,7 @@ Image_shadow(int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#sharpen(radius=0, sigma=1)
     Purpose:    sharpens an image
@@ -8607,10 +8999,7 @@ Image_sharpen_channel(int argc, VALUE *argv, VALUE self)
                 shave!: self, shaved
 */
 VALUE
-Image_shave(
-           VALUE self,
-           VALUE width,
-           VALUE height)
+Image_shave(VALUE self, VALUE width, VALUE height)
 {
     (void) rm_check_destroyed(self);
     return xform_image(False, self, INT2FIX(0), INT2FIX(0), width, height, ShaveImage);
@@ -8618,10 +9007,7 @@ Image_shave(
 
 
 VALUE
-Image_shave_bang(
-                VALUE self,
-                VALUE width,
-                VALUE height)
+Image_shave_bang(VALUE self, VALUE width, VALUE height)
 {
     (void) rm_check_frozen(self);
     return xform_image(True, self, INT2FIX(0), INT2FIX(0), width, height, ShaveImage);
@@ -8635,10 +9021,7 @@ Image_shave_bang(
     Returns:    a new image
 */
 VALUE
-Image_shear(
-           VALUE self,
-           VALUE x_shear,
-           VALUE y_shear)
+Image_shear(VALUE self, VALUE x_shear, VALUE y_shear)
 {
     Image *image, *new_image;
     ExceptionInfo exception;
@@ -8695,6 +9078,7 @@ Image_sigmoidal_contrast_channel(int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#signature
     Purpose:    computes a message digest from an image pixel stream with an
@@ -8719,7 +9103,6 @@ Image_signature(VALUE self)
 }
 
 
-
 /*
     Method:     Image#sketch(radius=0.0, sigma=1.0, angle=0.0)
     Purpose:    Call SketchImage
@@ -8769,6 +9152,7 @@ Image_solarize(int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#spaceship     (a <=> b)
     Purpose:    compare two images
@@ -8806,6 +9190,62 @@ Image_spaceship(VALUE self, VALUE other)
     return INT2FIX(res);
 }
 
+
+/*
+    Method:     Image#sparse_color(method, pts[, channel...])
+    Purpose:    Call SparseColorInterpolate
+*/
+VALUE
+Image_sparse_color(int argc, VALUE *argv, VALUE self)
+{
+#if defined(HAVE_SPARSECOLORINTERPOLATE) && 0
+    Image *image, *new_image;
+    unsigned long n, npoints;
+    SparseColorInterpolateMethod interpolate_method;
+    double *points;
+    ChannelType channels;
+
+    ExceptionInfo exception;
+
+    image = rm_check_destroyed(self);
+    channels = extract_channels(&argc, argv);
+
+    if (argc != 2)
+    {
+        raise_ChannelType_error(argv[argc-1]);
+    }
+
+    VALUE_TO_ENUM(argv[0], interpolate_method, SparseColorInterpolateMethod);
+    npoints = RARRAY_LEN(argv[1]);
+
+    // Allocate points array from Ruby's memory. If an error occurs Ruby will
+    // be able to clean it up.
+    points = ALLOC_N(double, npoints);
+
+    for (n = 0; n < npoints; n++)
+    {
+        points[n] = NUM2DBL(rb_ary_entry(argv[1], n));
+    }
+
+    GetExceptionInfo(&exception);
+    new_image = SparseColorInterpolate(image, interpolate_method, npoints, points, channels, &exception);
+    xfree(points);
+    rm_check_exception(&exception, new_image, DestroyOnError);
+    (void) DestroyExceptionInfo(&exception);
+    rm_ensure_result(new_image);
+
+    return rm_image_new(new_image);
+
+#else
+    self = self;
+    argc = argc;
+    argv = argv;
+    rm_not_implemented();
+    return(VALUE)0;
+#endif
+}
+
+
 /*
     Method:     Image#splice(x, y, width, height[, color])
     Purpose:    Splice a solid color into the part of the image specified
@@ -8862,6 +9302,7 @@ Image_splice(int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#spread(radius=3)
     Purpose:    randomly displaces each pixel in a block defined by "radius"
@@ -8896,6 +9337,7 @@ Image_spread(int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 DEF_ATTR_ACCESSOR(Image, start_loop, bool)
 
 
@@ -8908,10 +9350,7 @@ DEF_ATTR_ACCESSOR(Image, start_loop, bool)
     Returns:    a new image
 */
 VALUE
-Image_stegano(
-             VALUE self,
-             VALUE watermark_image,
-             VALUE offset)
+Image_stegano(VALUE self, VALUE watermark_image, VALUE offset)
 {
     Image *image, *new_image;
     volatile VALUE wm_image;
@@ -8920,7 +9359,7 @@ Image_stegano(
 
     image = rm_check_destroyed(self);
 
-    wm_image = ImageList_cur_image(watermark_image);
+    wm_image = rm_cur_image(watermark_image);
     watermark = rm_check_destroyed(wm_image);
 
     image->offset = NUM2LONG(offset);
@@ -8936,6 +9375,7 @@ Image_stegano(
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#stereo(offset_image)
     Purpose:    combines two images and produces a single image that is the
@@ -8945,9 +9385,7 @@ Image_stegano(
     Returns:    a new image
 */
 VALUE
-Image_stereo(
-            VALUE self,
-            VALUE offset_image_arg)
+Image_stereo(VALUE self, VALUE offset_image_arg)
 {
     Image *image, *new_image;
     volatile VALUE offset_image;
@@ -8956,7 +9394,7 @@ Image_stereo(
 
     image = rm_check_destroyed(self);
 
-    offset_image = ImageList_cur_image(offset_image_arg);
+    offset_image = rm_cur_image(offset_image_arg);
     offset = rm_check_destroyed(offset_image);
 
     GetExceptionInfo(&exception);
@@ -8970,6 +9408,7 @@ Image_stereo(
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#class_type
     Purpose:    return the image's storage class (a.k.a. storage type, class type)
@@ -8982,6 +9421,7 @@ Image_class_type(VALUE self)
     return ClassType_new(image->storage_class);
 }
 
+
 /*
     Method:     Image#class_type=
     Purpose:    change the image's storage class
@@ -9015,6 +9455,7 @@ Image_class_type_eq(VALUE self, VALUE new_class_type)
     return self;
 }
 
+
 /*
     Method:     Image#store_pixels
     Purpose:    Replace the pixels in the specified rectangle
@@ -9024,13 +9465,8 @@ Image_class_type_eq(VALUE self, VALUE new_class_type)
                 "new_pixels" argument.
 */
 VALUE
-Image_store_pixels(
-                  VALUE self,
-                  VALUE x_arg,
-                  VALUE y_arg,
-                  VALUE cols_arg,
-                  VALUE rows_arg,
-                  VALUE new_pixels)
+Image_store_pixels(VALUE self, VALUE x_arg, VALUE y_arg, VALUE cols_arg
+                   , VALUE rows_arg, VALUE new_pixels)
 {
     Image *image;
     Pixel *pixels, *pixel;
@@ -9160,13 +9596,8 @@ Image_sync_profiles(VALUE self)
                 stopping at pixels matching the specified color."
 */
 VALUE
-Image_texture_flood_fill(
-                        VALUE self,
-                        VALUE color_obj,
-                        VALUE texture_obj,
-                        VALUE x_obj,
-                        VALUE y_obj,
-                        VALUE method_obj)
+Image_texture_flood_fill(VALUE self, VALUE color_obj, VALUE texture_obj
+                         , VALUE x_obj, VALUE y_obj, VALUE method_obj)
 {
     Image *image, *new_image;
     Image *texture_image;
@@ -9179,7 +9610,7 @@ Image_texture_flood_fill(
     image = rm_check_destroyed(self);
 
     Color_to_PixelPacket(&color, color_obj);
-    texture = ImageList_cur_image(texture_obj);
+    texture = rm_cur_image(texture_obj);
     texture_image = rm_check_destroyed(texture);
 
     x = NUM2LONG(x_obj);
@@ -9210,26 +9641,26 @@ Image_texture_flood_fill(
 
 #if defined(HAVE_FLOODFILLPAINTIMAGE)
     {
-    MagickPixelPacket color_mpp;
-    MagickBooleanType invert;
+        MagickPixelPacket color_mpp;
+        MagickBooleanType invert;
 
-    GetMagickPixelPacket(new_image, &color_mpp);
-    if (method == FillToBorderMethod)
-    {
-        invert = MagickTrue;
-        color_mpp.red   = (MagickRealType) image->border_color.red;
-        color_mpp.green = (MagickRealType) image->border_color.green;
-        color_mpp.blue  = (MagickRealType) image->border_color.blue;
-    }
-    else
-    {
-        invert = MagickFalse;
-        color_mpp.red   = (MagickRealType) color.red;
-        color_mpp.green = (MagickRealType) color.green;
-        color_mpp.blue  = (MagickRealType) color.blue;
-    }
+        GetMagickPixelPacket(new_image, &color_mpp);
+        if (method == FillToBorderMethod)
+        {
+            invert = MagickTrue;
+            color_mpp.red   = (MagickRealType) image->border_color.red;
+            color_mpp.green = (MagickRealType) image->border_color.green;
+            color_mpp.blue  = (MagickRealType) image->border_color.blue;
+        }
+        else
+        {
+            invert = MagickFalse;
+            color_mpp.red   = (MagickRealType) color.red;
+            color_mpp.green = (MagickRealType) color.green;
+            color_mpp.blue  = (MagickRealType) color.blue;
+        }
 
-    (void) FloodfillPaintImage(new_image, DefaultChannels, draw_info, &color_mpp, x, y, invert);
+        (void) FloodfillPaintImage(new_image, DefaultChannels, draw_info, &color_mpp, x, y, invert);
     }
 
 #else
@@ -9243,6 +9674,7 @@ Image_texture_flood_fill(
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#threshold(threshold)
     Purpose:    changes the value of individual pixels based on the intensity of
@@ -9269,11 +9701,7 @@ Image_threshold(VALUE self, VALUE threshold)
  *  Purpose:    call one of the xxxxThresholdImage methods
 */
 static
-VALUE threshold_image(
-                     int argc,
-                     VALUE *argv,
-                     VALUE self,
-                     thresholder_t thresholder)
+VALUE threshold_image(int argc, VALUE *argv, VALUE self, thresholder_t thresholder)
 {
     Image *image, *new_image;
     double red, green, blue, opacity;
@@ -9383,6 +9811,7 @@ thumbnail(int bang, int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 VALUE
 Image_thumbnail(int argc, VALUE *argv, VALUE self)
 {
@@ -9390,6 +9819,7 @@ Image_thumbnail(int argc, VALUE *argv, VALUE self)
     return thumbnail(False, argc, argv, self);
 }
 
+
 VALUE
 Image_thumbnail_bang(int argc, VALUE *argv, VALUE self)
 {
@@ -9490,6 +9920,7 @@ Image_tint(int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#to_blob
     Purpose:    Return a "blob" (a String) from the image
@@ -9569,6 +10000,7 @@ Image_to_blob(VALUE self)
     return blob_str;
 }
 
+
 /*
     Method:     Image#to_color
     Purpose:    Return a color name for the color intensity specified by the
@@ -9601,6 +10033,7 @@ Image_to_color(VALUE self, VALUE pixel_arg)
 
 }
 
+
 /*
     Method:     Image#total_colors
     Purpose:    alias for Image#number_colors
@@ -9613,6 +10046,7 @@ Image_total_colors(VALUE self)
     return Image_number_colors(self);
 }
 
+
 /*
     Method:     Image#transparent(color-name<, opacity>)
                 Image#transparent(pixel<, opacity>)
@@ -9791,6 +10225,7 @@ Image_trim(int argc, VALUE *argv, VALUE self)
     return trimmer(False, argc, argv, self);
 }
 
+
 VALUE
 Image_trim_bang(int argc, VALUE *argv, VALUE self)
 {
@@ -9851,6 +10286,33 @@ VALUE Image_image_type_eq(VALUE self, VALUE image_type)
 }
 
 
+/*
+    Method:     Image#undefine(artifact)
+    Purpose:    Call RemoveImageArtifact
+    Note:       Normally a script should never call this method.
+                See Image_define.
+*/
+VALUE
+Image_undefine(VALUE self, VALUE artifact)
+{
+#if defined(HAVE_REMOVEIMAGEARTIFACT)
+    Image *image;
+    char *key;
+    long key_l;
+
+    image = rm_check_frozen(self);
+    key = rm_str2cstr(artifact, &key_l);
+    (void) RemoveImageArtifact(image, key);
+    return self;
+#else
+    rm_not_implemented();
+    artifact = artifact;
+    self = self;
+    return(VALUE)0;
+#endif
+}
+
+
 /*
     Method:     Image#unique_colors
     Purpose:    Call UniqueImageColors
@@ -9885,6 +10347,7 @@ Image_units(VALUE self)
     return ResolutionType_new(image->units);
 }
 
+
 /*
     Method:     Image#units=
     Purpose:    Set the resolution type field
@@ -9914,8 +10377,8 @@ Image_units_eq(
             case PixelsPerCentimeterResolution:
                 if (units == PixelsPerInchResolution)
                 {
-                  image->x_resolution *= 2.54;
-                  image->y_resolution *= 2.54;
+                    image->x_resolution *= 2.54;
+                    image->y_resolution *= 2.54;
                 }
                 break;
 
@@ -9932,6 +10395,7 @@ Image_units_eq(
     return self;
 }
 
+
 /*
     Method:     Image#unsharp_mask(radius=0.0, sigma=1.0, amount=1.0, threshold=0.05)
     Purpose:    sharpens an image. "amount" is the percentage of the difference
@@ -9940,13 +10404,8 @@ Image_units_eq(
                 apply the diffence amount.
 */
 static void
-unsharp_mask_args(
-                 int argc,
-                 VALUE *argv,
-                 double *radius,
-                 double *sigma,
-                 double *amount,
-                 double *threshold)
+unsharp_mask_args(int argc, VALUE *argv, double *radius, double *sigma
+                  , double *amount, double *threshold)
 {
     switch (argc)
     {
@@ -10126,8 +10585,6 @@ Image_virtual_pixel_method_eq(VALUE self, VALUE method)
 }
 
 
-
-
 /*
   Method:   Image#watermark(mark, brightness=100.0, saturation=100.0
                           , [gravity,] x_off=0, y_off=0)
@@ -10151,7 +10608,7 @@ Image_watermark(int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 to 6)", argc);
     }
 
-    ovly = ImageList_cur_image(argv[0]);
+    ovly = rm_cur_image(argv[0]);
     overlay = rm_check_destroyed(ovly);
 
     if (argc > 3)
@@ -10185,6 +10642,7 @@ Image_watermark(int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 /*
   Method:   Image#wave(amplitude=25.0, wavelength=150.0)
   Purpose:  creates a "ripple" effect in the image by shifting the pixels
@@ -10378,6 +10836,91 @@ Image_white_threshold(int argc, VALUE *argv, VALUE self)
 }
 
 
+/*
+   Copy the filename to the Info and to the Image. Add format
+   prefix if necessary. This complicated code is necessary to handle filenames
+   like the kind Tempfile.new produces, which have an "extension" in the form
+   ".n", which confuses SetMagickInfo. So we don't use SetMagickInfo any longer.
+*/
+void add_format_prefix(Info *info, VALUE file)
+{
+    char *filename;
+    long filename_l;
+    const MagickInfo *magick_info, *magick_info2;
+    ExceptionInfo exception;
+    char magic[MaxTextExtent];
+    size_t magic_l;
+    size_t prefix_l;
+    void *p;
+
+    // Convert arg to string. If an exception occurs raise an error condition.
+    file = rb_rescue(rb_String, file, file_arg_rescue, file);
+
+    filename = rm_str2cstr(file, &filename_l);
+
+    if (*info->magick == '\0')
+    {
+        memset(info->filename, 0, sizeof(info->filename));
+        memcpy(info->filename, filename, (size_t)min(filename_l, MaxTextExtent-1));
+        return;
+    }
+
+    // If the filename starts with a prefix, and it's a valid image format
+    // prefix, then check for a conflict. If it's not a valid format prefix,
+    // ignore it.
+    p = memchr(filename, ':', (size_t)filename_l);
+    if (p)
+    {
+        memset(magic, '\0', sizeof(magic));
+        magic_l = p - (void *)filename;
+        memcpy(magic, filename, magic_l);
+
+        GetExceptionInfo(&exception);
+        magick_info = GetMagickInfo(magic, &exception);
+        CHECK_EXCEPTION();
+        DestroyExceptionInfo(&exception);
+
+        if (magick_info && magick_info->module)
+        {
+            // We have to compare the module names because some formats have
+            // more than one name. JPG and JPEG, for example.
+            GetExceptionInfo(&exception);
+            magick_info2 = GetMagickInfo(info->magick, &exception);
+            CHECK_EXCEPTION();
+            DestroyExceptionInfo(&exception);
+
+            if (magick_info2->module && strcmp(magick_info->module, magick_info2->module) != 0)
+            {
+                rb_raise(rb_eRuntimeError
+                         , "filename prefix `%s' conflicts with output format `%s'"
+                         , magick_info->name, info->magick);
+            }
+
+            // The filename prefix already matches the specified format.
+            // Just copy the filename as-is.
+            memset(info->filename, 0, sizeof(info->filename));
+            filename_l = min((size_t)filename_l, sizeof(info->filename));
+            memcpy(info->filename, filename, (size_t)filename_l);
+            return;
+        }
+    }
+
+    // The filename doesn't start with a format prefix. Add the format from
+    // the image info as the filename prefix.
+
+    memset(info->filename, 0, sizeof(info->filename));
+    prefix_l = min(sizeof(info->filename)-1, strlen(info->magick));
+    memcpy(info->filename, info->magick, prefix_l);
+    info->filename[prefix_l++] = ':';
+
+    filename_l = min(sizeof(info->filename) - prefix_l - 1, (size_t)filename_l);
+    memcpy(info->filename+prefix_l, filename, (size_t)filename_l);
+    info->filename[prefix_l+filename_l] = '\0';
+
+    return;
+}
+
+
 /*
   Method:   Image#write(filename)
   Purpose:  Write the image to the file.
@@ -10389,9 +10932,6 @@ Image_write(VALUE self, VALUE file)
     Image *image;
     Info *info;
     volatile VALUE info_obj;
-    char *filename;
-    long filename_l;
-    ExceptionInfo exception;
 
     image = rm_check_destroyed(self);
 
@@ -10406,31 +10946,12 @@ Image_write(VALUE self, VALUE file)
         GetOpenFile(file, fptr);
         rb_io_check_writable(fptr);
         SetImageInfoFile(info, GetWriteFile(fptr));
+        memset(image->filename, 0, sizeof(image->filename));
     }
     else
     {
-        // Copy the filename to the Info and to the Image, then call
-        // SetImageInfo. (Ref: ImageMagick's utilities/convert.c.)
-
-        // Convert arg to string. If an exception occurs raise an error condition.
-        file = rb_rescue(rb_String, file, file_arg_rescue, file);
-
-        filename = rm_str2cstr(file, &filename_l);
-        filename_l = min(filename_l, MaxTextExtent-1);
-        memcpy(info->filename, filename, (size_t)filename_l);
-        info->filename[filename_l] = '\0';
+        add_format_prefix(info, file);
         strcpy(image->filename, info->filename);
-
-        GetExceptionInfo(&exception);
-        (void) SetImageInfo(info, MagickTrue, &exception);
-        CHECK_EXCEPTION()
-
-        (void) DestroyExceptionInfo(&exception);
-
-        if (*info->magick == '\0')
-        {
-            return Qnil;
-        }
         SetImageInfoFile(info, NULL);
     }
 
@@ -10640,21 +11161,13 @@ cropper(int bang, int argc, VALUE *argv, VALUE self)
 }
 
 
-
 /*
     Static:     xform_image
     Purpose:    call one of the image transformation functions
     Returns:    a new image, or transformed self
 */
 static VALUE
-xform_image(
-           int bang,
-           VALUE self,
-           VALUE x,
-           VALUE y,
-           VALUE width,
-           VALUE height,
-           xformer_t xformer)
+xform_image(int bang, VALUE self, VALUE x, VALUE y, VALUE width, VALUE height, xformer_t xformer)
 {
     Image *image, *new_image;
     RectangleInfo rect;
@@ -10699,9 +11212,7 @@ xform_image(
                 no channel arguments were found. Returns the
                 number of remaining arguments.
 */
-ChannelType extract_channels(
-                            int *argc,
-                            VALUE *argv)
+ChannelType extract_channels(int *argc, VALUE *argv)
 {
     volatile VALUE arg;
     ChannelType channels, ch_arg;