rmagick 3.1.0 → 3.2.0

data/ext/RMagick/rmfill.c

@@ -150,7 +150,7 @@ point_fill(
         CHECK_EXCEPTION()
     }
 
-    DestroyExceptionInfo(exception);
+    (void) DestroyExceptionInfo(exception);
 }
 
 /**
@@ -228,9 +228,9 @@ vertical_fill(
         }
     }
 
-    DestroyExceptionInfo(exception);
+    (void) DestroyExceptionInfo(exception);
 
-    xfree((void *)master);
+    xfree((void *) master);
 }
 
 /**
@@ -305,9 +305,9 @@ horizontal_fill(
         }
     }
 
-    DestroyExceptionInfo(exception);
+    (void) DestroyExceptionInfo(exception);
 
-    xfree((void *)master);
+    xfree((void *) master);
 }
 
 /**
@@ -398,7 +398,7 @@ v_diagonal_fill(
         CHECK_EXCEPTION()
     }
 
-    DestroyExceptionInfo(exception);
+    (void) DestroyExceptionInfo(exception);
 }
 
 /**
@@ -491,7 +491,7 @@ h_diagonal_fill(
         CHECK_EXCEPTION()
     }
 
-    DestroyExceptionInfo(exception);
+    (void) DestroyExceptionInfo(exception);
 }
 
 /**

data/ext/RMagick/rmilist.c

@@ -184,6 +184,88 @@ ImageList_coalesce(VALUE self)
 }
 
 
+/**
+ * Combines the images using the specified colorspace.
+ *
+ * Ruby usage:
+ *   - @verbatim new_image = ImageList#combine @endverbatim
+ *   - @verbatim new_image = ImageList#combine(colorspace) @endverbatim
+ *
+ * Notes:
+ *   - Calls CombineImages.
+ *
+ * @param argc number of input arguments
+ * @param argv array of input arguments
+ * @param self this object
+ * @return a new image
+ */
+VALUE ImageList_combine(int argc, VALUE *argv, VALUE self)
+{
+    ChannelType channel;
+    ColorspaceType colorspace, old_colorspace;
+    long len;
+    Image *images, *new_image;
+    ExceptionInfo *exception;
+
+    len = check_imagelist_length(self);
+
+    switch (argc)
+    {
+        case 1:
+            VALUE_TO_ENUM(argv[0], colorspace, ColorspaceType);
+            break;
+        case 0:
+            colorspace = sRGBColorspace;
+            break;
+        default:
+            rb_raise(rb_eArgError, "wrong number of arguments (expected 1, got %d)", argc);
+            break;
+    }
+
+    channel = RedChannel;
+    switch (len)
+    {
+        case 5:
+            if (colorspace == CMYKColorspace)
+                channel |= AlphaChannel;
+            else
+                rb_raise(rb_eArgError, "invalid number of images in this image list");
+        case 4:
+            if (colorspace == CMYKColorspace)
+                channel |= IndexChannel;
+            else
+                channel |= AlphaChannel;
+        case 3:
+            channel |= GreenChannel;
+            channel |= BlueChannel;
+            break;
+        case 2:
+            channel |= AlphaChannel;
+            break;
+        case 1:
+            break;
+        default:
+            rb_raise(rb_eArgError, "invalid number of images in this image list");
+            break;
+    }
+
+    images = images_from_imagelist(self);
+    old_colorspace = images->colorspace;
+    SetImageColorspace(images, colorspace);
+
+    exception = AcquireExceptionInfo();
+    new_image = CombineImages(images, channel, exception);
+    rm_split(images);
+    images->colorspace = old_colorspace;
+    rm_check_exception(exception, new_image, DestroyOnError);
+    (void) DestroyExceptionInfo(exception);
+
+    rm_ensure_result(new_image);
+
+    return rm_image_new(new_image);
+}
+
+
 /**
  * Equivalent to convert's -layers composite option.
  *
@@ -504,14 +586,16 @@ ImageList_montage(VALUE self)
 
     images = images_from_imagelist(self);
 
-    // If app specified a non-default composition operator, use it for all images.
-    if (montage->compose != UndefinedCompositeOp)
+    for (Image *image = images; image; image = GetNextImageInList(image))
     {
-        Image *i;
-        for (i = images; i; i = GetNextImageInList(i))
+        if (montage->compose != UndefinedCompositeOp)
         {
-            i->compose = montage->compose;
+            image->compose = montage->compose;
         }
+        image->background_color = montage->info->background_color;
+        image->border_color = montage->info->border_color;
+        image->matte_color = montage->info->matte_color;
+        image->gravity = montage->info->gravity;
     }
 
     exception = AcquireExceptionInfo();
@@ -616,13 +700,13 @@ VALUE
 ImageList_optimize_layers(VALUE self, VALUE method)
 {
     Image *images, *new_images, *new_images2;
-    ImageLayerMethod mthd;
+    LayerMethod mthd;
     ExceptionInfo *exception;
     QuantizeInfo quantize_info;
 
     new_images2 = NULL;     // defeat "unused variable" message
 
-    VALUE_TO_ENUM(method, mthd, ImageLayerMethod);
+    VALUE_TO_ENUM(method, mthd, LayerMethod);
     images = images_from_imagelist(self);
 
     exception = AcquireExceptionInfo();

data/ext/RMagick/rmimage.c

@@ -41,6 +41,64 @@ static void call_trace_proc(Image *, const char *);
 static const char *BlackPointCompensationKey = "PROFILE:black-point-compensation";
 
 
+/**
+ * Converts the opacity value to alpha and raises a warning.
+ *
+ * No Ruby usage (internal function)
+ *
+ * @opacity an opacity value
+ */
+static Quantum
+get_alpha_from_opacity(VALUE opacity)
+{
+    VALUE method = rb_id2str(rb_frame_this_func());
+    rb_warning("Image#%"PRIsVALUE" requires a named argument for 'alpha' and now expects an alpha value instead of an opacity value.", method);
+
+    return QuantumRange - APP2QUANTUM(opacity);
+}
+
+/**
+ * Returns the alpha value from the hash.
+ *
+ * No Ruby usage (internal function)
+ *
+ * @hash the hash
+ */
+static Quantum
+get_alpha_from_hash(VALUE hash)
+{
+    if (FIX2ULONG(rb_hash_size(hash)) != 1)
+    {
+        rb_raise(rb_eArgError, "wrong number of arguments");
+    }
+
+    VALUE alpha = rb_hash_aref(hash, ID2SYM(rb_intern("alpha")));
+    if (NIL_P(alpha))
+    {
+        rb_raise(rb_eArgError, "missing keyword: alpha");
+    }
+
+    return APP2QUANTUM(alpha);
+}
+
+/**
+ * Checks if opacity_or_alpha is a named argument called alpha and returns the alpha value or
+ * converts the unnamed opacity value to alpha.
+ *
+ * No Ruby usage (internal function)
+ *
+ * @opacity_or_alpha an opacity or a named alpha value
+ */
+static Quantum
+get_named_alpha_value(VALUE opacity_or_alpha)
+{
+    if (TYPE(opacity_or_alpha) != T_HASH)
+    {
+        return get_alpha_from_opacity(opacity_or_alpha);
+    }
+
+    return get_alpha_from_hash(opacity_or_alpha);
+}
 
 
 /**
@@ -371,8 +429,7 @@ Image_adaptive_threshold(int argc, VALUE *argv, VALUE self)
 VALUE
 Image_add_compose_mask(VALUE self, VALUE mask)
 {
-    Image *image;
-    Image *mask_image = NULL;
+    Image *image, *mask_image = NULL;
 
     image = rm_check_frozen(self);
     mask_image = rm_check_destroyed(mask);
@@ -521,7 +578,6 @@ Image_add_profile(VALUE self, VALUE name)
     profile_image = ReadImage(info, exception);
     (void) DestroyImageInfo(info);
     rm_check_exception(exception, profile_image, DestroyOnError);
-    (void) DestroyExceptionInfo(exception);
     rm_ensure_result(profile_image);
 
     ResetImageProfileIterator(profile_image);
@@ -531,9 +587,8 @@ Image_add_profile(VALUE self, VALUE name)
         profile = GetImageProfile(profile_image, profile_name);
         if (profile)
         {
-            (void)ProfileImage(image, profile_name, GetStringInfoDatum(profile)
-                               , GetStringInfoLength(profile), MagickFalse);
-            if (image->exception.severity >= ErrorException)
+            (void) ProfileImage(image, profile_name, GetStringInfoDatum(profile), GetStringInfoLength(profile), MagickFalse);
+            if (rm_should_raise_exception(&image->exception, RetainExceptionRetention))
             {
                 break;
             }
@@ -542,9 +597,9 @@ Image_add_profile(VALUE self, VALUE name)
     }
 
     (void) DestroyImage(profile_image);
+    (void) DestroyExceptionInfo(exception);
     rm_check_image_exception(image, RetainOnError);
 
-
     return self;
 }
 
@@ -573,7 +628,7 @@ VALUE
 Image_alpha(int argc, VALUE *argv, VALUE self)
 {
     Image *image;
-    AlphaChannelType alpha;
+    AlphaChannelOption alpha;
 
 
     // For backward compatibility, make alpha() act like alpha?
@@ -588,7 +643,7 @@ Image_alpha(int argc, VALUE *argv, VALUE self)
 
 
     image = rm_check_frozen(self);
-    VALUE_TO_ENUM(argv[0], alpha, AlphaChannelType);
+    VALUE_TO_ENUM(argv[0], alpha, AlphaChannelOption);
 
     (void) SetImageAlphaChannel(image, alpha);
     rm_check_image_exception(image, RetainOnError);
@@ -1041,14 +1096,14 @@ Image_background_color(VALUE self)
  *
  * @param self this object
  * @param color the color
- * @return self
+ * @return color
  */
 VALUE
 Image_background_color_eq(VALUE self, VALUE color)
 {
     Image *image = rm_check_frozen(self);
     Color_to_PixelColor(&image->background_color, color);
-    return self;
+    return color;
 }
 
 
@@ -1120,7 +1175,9 @@ Image_base_rows(VALUE self)
 VALUE
 Image_bias(VALUE self)
 {
-    Image *image = rm_check_destroyed(self);
+    Image *image;
+
+    image = rm_check_destroyed(self);
     return rb_float_new(image->bias);
 }
 
@@ -1133,7 +1190,7 @@ Image_bias(VALUE self)
  *
  * @param self this object
  * @param pct the bias
- * @return self
+ * @return pct
  */
 VALUE
 Image_bias_eq(VALUE self, VALUE pct)
@@ -1142,10 +1199,10 @@ Image_bias_eq(VALUE self, VALUE pct)
     double bias;
 
     image = rm_check_frozen(self);
-    bias = rm_percentage(pct,1.0);
-    image->bias = bias * QuantumRange;
+    bias = rm_percentage(pct, 1.0) * QuantumRange;
+    image->bias = bias;
 
-    return self;
+    return pct;
 }
 
 /**
@@ -1234,7 +1291,7 @@ Image_black_point_compensation(VALUE self)
  *
  * @param self this object
  * @param arg the compensation
- * @return self
+ * @return arg
  */
 VALUE
 Image_black_point_compensation_eq(VALUE self, VALUE arg)
@@ -1247,7 +1304,7 @@ Image_black_point_compensation_eq(VALUE self, VALUE arg)
     value = RTEST(arg) ? "true" : "false";
     (void) rm_set_property(image, BlackPointCompensationKey, value);
 
-    return self;
+    return arg;
 }
 
 
@@ -1255,10 +1312,10 @@ Image_black_point_compensation_eq(VALUE self, VALUE arg)
  * Call BlackThresholdImage.
  *
  * Ruby usage:
- *   - @verbatim Image#black_threshold(red_channel) @endverbatim
- *   - @verbatim Image#black_threshold(red_channel, green_channel) @endverbatim
- *   - @verbatim Image#black_threshold(red_channel, green_channel, blue_channel) @endverbatim
- *   - @verbatim Image#black_threshold(red_channel, green_channel, blue_channel, opacity_channel) @endverbatim
+ *   - @verbatim Image#black_threshold(red) @endverbatim
+ *   - @verbatim Image#black_threshold(red, green) @endverbatim
+ *   - @verbatim Image#black_threshold(red, green, blue) @endverbatim
+ *   - @verbatim Image#black_threshold(red, green, blue, alpha: alpha) @endverbatim
  *
  * @param argc number of input arguments
  * @param argv array of input arguments
@@ -1410,10 +1467,7 @@ get_offsets_from_gravity(GravityType gravity, Image *image, Image *mark
 static VALUE
 check_for_long_value(VALUE obj)
 {
-    long t;
-    t = NUM2LONG(obj);
-    t = t;      // placate gcc
-    return(VALUE)0;
+    return LONG2NUM(NUM2LONG(obj));
 }
 
 
@@ -1702,8 +1756,51 @@ Image_blue_shift(int argc, VALUE *argv, VALUE self)
 }
 
 
+/**
+ * Get the blur attribute.
+ *
+ * Ruby usage:
+ *   - @verbatim Image#blur @endverbatim
+ *
+ * @param self this object
+ * @return the blur
+ * @deprecated This method has been deprecated.
+ */
+VALUE
+Image_blur(VALUE self)
+{
+    Image *image;
+
+    rb_warning("Image#blur is deprecated");
+    (void) rm_check_destroyed(self);
+    Data_Get_Struct(self, Image, image);
+    return C_dbl_to_R_dbl(image->blur);
+}
+
+
+/**
+ * Set the blur attribute.
+ *
+ * Ruby usage:
+ *   - @verbatim Image#blur= @endverbatim
+ *
+ * @param self this object
+ * @param value the blur
+ * @return value
+ * @deprecated This method has been deprecated.
+ */
+VALUE
+Image_blur_eq(VALUE self, VALUE value)
+{
+    Image *image;
 
-DEF_ATTR_ACCESSOR(Image, blur, dbl)
+    rb_warning("Image#blur= is deprecated");
+    (void) rm_check_destroyed(self);
+    rb_check_frozen(self);
+    Data_Get_Struct(self, Image, image);
+    image->blur = R_dbl_to_C_dbl(value);
+    return value;
+}
 
 
 /**
@@ -1911,14 +2008,14 @@ Image_border_color(VALUE self)
  *
  * @param self this object
  * @param color the color
- * @return self
+ * @return color
  */
 VALUE
 Image_border_color_eq(VALUE self, VALUE color)
 {
     Image *image = rm_check_frozen(self);
     Color_to_PixelColor(&image->border_color, color);
-    return self;
+    return color;
 }
 
 
@@ -1973,15 +2070,13 @@ Image_bounding_box(VALUE self)
  * @return a new image
  */
 VALUE
-Image_capture(int argc, VALUE *argv, VALUE self)
+Image_capture(int argc, VALUE *argv, VALUE self ATTRIBUTE_UNUSED)
 {
-    Image *image;
+    Image *new_image;
     ImageInfo *image_info;
     VALUE info_obj;
     XImportInfo ximage_info;
 
-    self = self;  // Suppress "never referenced" message from icc
-
     XGetImportInfo(&ximage_info);
     switch (argc)
     {
@@ -2011,15 +2106,15 @@ Image_capture(int argc, VALUE *argv, VALUE self)
     Data_Get_Struct(info_obj, Info, image_info);
 
     // If an error occurs, IM will call our error handler and we raise an exception.
-    image = XImportImage(image_info, &ximage_info);
-    rm_check_image_exception(image, DestroyOnError);
-    rm_ensure_result(image);
+    new_image = XImportImage(image_info, &ximage_info);
+    rm_check_image_exception(new_image, DestroyOnError);
+    rm_ensure_result(new_image);
 
-    rm_set_user_artifact(image, image_info);
+    rm_set_user_artifact(new_image, image_info);
 
     RB_GC_GUARD(info_obj);
 
-    return rm_image_new(image);
+    return rm_image_new(new_image);
 }
 
 
@@ -2050,7 +2145,6 @@ Image_change_geometry(VALUE self, VALUE geom_arg)
     memset(&rect, 0, sizeof(rect));
 
     SetGeometry(image, &rect);
-    rm_check_image_exception(image, RetainOnError);
     flags = ParseMetaGeometry(geometry, &rect.x,&rect.y, &rect.width,&rect.height);
     if (flags == NoValue)
     {
@@ -2084,7 +2178,6 @@ Image_changed_q(VALUE self)
 {
     Image *image = rm_check_destroyed(self);
     VALUE okay = IsTaintImage(image) ? Qtrue : Qfalse;
-    rm_check_image_exception(image, RetainOnError);
     return okay;
 }
 
@@ -2417,14 +2510,14 @@ Image_chromaticity(VALUE self)
  *
  * @param self this object
  * @param chroma the chromaticity
- * @return self
+ * @return chroma
  */
 VALUE
 Image_chromaticity_eq(VALUE self, VALUE chroma)
 {
     Image *image = rm_check_frozen(self);
     Export_ChromaticityInfo(&image->chromaticity, chroma);
-    return self;
+    return chroma;
 }
 
 
@@ -2629,7 +2722,6 @@ set_profile(VALUE self, const char *name, VALUE profile)
     profile_image = BlobToImage(info, profile_blob, (size_t)profile_length, exception);
     (void) DestroyImageInfo(info);
     CHECK_EXCEPTION()
-    (void) DestroyExceptionInfo(exception);
 
     ResetImageProfileIterator(profile_image);
     profile_name = GetNextImageProfile(profile_image);
@@ -2639,7 +2731,7 @@ set_profile(VALUE self, const char *name, VALUE profile)
         if (rm_strcasecmp("8bim", profile_name) == 0 && rm_strcasecmp("iptc", name) == 0)
         {
             (void) ProfileImage(image, name, profile_blob, profile_length, MagickFalse);
-            if (image->exception.severity >= ErrorException)
+            if (rm_should_raise_exception(&image->exception, RetainExceptionRetention))
             {
                 break;
             }
@@ -2650,7 +2742,7 @@ set_profile(VALUE self, const char *name, VALUE profile)
             if (profile_data)
             {
                 (void) ProfileImage(image, name, GetStringInfoDatum(profile_data), GetStringInfoLength(profile_data), MagickFalse);
-                if (image->exception.severity >= ErrorException)
+                if (rm_should_raise_exception(&image->exception, RetainExceptionRetention))
                 {
                     break;
                 }
@@ -2660,6 +2752,7 @@ set_profile(VALUE self, const char *name, VALUE profile)
     }
 
     (void) DestroyImage(profile_image);
+    (void) DestroyExceptionInfo(exception);
     rm_check_image_exception(image, RetainOnError);
 
     return self;
@@ -2710,7 +2803,7 @@ Image_color_profile(VALUE self)
  *
  * @param self this object
  * @param profile the profile to set, as a Ruby string
- * @return self
+ * @return profile
  */
 VALUE
 Image_color_profile_eq(VALUE self, VALUE profile)
@@ -2720,7 +2813,7 @@ Image_color_profile_eq(VALUE self, VALUE profile)
     {
         (void) set_profile(self, "ICC", profile);
     }
-    return self;
+    return profile;
 }
 
 
@@ -2806,9 +2899,9 @@ Image_color_flood_fill( VALUE self, VALUE target_color, VALUE fill_color
 
     (void) FloodfillPaintImage(new_image, DefaultChannels, draw_info, &target_mpp, x, y, invert);
 
-    // No need to check for error
-
     (void) DestroyDrawInfo(draw_info);
+    rm_check_image_exception(new_image, DestroyOnError);
+
     return rm_image_new(new_image);
 }
 
@@ -2993,7 +3086,7 @@ Image_colorspace(VALUE self)
     Image *image;
 
     image = rm_check_destroyed(self);
-    return ColorspaceType_new(image->colorspace);
+    return ColorspaceType_find(image->colorspace);
 }
 
 
@@ -3005,7 +3098,7 @@ Image_colorspace(VALUE self)
  *
  * @param self this object
  * @param colorspace the colorspace
- * @return self
+ * @return colorspace
  * @see Magick::colorSpace in Magick++'s Magick::colorSpace
  */
 VALUE
@@ -3018,7 +3111,7 @@ Image_colorspace_eq(VALUE self, VALUE colorspace)
     VALUE_TO_ENUM(colorspace, new_cs, ColorspaceType);
     (void) TransformImageColorspace(image, new_cs);
 
-    return self;
+    return colorspace;
 }
 
 
@@ -3052,14 +3145,15 @@ DEF_ATTR_READER(Image, columns, int)
  * @param argv array of input arguments
  * @param self this object
  * @return a new image
+ * @deprecated This method has been deprecated. Please use ImageList_combine.
  */
-VALUE Image_combine(int argc, VALUE *argv, VALUE self)
+VALUE Image_combine(int argc, VALUE *argv, VALUE self ATTRIBUTE_UNUSED)
 {
     ChannelType channel = 0;
     Image *image, *images = NULL, *new_image;
     ExceptionInfo *exception;
 
-    self = self;        // defeat "unreferenced argument" message
+    rb_warning("Image#combine is deprecated; use ImageList#combine.");
 
     switch (argc)
     {
@@ -3172,12 +3266,7 @@ Image_compare_channel(int argc, VALUE *argv, VALUE self)
     VALUE_TO_ENUM(argv[1], metric_type, MetricType);
 
     exception = AcquireExceptionInfo();
-    difference_image = CompareImageChannels(image
-                                            , r_image
-                                            , channels
-                                            , metric_type
-                                            , &distortion
-                                            , exception);
+    difference_image = CompareImageChannels(image, r_image, channels, metric_type, &distortion, exception);
     rm_check_exception(exception, difference_image, DestroyOnError);
 
     (void) DestroyExceptionInfo(exception);
@@ -3208,7 +3297,7 @@ VALUE
 Image_compose(VALUE self)
 {
     Image *image = rm_check_destroyed(self);
-    return CompositeOperator_new(image->compose);
+    return CompositeOperator_find(image->compose);
 }
 
 
@@ -3220,14 +3309,14 @@ Image_compose(VALUE self)
  *
  * @param self this object
  * @param compose_arg the composite operator
- * @return self
+ * @return 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);
-    return self;
+    return compose_arg;
 }
 
 /**
@@ -3616,10 +3705,10 @@ Image_composite_mathematics(int argc, VALUE *argv, VALUE self)
 
     // Call composite(False, gravity, x_off, y_off, MathematicsCompositeOp, DefaultChannels)
     args[0] = argv[0];
-    args[1] = GravityType_new(gravity);
+    args[1] = GravityType_find(gravity);
     args[2] = LONG2FIX(x_off);
     args[3] = LONG2FIX(y_off);
-    args[4] = CompositeOperator_new(MathematicsCompositeOp);
+    args[4] = CompositeOperator_find(MathematicsCompositeOp);
 
     return composite(False, 5, args, self, DefaultChannels);
 }
@@ -3768,7 +3857,7 @@ VALUE
 Image_compression(VALUE self)
 {
     Image *image = rm_check_destroyed(self);
-    return CompressionType_new(image->compression);
+    return CompressionType_find(image->compression);
 }
 
 /**
@@ -3779,14 +3868,14 @@ Image_compression(VALUE self)
  *
  * @param self this object
  * @param compression the compression
- * @return self
+ * @return compression
  */
 VALUE
 Image_compression_eq(VALUE self, VALUE compression)
 {
     Image *image = rm_check_frozen(self);
     VALUE_TO_ENUM(compression, image->compression, CompressionType);
-    return self;
+    return compression;
 }
 
 /**
@@ -3804,9 +3893,10 @@ Image_compression_eq(VALUE self, VALUE compression)
 VALUE
 Image_compress_colormap_bang(VALUE self)
 {
+    Image *image;
     MagickBooleanType okay;
 
-    Image *image = rm_check_frozen(self);
+    image = rm_check_frozen(self);
     okay = CompressImageColormap(image);
     rm_check_image_exception(image, RetainOnError);
     if (!okay)
@@ -3842,10 +3932,10 @@ Image_compress_colormap_bang(VALUE self)
  * @throw TypeError
  */
 VALUE
-Image_constitute(VALUE class, VALUE width_arg, VALUE height_arg
+Image_constitute(VALUE class ATTRIBUTE_UNUSED, VALUE width_arg, VALUE height_arg
                  , VALUE map_arg, VALUE pixels_arg)
 {
-    Image *image;
+    Image *new_image;
     VALUE pixel, pixel0;
     unsigned long width, height;
     long x, npixels;
@@ -3859,12 +3949,11 @@ Image_constitute(VALUE class, VALUE width_arg, VALUE height_arg
     } pixels;
     VALUE pixel_class;
     StorageType stg_type;
+    ExceptionInfo *exception;
 
-    class = class;  // Suppress "never referenced" message from icc
-
-            // rb_Array converts objects that are not Arrays to Arrays if possible,
-            // and raises TypeError if it can't.
-            pixels_arg = rb_Array(pixels_arg);
+    // rb_Array converts objects that are not Arrays to Arrays if possible,
+    // and raises TypeError if it can't.
+    pixels_arg = rb_Array(pixels_arg);
 
     width = NUM2ULONG(width_arg);
     height = NUM2ULONG(height_arg);
@@ -3933,28 +4022,40 @@ Image_constitute(VALUE class, VALUE width_arg, VALUE height_arg
     }
 
     // This is based on ConstituteImage in IM 5.5.7
-    image = rm_acquire_image((ImageInfo *) NULL);
-    if (!image)
+    new_image = rm_acquire_image((ImageInfo *) NULL);
+    if (!new_image)
     {
         xfree(pixels.v);
         rb_raise(rb_eNoMemError, "not enough memory to continue.");
     }
 
-    SetImageExtent(image, width, height);
-    rm_check_image_exception(image, DestroyOnError);
+    SetImageExtent(new_image, width, height);
+    exception = &new_image->exception;
+    if (rm_should_raise_exception(exception, RetainExceptionRetention))
+    {
+        xfree(pixels.v);
+        (void) DestroyImage(new_image);
+        rm_raise_exception(exception);
+    }
 
-    (void) SetImageBackgroundColor(image);
-    rm_check_image_exception(image, DestroyOnError);
+    (void) SetImageBackgroundColor(new_image);
+    exception = &new_image->exception;
+    if (rm_should_raise_exception(exception, RetainExceptionRetention))
+    {
+        xfree(pixels.v);
+        (void) DestroyImage(new_image);
+        rm_raise_exception(exception);
+    }
 
-    (void) ImportImagePixels(image, 0, 0, width, height, map, stg_type, (const void *)pixels.v);
+    (void) ImportImagePixels(new_image, 0, 0, width, height, map, stg_type, (const void *)pixels.v);
     xfree(pixels.v);
-    rm_check_image_exception(image, DestroyOnError);
+    rm_check_image_exception(new_image, DestroyOnError);
 
     RB_GC_GUARD(pixel);
     RB_GC_GUARD(pixel0);
     RB_GC_GUARD(pixel_class);
 
-    return rm_image_new(image);
+    return rm_image_new(new_image);
 }
 
 /**
@@ -4124,12 +4225,14 @@ Image_contrast_stretch_channel(int argc, VALUE *argv, VALUE self)
 VALUE
 Image_morphology(VALUE self, VALUE method_v, VALUE iterations, VALUE kernel_v)
 {
-  static VALUE default_channels_const = 0;
+    static VALUE default_channels_const = 0;
 
-  if(!default_channels_const)
-    default_channels_const = rb_const_get(Module_Magick, rb_intern("DefaultChannels"));
+    if(!default_channels_const)
+    {
+        default_channels_const = rb_const_get(Module_Magick, rb_intern("DefaultChannels"));
+    }
 
-  return Image_morphology_channel(self, default_channels_const, method_v, iterations, kernel_v);
+    return Image_morphology_channel(self, default_channels_const, method_v, iterations, kernel_v);
 }
 
 /** Apply a user supplied kernel to the image channel according to the given mophology method.
@@ -4150,33 +4253,38 @@ Image_morphology(VALUE self, VALUE method_v, VALUE iterations, VALUE kernel_v)
 VALUE
 Image_morphology_channel(VALUE self, VALUE channel_v, VALUE method_v, VALUE iterations, VALUE kernel_v)
 {
-  Image *image, *new_image;
-  ExceptionInfo *exception;
-  MorphologyMethod method;
-  ChannelType channel;
-  KernelInfo *kernel;
+    Image *image, *new_image;
+    ExceptionInfo *exception;
+    MorphologyMethod method;
+    ChannelType channel;
+    KernelInfo *kernel;
 
-  VALUE_TO_ENUM(method_v, method, MorphologyMethod);
-  VALUE_TO_ENUM(channel_v, channel, ChannelType);
-  Check_Type(iterations, T_FIXNUM);
+    image = rm_check_destroyed(self);
 
-  if (TYPE(kernel_v) == T_STRING)
-    kernel_v = rb_class_new_instance(1, &kernel_v, Class_KernelInfo);
+    VALUE_TO_ENUM(method_v, method, MorphologyMethod);
+    VALUE_TO_ENUM(channel_v, channel, ChannelType);
+    Check_Type(iterations, T_FIXNUM);
 
-  if (!rb_obj_is_kind_of(kernel_v, Class_KernelInfo))
-    rb_raise(rb_eArgError, "expected String or Magick::KernelInfo");
+    if (TYPE(kernel_v) == T_STRING)
+    {
+        kernel_v = rb_class_new_instance(1, &kernel_v, Class_KernelInfo);
+    }
 
-  Data_Get_Struct(kernel_v, KernelInfo, kernel);
+    if (!rb_obj_is_kind_of(kernel_v, Class_KernelInfo))
+    {
+        rb_raise(rb_eArgError, "expected String or Magick::KernelInfo");
+    }
 
-  image = rm_check_destroyed(self);
-  exception = AcquireExceptionInfo();
+    Data_Get_Struct(kernel_v, KernelInfo, kernel);
 
-  new_image = MorphologyImageChannel(image, channel, method, NUM2LONG(iterations), kernel, exception);
-  rm_check_exception(exception, new_image, DestroyOnError);
-  DestroyExceptionInfo(exception);
+    exception = AcquireExceptionInfo();
 
-  rm_ensure_result(new_image);
-  return rm_image_new(new_image);
+    new_image = MorphologyImageChannel(image, channel, method, NUM2LONG(iterations), kernel, exception);
+    rm_check_exception(exception, new_image, DestroyOnError);
+    (void) DestroyExceptionInfo(exception);
+
+    rm_ensure_result(new_image);
+    return rm_image_new(new_image);
 }
 
 /**
@@ -4194,13 +4302,19 @@ VALUE
 Image_convolve(VALUE self, VALUE order_arg, VALUE kernel_arg)
 {
     Image *image, *new_image;
-    double *kernel;
-    unsigned int x, order;
+    int order;
     ExceptionInfo *exception;
+    double *kernel;
+    unsigned int x;
 
     image = rm_check_destroyed(self);
 
-    order = NUM2UINT(order_arg);
+    order = NUM2INT(order_arg);
+
+    if (order <= 0)
+    {
+        rb_raise(rb_eArgError, "order must be non-zero and positive");
+    }
 
     kernel_arg = rb_Array(kernel_arg);
     rm_check_ary_len(kernel_arg, (long)(order*order));
@@ -4224,7 +4338,7 @@ Image_convolve(VALUE self, VALUE order_arg, VALUE kernel_arg)
 
     exception = AcquireExceptionInfo();
 
-    new_image = ConvolveImage((const Image *)image, order, (double *)kernel, exception);
+    new_image = ConvolveImage(image, order, kernel, exception);
     xfree((void *)kernel);
     rm_check_exception(exception, new_image, DestroyOnError);
 
@@ -4253,11 +4367,12 @@ VALUE
 Image_convolve_channel(int argc, VALUE *argv, VALUE self)
 {
     Image *image, *new_image;
-    double *kernel;
     VALUE ary;
-    unsigned int x, order;
+    int order;
     ChannelType channels;
     ExceptionInfo *exception;
+    double *kernel;
+    unsigned int x;
 
     image = rm_check_destroyed(self);
 
@@ -4273,7 +4388,12 @@ Image_convolve_channel(int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or more)", argc);
     }
 
-    order = NUM2UINT(argv[0]);
+    order = NUM2INT(argv[0]);
+    if (order <= 0)
+    {
+        rb_raise(rb_eArgError, "order must be non-zero and positive");
+    }
+
     ary = argv[1];
 
     rm_check_ary_len(ary, (long)(order*order));
@@ -4420,7 +4540,7 @@ Image_cycle_colormap(VALUE self, VALUE amount)
     new_image = rm_clone_image(image);
 
     (void) CycleColormapImage(new_image, amt);
-    // No need to check for an error
+    rm_check_image_exception(new_image, DestroyOnError);
 
     return rm_image_new(new_image);
 }
@@ -4465,7 +4585,7 @@ Image_density(VALUE self)
  *
  * @param self this object
  * @param density_arg The density String or Geometry
- * @return self
+ * @return density_arg
  */
 VALUE
 Image_density_eq(VALUE self, VALUE density_arg)
@@ -4519,7 +4639,7 @@ Image_density_eq(VALUE self, VALUE density_arg)
     RB_GC_GUARD(x_val);
     RB_GC_GUARD(y_val);
 
-    return self;
+    return density_arg;
 }
 
 
@@ -4551,11 +4671,11 @@ Image_decipher(VALUE self, VALUE passphrase)
     rm_check_exception(exception, new_image, DestroyOnError);
     if (!okay)
     {
-        new_image = DestroyImage(new_image);
+        (void) DestroyImage(new_image);
         rb_raise(rb_eRuntimeError, "DecipherImage failed for unknown reason.");
     }
 
-    DestroyExceptionInfo(exception);
+    (void) DestroyExceptionInfo(exception);
 
     return rm_image_new(new_image);
 }
@@ -4625,7 +4745,9 @@ DEF_ATTR_ACCESSOR(Image, delay, ulong)
 VALUE
 Image_delete_compose_mask(VALUE self)
 {
-    Image *image = rm_check_frozen(self);
+    Image *image;
+
+    image = rm_check_frozen(self);
 
     // Store a clone of the mask image
     (void) SetImageMask(image, NULL);
@@ -4650,7 +4772,6 @@ Image_delete_profile(VALUE self, VALUE name)
 {
     Image *image = rm_check_frozen(self);
     (void) DeleteImageProfile(image, StringValuePtr(name));
-    rm_check_image_exception(image, RetainOnError);
 
     return self;
 }
@@ -4841,7 +4962,7 @@ Image_difference(VALUE self, VALUE other)
     image2 = rm_check_destroyed(other);
 
     (void) IsImagesEqual(image, image2);
-    // No need to check for error
+    rm_check_image_exception(image, RetainOnError);
 
     mean  = rb_float_new(image->error.mean_error_per_pixel);
     nmean = rb_float_new(image->error.normalized_mean_error);
@@ -5085,7 +5206,7 @@ VALUE
 Image_dispose(VALUE self)
 {
     Image *image = rm_check_destroyed(self);
-    return DisposeType_new(image->dispose);
+    return DisposeType_find(image->dispose);
 }
 
 
@@ -5097,14 +5218,14 @@ Image_dispose(VALUE self)
  *
  * @param self this object
  * @param dispose the dispose
- * @return self
+ * @return dispose
  */
 VALUE
 Image_dispose_eq(VALUE self, VALUE dispose)
 {
     Image *image = rm_check_frozen(self);
     VALUE_TO_ENUM(dispose, image->dispose, DisposeType);
-    return self;
+    return dispose;
 }
 
 
@@ -5206,7 +5327,7 @@ Image_distort(int argc, VALUE *argv, VALUE self)
     Image *image, *new_image;
     VALUE pts;
     unsigned long n, npoints;
-    DistortImageMethod distortion_method;
+    DistortMethod distortion_method;
     double *points;
     MagickBooleanType bestfit = MagickFalse;
     ExceptionInfo *exception;
@@ -5221,7 +5342,7 @@ Image_distort(int argc, VALUE *argv, VALUE self)
         case 2:
             // Ensure pts is an array
             pts = rb_Array(argv[1]);
-            VALUE_TO_ENUM(argv[0], distortion_method, DistortImageMethod);
+            VALUE_TO_ENUM(argv[0], distortion_method, DistortMethod);
             break;
         default:
             rb_raise(rb_eArgError, "wrong number of arguments (expected 2 or 3, got %d)", argc);
@@ -5299,8 +5420,7 @@ Image_distortion_channel(int argc, VALUE *argv, VALUE self)
     reconstruct = rm_check_destroyed(rec);
     VALUE_TO_ENUM(argv[1], metric, MetricType);
     exception = AcquireExceptionInfo();
-    (void) GetImageChannelDistortion(image, reconstruct, channels
-                                     , metric, &distortion, exception);
+    (void) GetImageChannelDistortion(image, reconstruct, channels, metric, &distortion, exception);
     CHECK_EXCEPTION()
 
     (void) DestroyExceptionInfo(exception);
@@ -5326,7 +5446,7 @@ Image_distortion_channel(int argc, VALUE *argv, VALUE self)
  * @return a string representing the dumped image
  */
 VALUE
-Image__dump(VALUE self, VALUE depth)
+Image__dump(VALUE self, VALUE depth ATTRIBUTE_UNUSED)
 {
     Image *image;
     ImageInfo *info;
@@ -5336,8 +5456,6 @@ Image__dump(VALUE self, VALUE depth)
     VALUE str;
     ExceptionInfo *exception;
 
-    depth = depth;  // Suppress "never referenced" message from icc
-
     image = rm_check_destroyed(self);
 
     info = CloneImageInfo(NULL);
@@ -5613,7 +5731,7 @@ Image_encipher(VALUE self, VALUE passphrase)
     rm_check_exception(exception, new_image, DestroyOnError);
     if (!okay)
     {
-        new_image = DestroyImage(new_image);
+        (void) DestroyImage(new_image);
         rb_raise(rb_eRuntimeError, "EncipherImage failed for unknown reason.");
     }
 
@@ -5637,7 +5755,7 @@ VALUE
 Image_endian(VALUE self)
 {
     Image *image = rm_check_destroyed(self);
-    return EndianType_new(image->endian);
+    return EndianType_find(image->endian);
 }
 
 
@@ -5649,14 +5767,14 @@ Image_endian(VALUE self)
  *
  * @param self this object
  * @param type the endian type
- * @return self
+ * @return type
  */
 VALUE
 Image_endian_eq(VALUE self, VALUE type)
 {
     Image *image = rm_check_frozen(self);
     VALUE_TO_ENUM(type, image->endian, EndianType);
-    return self;
+    return type;
 }
 
 /**
@@ -5774,7 +5892,9 @@ Image_equalize_channel(int argc, VALUE *argv, VALUE self)
 VALUE
 Image_erase_bang(VALUE self)
 {
-    Image *image = rm_check_frozen(self);
+    Image *image;
+
+    image = rm_check_frozen(self);
 
     (void) SetImageBackgroundColor(image);
     rm_check_image_exception(image, RetainOnError);
@@ -6215,14 +6335,14 @@ Image_extract_info(VALUE self)
  *
  * @param self this object
  * @param rect extract_info
- * @return self
+ * @return rect
  */
 VALUE
 Image_extract_info_eq(VALUE self, VALUE rect)
 {
     Image *image = rm_check_frozen(self);
     Export_RectangleInfo(&image->extract_info, rect);
-    return self;
+    return rect;
 }
 
 
@@ -6267,7 +6387,7 @@ VALUE
 Image_filter(VALUE self)
 {
     Image *image = rm_check_destroyed(self);
-    return FilterTypes_new(image->filter);
+    return FilterType_find(image->filter);
 }
 
 
@@ -6279,14 +6399,14 @@ Image_filter(VALUE self)
  *
  * @param self this object
  * @param filter the filter
- * @return self
+ * @return filter
  */
 VALUE
 Image_filter_eq(VALUE self, VALUE filter)
 {
     Image *image = rm_check_frozen(self);
-    VALUE_TO_ENUM(filter, image->filter, FilterTypes);
-    return self;
+    VALUE_TO_ENUM(filter, image->filter, FilterType);
+    return filter;
 }
 
 
@@ -6525,7 +6645,7 @@ Image_format(VALUE self)
  *
  * @param self this object
  * @param magick the encoding format
- * @return self
+ * @return magick
  */
 VALUE
 Image_format_eq(VALUE self, VALUE magick)
@@ -6552,7 +6672,7 @@ Image_format_eq(VALUE self, VALUE magick)
 
 
     strncpy(image->magick, m->name, MaxTextExtent-1);
-    return self;
+    return magick;
 }
 
 
@@ -6654,7 +6774,7 @@ Image_frame(int argc, VALUE *argv, VALUE self)
  * @return an array of new images
  */
 VALUE
-Image_from_blob(VALUE class, VALUE blob_arg)
+Image_from_blob(VALUE class ATTRIBUTE_UNUSED, VALUE blob_arg)
 {
     Image *images;
     Info *info;
@@ -6663,9 +6783,6 @@ Image_from_blob(VALUE class, VALUE blob_arg)
     void *blob;
     long length;
 
-    class = class;          // defeat gcc message
-            blob_arg = blob_arg;    // defeat gcc message
-
     blob = (void *) rm_str2cstr(blob_arg, &length);
 
     // Get a new Info object - run the parm block if supplied
@@ -6709,7 +6826,6 @@ Image_function_channel(int argc, VALUE *argv, VALUE self)
     Image *image, *new_image;
     MagickFunction function;
     unsigned long n, nparms;
-    volatile double *parameters;
     double *parms;
     ChannelType channels;
     ExceptionInfo *exception;
@@ -6749,7 +6865,7 @@ Image_function_channel(int argc, VALUE *argv, VALUE self)
     }
 
     nparms = argc;
-    parameters = parms = ALLOC_N(double, nparms);
+    parms = ALLOC_N(double, nparms);
 
     for (n = 0; n < nparms; n++)
     {
@@ -6798,7 +6914,7 @@ DEF_ATTR_READER(Image, fuzz, dbl)
  *
  * @param self this object
  * @param fuzz the fuzz
- * @return self
+ * @return fuzz
  * @see Info_fuzz_eq
  */
 VALUE
@@ -6806,7 +6922,7 @@ Image_fuzz_eq(VALUE self, VALUE fuzz)
 {
     Image *image = rm_check_frozen(self);
     image->fuzz = rm_fuzz_to_dbl(fuzz);
-    return self;
+    return fuzz;
 }
 
 
@@ -6902,7 +7018,7 @@ Image_gamma_channel(int argc, VALUE *argv, VALUE self)
     gamma = NUM2DBL(argv[0]);
     new_image = rm_clone_image(image);
 
-    (void)GammaImageChannel(new_image, channels, gamma);
+    (void) GammaImageChannel(new_image, channels, gamma);
     rm_check_image_exception(new_image, DestroyOnError);
 
     return rm_image_new(new_image);
@@ -6932,7 +7048,6 @@ Image_gamma_correct(int argc, VALUE *argv, VALUE self)
 {
     Image *image, *new_image;
     double red_gamma, green_gamma, blue_gamma;
-    char gamma_arg[50];
 
     image = rm_check_destroyed(self);
     switch (argc)
@@ -6957,11 +7072,19 @@ Image_gamma_correct(int argc, VALUE *argv, VALUE self)
             break;
     }
 
-    sprintf(gamma_arg, "%f,%f,%f", red_gamma, green_gamma, blue_gamma);
-
     new_image = rm_clone_image(image);
 
-    (void) GammaImage(new_image, gamma_arg);
+    if ((red_gamma == green_gamma) && (green_gamma == blue_gamma))
+    {
+        (void) GammaImageChannel(new_image, (ChannelType) (RedChannel | GreenChannel | BlueChannel), red_gamma);
+    }
+    else
+    {
+        (void) GammaImageChannel(new_image, RedChannel, red_gamma);
+        (void) GammaImageChannel(new_image, GreenChannel, green_gamma);
+        (void) GammaImageChannel(new_image, BlueChannel, blue_gamma);
+    }
+
     rm_check_image_exception(new_image, DestroyOnError);
 
     return rm_image_new(new_image);
@@ -7066,12 +7189,10 @@ DEF_ATTR_READER(Image, geometry, str)
  *
  * @param self this object
  * @param geometry the geometry
- * @return self
+ * @return geometry
  */
 VALUE
-Image_geometry_eq(
-                 VALUE self,
-                 VALUE geometry)
+Image_geometry_eq(VALUE self, VALUE geometry)
 {
     Image *image;
     VALUE geom_str;
@@ -7097,7 +7218,7 @@ Image_geometry_eq(
 
     RB_GC_GUARD(geom_str);
 
-    return self;
+    return geometry;
 }
 
 
@@ -7125,12 +7246,12 @@ VALUE
 Image_get_pixels(VALUE self, VALUE x_arg, VALUE y_arg, VALUE cols_arg, VALUE rows_arg)
 {
     Image *image;
-    const PixelPacket *pixels;
     ExceptionInfo *exception;
     long x, y;
     unsigned long columns, rows;
     long size, n;
     VALUE pixel_ary;
+    const PixelPacket *pixels;
 
     image = rm_check_destroyed(self);
     x       = NUM2LONG(x_arg);
@@ -7675,7 +7796,7 @@ VALUE
 Image_interlace(VALUE self)
 {
     Image *image = rm_check_destroyed(self);
-    return InterlaceType_new(image->interlace);
+    return InterlaceType_find(image->interlace);
 }
 
 
@@ -7687,14 +7808,14 @@ Image_interlace(VALUE self)
  *
  * @param self this object
  * @param interlace the interlace
- * @return self
+ * @return interlace
  */
 VALUE
 Image_interlace_eq(VALUE self, VALUE interlace)
 {
     Image *image = rm_check_frozen(self);
     VALUE_TO_ENUM(interlace, image->interlace, InterlaceType);
-    return self;
+    return interlace;
 }
 
 
@@ -7715,7 +7836,6 @@ Image_iptc_profile(VALUE self)
 
     image = rm_check_destroyed(self);
     profile = GetImageProfile(image, "iptc");
-    rm_check_image_exception(image, RetainOnError);
     if (!profile)
     {
         return Qnil;
@@ -7738,7 +7858,7 @@ Image_iptc_profile(VALUE self)
  *
  * @param self
  * @param profile the IPTC profile (as a string)
- * @return self
+ * @return profile
  */
 VALUE
 Image_iptc_profile_eq(VALUE self, VALUE profile)
@@ -7748,7 +7868,7 @@ Image_iptc_profile_eq(VALUE self, VALUE profile)
     {
         (void) set_profile(self, "iptc", profile);
     }
-    return self;
+    return profile;
 }
 
 
@@ -7907,7 +8027,6 @@ Image_level_colors(int argc, VALUE *argv, VALUE self)
     Image *image, *new_image;
     MagickPixel black_color, white_color;
     ChannelType channels;
-    ExceptionInfo *exception;
     MagickBooleanType invert = MagickTrue;
     MagickBooleanType status;
 
@@ -8012,8 +8131,8 @@ Image_levelize_channel(int argc, VALUE *argv, VALUE self)
 
     new_image = rm_clone_image(image);
     status = LevelizeImageChannel(new_image, channels, black_point, white_point, gamma);
-
     rm_check_image_exception(new_image, DestroyOnError);
+
     if (!status)
     {
         rb_raise(rb_eRuntimeError, "LevelizeImageChannel failed for unknown reason.");
@@ -8124,7 +8243,7 @@ Image_liquid_rescale(int argc, VALUE *argv, VALUE self)
  * @see Image__dump
  */
 VALUE
-Image__load(VALUE class, VALUE str)
+Image__load(VALUE class ATTRIBUTE_UNUSED, VALUE str)
 {
     Image *image;
     ImageInfo *info;
@@ -8133,8 +8252,6 @@ Image__load(VALUE class, VALUE str)
     char *blob;
     long length;
 
-    class = class;  // Suppress "never referenced" message from icc
-
     blob = rm_str2cstr(str, &length);
 
     // Must be as least as big as the 1st 4 fields in DumpedImage
@@ -8442,73 +8559,24 @@ get_image_mask(Image *image)
     return mask ? rm_image_new(mask) : Qnil;
 }
 
-
-/**
- * Set the image mask.
- *
- * Ruby usage:
- *   - @verbatim Image#mask= @endverbatim
- *
- * @param self this object
- * @param mask the mask to use
- * @return copy of the current clip-mask or nil
- * @deprecated This method has been deprecated. Please use Image_mask(mask-image).
- * @see Image_mask(mask-image)
- * @see get_image_mask
- */
-VALUE
-Image_mask_eq(VALUE self, VALUE mask)
-{
-    VALUE v[1];
-    v[0] = mask;
-    rb_warning("Image#mask= is deprecated; use Image#mask.");
-    return Image_mask(1, v, self);
-}
-
-
 /**
- * Associate a clip mask with the image.
+ * Sets the image's clip mask, or removes it when mask is nil.
  *
- * Ruby usage:
- *   - @verbatim Image#mask @endverbatim
- *   - @verbatim Image#mask(mask-image) @endverbatim
- *
- * Notes:
- *   - Omit the argument to get a copy of the current clip mask.
- *   - Pass "nil" for the mask-image to remove the current clip mask.
- *   - If the clip mask is not the same size as the target image, resizes the
- *     clip mask to match the target.
- *   - Distinguish from Image#clip_mask=
+ * No Ruby usage (internal function)
  *
- * @param argc number of input arguments
- * @param argv array of input arguments
- * @param self this object
+ * @param image the image
+ * @param mask the mask
  * @return copy of the current clip-mask or nil
- * @see get_image_mask
  */
-VALUE
-Image_mask(int argc, VALUE *argv, VALUE self)
+static VALUE
+set_image_mask(Image *image, VALUE mask)
 {
-    VALUE mask;
-    Image *image, *mask_image, *resized_image;
+    Image *mask_image, *resized_image;
     Image *clip_mask;
     long x, y;
     PixelPacket *q;
     ExceptionInfo *exception;
 
-    image = rm_check_destroyed(self);
-    if (argc == 0)
-    {
-        return get_image_mask(image);
-    }
-    if (argc > 1)
-    {
-        rb_raise(rb_eArgError, "wrong number of arguments (expected 0 or 1, got %d)", argc);
-    }
-
-    rb_check_frozen(self);
-    mask = argv[0];
-
     if (mask != Qnil)
     {
         mask = rm_cur_image(mask);
@@ -8580,6 +8648,73 @@ Image_mask(int argc, VALUE *argv, VALUE self)
 }
 
 
+/**
+ * Set the image mask.
+ *
+ * Ruby usage:
+ *   - @verbatim Image#mask= @endverbatim
+ *
+ * @param self this object
+ * @param mask the mask to use
+ * @return copy of the current clip-mask or nil
+ * @deprecated This method has been deprecated. Please use Image_mask(mask-image).
+ * @see Image_mask(mask-image)
+ * @see get_image_mask
+ */
+VALUE
+Image_mask_eq(VALUE self, VALUE mask)
+{
+    VALUE v[1];
+    v[0] = mask;
+    rb_warning("Image#mask= is deprecated; use Image#mask.");
+    return Image_mask(1, v, self);
+}
+
+
+/**
+ * Associate a clip mask with the image.
+ *
+ * Ruby usage:
+ *   - @verbatim Image#mask @endverbatim
+ *   - @verbatim Image#mask(mask-image) @endverbatim
+ *
+ * Notes:
+ *   - Omit the argument to get a copy of the current clip mask.
+ *   - Pass "nil" for the mask-image to remove the current clip mask.
+ *   - If the clip mask is not the same size as the target image, resizes the
+ *     clip mask to match the target.
+ *   - Distinguish from Image#clip_mask=
+ *
+ * @param argc number of input arguments
+ * @param argv array of input arguments
+ * @param self this object
+ * @return copy of the current clip-mask or nil
+ * @see get_image_mask
+ */
+VALUE
+Image_mask(int argc, VALUE *argv, VALUE self)
+{
+    VALUE mask;
+    Image *image;
+
+    image = rm_check_destroyed(self);
+    if (argc == 0)
+    {
+        return get_image_mask(image);
+    }
+    if (argc > 1)
+    {
+        rb_raise(rb_eArgError, "wrong number of arguments (expected 0 or 1, got %d)", argc);
+    }
+
+    rb_check_frozen(self);
+    mask = argv[0];
+
+    // Always return a copy of the mask!
+    return set_image_mask(image, mask);
+}
+
+
 /**
  * Get matte attribute.
  *
@@ -8660,14 +8795,14 @@ Image_matte_color(VALUE self)
  *
  * @param self this object
  * @param color the matte color
- * @return self
+ * @return color
  */
 VALUE
 Image_matte_color_eq(VALUE self, VALUE color)
 {
     Image *image = rm_check_frozen(self);
     Color_to_PixelColor(&image->matte_color, color);
-    return self;
+    return color;
 }
 
 
@@ -8675,41 +8810,56 @@ Image_matte_color_eq(VALUE self, VALUE color)
  * Call MatteFloodFillImage.
  *
  * Ruby usage:
- *   - @verbatim Image#matte_flood_fill(color, opacity, x, y, method_obj) @endverbatim
+ *   - @verbatim Image#matte_flood_fill(color x, y, method_obj, alpha: alpha) @endverbatim
  *
  * @param self this object
  * @param color the color
- * @param opacity the opacity
+ * @param alpha the alpha
  * @param x_obj x position
  * @param y_obj y position
  * @param method_obj which method to call: FloodfillMethod or FillToBorderMethod
  * @return a new image
  */
 VALUE
-Image_matte_flood_fill(VALUE self, VALUE color, VALUE opacity, VALUE x_obj, VALUE y_obj, VALUE method_obj)
+Image_matte_flood_fill(int argc, VALUE *argv, VALUE self)
 {
     Image *image, *new_image;
     PixelColor target;
-    Quantum op;
+    Quantum alpha;
     long x, y;
     PaintMethod method;
     DrawInfo *draw_info;
     MagickPixel target_mpp;
     MagickBooleanType invert;
+    int start_index;
 
     image = rm_check_destroyed(self);
-    Color_to_PixelColor(&target, color);
 
-    op = APP2QUANTUM(opacity);
+    if (argc != 5)
+    {
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 5)", argc);
+    }
 
-    VALUE_TO_ENUM(method_obj, method, PaintMethod);
+    if (TYPE(argv[4]) == T_HASH)
+    {
+        alpha = get_alpha_from_hash(argv[4]);
+        start_index = 1;
+    }
+    else
+    {
+        alpha = get_alpha_from_opacity(argv[1]);
+        start_index = 2;
+    }
+
+    Color_to_PixelColor(&target, argv[0]);
+    VALUE_TO_ENUM(argv[start_index + 2], method, PaintMethod);
     if (!(method == FloodfillMethod || method == FillToBorderMethod))
     {
         rb_raise(rb_eArgError, "paint method_obj must be FloodfillMethod or "
                  "FillToBorderMethod (%d given)", method);
     }
-    x = NUM2LONG(x_obj);
-    y = NUM2LONG(y_obj);
+    x = NUM2LONG(argv[start_index]);
+    y = NUM2LONG(argv[start_index + 1]);
     if ((unsigned long)x > image->columns || (unsigned long)y > image->rows)
     {
         rb_raise(rb_eArgError, "target out of range. %ldx%ld given, image is %lux%lu"
@@ -8725,7 +8875,7 @@ Image_matte_flood_fill(VALUE self, VALUE color, VALUE opacity, VALUE x_obj, VALU
     {
         rb_raise(rb_eNoMemError, "not enough memory to continue");
     }
-    draw_info->fill.opacity = op;
+    draw_info->fill.opacity = QuantumRange - alpha;
 
     if (method == FillToBorderMethod)
     {
@@ -8956,7 +9106,7 @@ Image_modulate(int argc, VALUE *argv, VALUE self)
  *
  * @param self this object
  * @param monitor the progress monitor
- * @return self
+ * @return monitor
  */
 VALUE
 Image_monitor_eq(VALUE self, VALUE monitor)
@@ -8972,7 +9122,7 @@ Image_monitor_eq(VALUE self, VALUE monitor)
         (void) SetImageProgressMonitor(image, rm_progress_monitor, (void *)monitor);
     }
 
-    return self;
+    return monitor;
 }
 
 
@@ -9179,7 +9329,7 @@ Image_negate_channel(int argc, VALUE *argv, VALUE self)
 
     new_image = rm_clone_image(image);
 
-    (void)NegateImageChannel(new_image, channels, grayscale);
+    (void) NegateImageChannel(new_image, channels, grayscale);
     rm_check_image_exception(new_image, DestroyOnError);
 
     return rm_image_new(new_image);
@@ -9588,7 +9738,6 @@ Image_opaque_channel(int argc, VALUE *argv, VALUE self)
 
     okay = OpaquePaintImageChannel(new_image, channels, &target_pp, &fill_pp, invert);
 
-    // Restore saved fuzz value
     new_image->fuzz = keep;
     rm_check_image_exception(new_image, DestroyOnError);
 
@@ -9683,7 +9832,6 @@ Image_ordered_dither(int argc, VALUE *argv, VALUE self)
 
     exception = AcquireExceptionInfo();
 
-    // ImageMagick >= 6.2.9
     (void) OrderedPosterizeImage(new_image, threshold_map, exception);
     rm_check_exception(exception, new_image, DestroyOnError);
 
@@ -9706,7 +9854,7 @@ VALUE
 Image_orientation(VALUE self)
 {
     Image *image = rm_check_destroyed(self);
-    return OrientationType_new(image->orientation);
+    return OrientationType_find(image->orientation);
 }
 
 
@@ -9718,14 +9866,14 @@ Image_orientation(VALUE self)
  *
  * @param self this object
  * @param orientation the orientation
- * @return self
+ * @return orientation
  */
 VALUE
 Image_orientation_eq(VALUE self, VALUE orientation)
 {
     Image *image = rm_check_frozen(self);
     VALUE_TO_ENUM(orientation, image->orientation, OrientationType);
-    return self;
+    return orientation;
 }
 
 
@@ -9754,14 +9902,14 @@ Image_page(VALUE self)
  *
  * @param self this object
  * @param rect the page rectangle
- * @return self
+ * @return rect
  */
 VALUE
 Image_page_eq(VALUE self, VALUE rect)
 {
     Image *image = rm_check_frozen(self);
     Export_RectangleInfo(&image->page, rect);
-    return self;
+    return rect;
 }
 
 
@@ -9770,12 +9918,12 @@ Image_page_eq(VALUE self, VALUE rect)
  *
  * Ruby usage:
  *   - @verbatim Image#paint_transparent(target) @endverbatim
- *   - @verbatim Image#paint_transparent(target, opacity) @endverbatim
- *   - @verbatim Image#paint_transparent(target, opacity, invert) @endverbatim
- *   - @verbatim Image#paint_transparent(target, opacity, invert, fuzz) @endverbatim
+ *   - @verbatim Image#paint_transparent(target, alpha: alpha) @endverbatim
+ *   - @verbatim Image#paint_transparent(target, invert, alpha: alpha) @endverbatim
+ *   - @verbatim Image#paint_transparent(target, invert, fuzz, alpha: alpha) @endverbatim
  *
  * Notes:
- *   - Default opacity is TransparentOpacity
+ *   - Default alpha is TransparentAlpha
  *   - Default invert is false
  *   - Default fuzz is the image's fuzz (see Image_fuzz_eq)
  *
@@ -9789,23 +9937,45 @@ Image_paint_transparent(int argc, VALUE *argv, VALUE self)
 {
     Image *image, *new_image;
     MagickPixel color;
-    Quantum opacity = TransparentOpacity;
+    Quantum alpha = TransparentAlpha;
     double keep, fuzz;
-    MagickBooleanType okay, invert = MagickFalse;
+    MagickBooleanType okay, invert;
 
     image = rm_check_destroyed(self);
 
     // Default fuzz value is image's fuzz attribute.
     fuzz = image->fuzz;
+    invert = MagickFalse;
 
     switch (argc)
     {
         case 4:
-            fuzz = NUM2DBL(argv[3]);
+            if (TYPE(argv[argc - 1]) == T_HASH)
+            {
+                fuzz = NUM2DBL(argv[2]);
+            }
+            else
+            {
+                fuzz = NUM2DBL(argv[3]);
+            }
         case 3:
-            invert = RTEST(argv[2]);
+            if (TYPE(argv[argc - 1]) == T_HASH)
+            {
+                invert = RTEST(argv[1]);
+            }
+            else
+            {
+                invert = RTEST(argv[2]);
+            }
         case 2:
-            opacity = APP2QUANTUM(argv[1]);
+            if (TYPE(argv[argc - 1]) == T_HASH)
+            {
+                alpha = get_alpha_from_hash(argv[argc - 1]);
+            }
+            else
+            {
+                alpha = get_alpha_from_opacity(argv[1]);
+            }
         case 1:
             Color_to_MagickPixel(image, &color, argv[0]);
             break;
@@ -9820,7 +9990,7 @@ Image_paint_transparent(int argc, VALUE *argv, VALUE self)
     keep = new_image->fuzz;
     new_image->fuzz = fuzz;
 
-    okay = TransparentPaintImage(new_image, (const MagickPixel *)&color, opacity, invert);
+    okay = TransparentPaintImage(new_image, (const MagickPixel *)&color, QuantumRange - alpha, invert);
     new_image->fuzz = keep;
 
     // Is it possible for TransparentPaintImage to silently fail?
@@ -9894,11 +10064,12 @@ Image_pixel_color(int argc, VALUE *argv, VALUE self)
 {
     Image *image;
     PixelColor new_color;
-    PixelPacket old_color, *pixel;
+    PixelPacket old_color;
     ExceptionInfo *exception;
     long x, y;
     unsigned int set = False;
     MagickBooleanType okay;
+    PixelPacket *pixel;
 
     memset(&old_color, 0, sizeof(old_color));
 
@@ -9951,8 +10122,6 @@ Image_pixel_color(int argc, VALUE *argv, VALUE self)
         return Pixel_from_PixelColor(&image->background_color);
     }
 
-    // Set the color of a pixel. Return previous color.
-    // Convert to DirectClass
     if (image->storage_class == PseudoClass)
     {
         okay = SetImageStorageClass(image, DirectClass);
@@ -9963,7 +10132,6 @@ Image_pixel_color(int argc, VALUE *argv, VALUE self)
         }
     }
 
-
     exception = AcquireExceptionInfo();
 
     pixel = GetAuthenticPixels(image, x, y, 1, 1, exception);
@@ -9976,11 +10144,11 @@ Image_pixel_color(int argc, VALUE *argv, VALUE self)
         {
             old_color.opacity = OpaqueOpacity;
         }
-    }
-    *pixel = new_color;
+        *pixel = new_color;
 
-    SyncAuthenticPixels(image, exception);
-    CHECK_EXCEPTION()
+        SyncAuthenticPixels(image, exception);
+        CHECK_EXCEPTION()
+    }
 
     (void) DestroyExceptionInfo(exception);
 
@@ -10003,7 +10171,7 @@ VALUE
 Image_pixel_interpolation_method(VALUE self)
 {
     Image *image = rm_check_destroyed(self);
-    return InterpolatePixelMethod_new(image->interpolate);
+    return PixelInterpolateMethod_find(image->interpolate);
 }
 
 
@@ -10015,7 +10183,7 @@ Image_pixel_interpolation_method(VALUE self)
  *
  * @param self this object
  * @param method the interpolate field
- * @return self
+ * @return method
  * @see Image_pixel_interpolation_method
  * @see Image.interpolate_pixel_color
  */
@@ -10023,8 +10191,8 @@ VALUE
 Image_pixel_interpolation_method_eq(VALUE self, VALUE method)
 {
     Image *image = rm_check_frozen(self);
-    VALUE_TO_ENUM(method, image->interpolate, InterpolatePixelMethod);
-    return self;
+    VALUE_TO_ENUM(method, image->interpolate, PixelInterpolateMethod);
+    return method;
 }
 
 
@@ -10230,8 +10398,6 @@ Image_quantum_depth(VALUE self)
     image = rm_check_destroyed(self);
     quantum_depth = GetImageQuantumDepth(image, MagickFalse);
 
-    rm_check_image_exception(image, RetainOnError);
-
     return ULONG2NUM(quantum_depth);
 }
 
@@ -10729,7 +10895,7 @@ file_arg_rescue(VALUE arg)
  * @see array_from_images
  */
 static VALUE
-rd_image(VALUE class, VALUE file, reader_t reader)
+rd_image(VALUE class ATTRIBUTE_UNUSED, VALUE file, reader_t reader)
 {
     char *filename;
     long filename_l;
@@ -10738,8 +10904,6 @@ rd_image(VALUE class, VALUE file, reader_t reader)
     Image *images;
     ExceptionInfo *exception;
 
-    class = class;  // defeat gcc message
-
     // Create a new Info structure for this read/ping
     info_obj = rm_info_new();
     Data_Get_Struct(info_obj, Info, info);
@@ -10826,11 +10990,10 @@ Image_recolor(VALUE self, VALUE color_matrix)
 
     order = (unsigned long)sqrt((double)(len + 1.0));
 
-    // RecolorImage sets the ExceptionInfo and returns a NULL image if an error occurs.
     kernel_info = AcquireKernelInfo(NULL);
     if (kernel_info == (KernelInfo *) NULL)
     {
-        xfree((void *)matrix);
+        xfree((void *) matrix);
         return Qnil;
     }
     kernel_info->width = order;
@@ -10840,8 +11003,8 @@ Image_recolor(VALUE self, VALUE color_matrix)
     exception = AcquireExceptionInfo();
     new_image = ColorMatrixImage(image, kernel_info, exception);
     kernel_info->values = (double *) NULL;
-    kernel_info = DestroyKernelInfo(kernel_info);
-    xfree((void *)matrix);
+    (void) DestroyKernelInfo(kernel_info);
+    xfree((void *) matrix);
 
     rm_check_exception(exception, new_image, DestroyOnError);
     (void) DestroyExceptionInfo(exception);
@@ -10867,7 +11030,7 @@ Image_recolor(VALUE self, VALUE color_matrix)
  * @see array_from_images
  */
 VALUE
-Image_read_inline(VALUE self, VALUE content)
+Image_read_inline(VALUE self ATTRIBUTE_UNUSED, VALUE content)
 {
     VALUE info_obj;
     Image *images;
@@ -10878,8 +11041,6 @@ Image_read_inline(VALUE self, VALUE content)
     size_t blob_l;
     ExceptionInfo *exception;
 
-    self = self;    // defeat gcc message
-
     image_data = rm_str2cstr(content, &image_data_l);
 
     // Search for a comma. If found, we'll set the start of the
@@ -10970,11 +11131,12 @@ Image_reduce_noise(VALUE self, VALUE radius)
 {
     Image *image, *new_image;
     ExceptionInfo *exception;
+    size_t radius_size = NUM2SIZET(radius);
 
     image = rm_check_destroyed(self);
 
     exception = AcquireExceptionInfo();
-    new_image = StatisticImage(image, NonpeakStatistic, (size_t)radius, (size_t)radius, exception);
+    new_image = StatisticImage(image, NonpeakStatistic, radius_size, radius_size, exception);
     rm_check_exception(exception, new_image, DestroyOnError);
 
     (void) DestroyExceptionInfo(exception);
@@ -11047,7 +11209,7 @@ VALUE
 Image_rendering_intent(VALUE self)
 {
     Image *image = rm_check_destroyed(self);
-    return RenderingIntent_new(image->rendering_intent);
+    return RenderingIntent_find(image->rendering_intent);
 }
 
 
@@ -11059,14 +11221,14 @@ Image_rendering_intent(VALUE self)
  *
  * @param self this object
  * @param ri the rendering intent
- * @return self
+ * @return ri
  */
 VALUE
 Image_rendering_intent_eq(VALUE self, VALUE ri)
 {
     Image *image = rm_check_frozen(self);
     VALUE_TO_ENUM(ri, image->rendering_intent, RenderingIntent);
-    return self;
+    return ri;
 }
 
 
@@ -11088,7 +11250,7 @@ static VALUE
 resample(int bang, int argc, VALUE *argv, VALUE self)
 {
     Image *image, *new_image;
-    FilterTypes filter;
+    FilterType filter;
     double x_resolution, y_resolution, blur;
     double width, height;
     ExceptionInfo *exception;
@@ -11106,7 +11268,7 @@ resample(int bang, int argc, VALUE *argv, VALUE self)
         case 4:
             blur = NUM2DBL(argv[3]);
         case 3:
-            VALUE_TO_ENUM(argv[2], filter, FilterTypes);
+            VALUE_TO_ENUM(argv[2], filter, FilterType);
         case 2:
             y_resolution = NUM2DBL(argv[1]);
             if (y_resolution < 0.0)
@@ -11235,7 +11397,7 @@ resize(int bang, int argc, VALUE *argv, VALUE self)
 {
     Image *image, *new_image;
     double scale_arg;
-    FilterTypes filter;
+    FilterType filter;
     unsigned long rows, columns;
     double blur, drows, dcols;
     ExceptionInfo *exception;
@@ -11253,7 +11415,7 @@ resize(int bang, int argc, VALUE *argv, VALUE self)
         case 4:
             blur = NUM2DBL(argv[3]);
         case 3:
-            VALUE_TO_ENUM(argv[2], filter, FilterTypes);
+            VALUE_TO_ENUM(argv[2], filter, FilterType);
         case 2:
             rows = NUM2ULONG(argv[1]);
             columns = NUM2ULONG(argv[0]);
@@ -11941,7 +12103,8 @@ Image_segment(int argc, VALUE *argv, VALUE self)
  *
  * @param self this object
  * @param opacity_arg the opacity
- * @return self
+ * @return opacity_arg
+ * @deprecated This method has been deprecated. Please use Image_alpha.
  */
 VALUE
 Image_opacity_eq(VALUE self, VALUE opacity_arg)
@@ -11949,11 +12112,13 @@ Image_opacity_eq(VALUE self, VALUE opacity_arg)
     Image *image;
     Quantum opacity;
 
+    rb_warning("Image#opacity is deprecated; use Image#alpha");
+
     image = rm_check_frozen(self);
     opacity = APP2QUANTUM(opacity_arg);
     (void) SetImageOpacity(image, opacity);
     rm_check_image_exception(image, RetainOnError);
-    return self;
+    return opacity_arg;
 }
 
 
@@ -11975,10 +12140,8 @@ VALUE
 Image_properties(VALUE self)
 {
     Image *image;
-    VALUE attr_hash;
-    VALUE ary;
-    char *property;
-    const char *value;
+    VALUE attr_hash, ary;
+    const char *property, *value;
 
     image = rm_check_destroyed(self);
 
@@ -12083,7 +12246,7 @@ Image_shade(int argc, VALUE *argv, VALUE self)
 
 
 /**
- * Call ShadowImage. X- and y-offsets are the pixel offset. Opacity is either a
+ * Call ShadowImage. X- and y-offsets are the pixel offset. Alpha is either a
  * number between 0 and 1 or a string "NN%". Sigma is the std. dev. of the
  * Gaussian, in pixels.
  *
@@ -12092,14 +12255,14 @@ Image_shade(int argc, VALUE *argv, VALUE self)
  *   - @verbatim Image#shadow(x_offset) @endverbatim
  *   - @verbatim Image#shadow(x_offset, y_offset) @endverbatim
  *   - @verbatim Image#shadow(x_offset, y_offset, sigma) @endverbatim
- *   - @verbatim Image#shadow(x_offset, y_offset, sigma, opacity) @endverbatim
+ *   - @verbatim Image#shadow(x_offset, y_offset, sigma, alpha) @endverbatim
  *
  * Notes:
  *   - Default x_offset is 4
  *   - Default y_offset is 4
  *   - Default sigma is 4.0
- *   - Default opacity is 1.0
- *   - The defaults are taken from the mogrify.c source, except for opacity,
+ *   - Default alpha is 1.0
+ *   - The defaults are taken from the mogrify.c source, except for alpha,
  *     which has no default.
  *   - Introduced in ImageMagick 6.1.7
  *
@@ -12112,7 +12275,7 @@ VALUE
 Image_shadow(int argc, VALUE *argv, VALUE self)
 {
     Image *image, *new_image;
-    double opacity = 100.0;
+    double alpha = 100.0;
     double sigma = 4.0;
     long x_offset = 4L;
     long y_offset = 4L;
@@ -12122,14 +12285,14 @@ Image_shadow(int argc, VALUE *argv, VALUE self)
     switch (argc)
     {
         case 4:
-            opacity = rm_percentage(argv[3],1.0);   // Clamp to 1.0 < x <= 100.0
-            if (fabs(opacity) < 0.01)
+            alpha = rm_percentage(argv[3],1.0);   // Clamp to 1.0 < x <= 100.0
+            if (fabs(alpha) < 0.01)
             {
-                rb_warning("shadow will be transparent - opacity %g very small", opacity);
+                rb_warning("shadow will be transparent - alpha %g very small", alpha);
             }
-            opacity = FMIN(opacity, 1.0);
-            opacity = FMAX(opacity, 0.01);
-            opacity *= 100.0;
+            alpha = FMIN(alpha, 1.0);
+            alpha = FMAX(alpha, 0.01);
+            alpha *= 100.0;
         case 3:
             sigma = NUM2DBL(argv[2]);
         case 2:
@@ -12144,7 +12307,7 @@ Image_shadow(int argc, VALUE *argv, VALUE self)
     }
 
     exception = AcquireExceptionInfo();
-    new_image = ShadowImage(image, opacity, sigma, x_offset, y_offset, exception);
+    new_image = ShadowImage(image, alpha, sigma, x_offset, y_offset, exception);
     rm_check_exception(exception, new_image, DestroyOnError);
 
     (void) DestroyExceptionInfo(exception);
@@ -12388,8 +12551,8 @@ Image_signature(VALUE self)
     image = rm_check_destroyed(self);
 
     (void) SignatureImage(image);
-    signature = rm_get_property(image, "signature");
     rm_check_image_exception(image, RetainOnError);
+    signature = rm_get_property(image, "signature");
     if (!signature)
     {
         return Qnil;
@@ -12645,7 +12808,7 @@ Image_sparse_color(int argc, VALUE *argv, VALUE self)
         }
         else
         {
-            xfree((void *)args);
+            xfree((void *) args);
             rb_raise(rb_eTypeError, "type mismatch: %s and %s given", rb_class2name(CLASS_OF(elem1)), rb_class2name(CLASS_OF(elem2)));
         }
         Color_to_MagickPixel(NULL, &pp, argv[n++]);
@@ -12673,8 +12836,8 @@ Image_sparse_color(int argc, VALUE *argv, VALUE self)
 
     exception = AcquireExceptionInfo();
     new_image = SparseColorImage(image, channels, method, nargs, args, exception);
-    xfree(args);
-    CHECK_EXCEPTION();
+    xfree((void *) args);
+    rm_check_exception(exception, new_image, DestroyOnError);
     (void) DestroyExceptionInfo(exception);
     rm_ensure_result(new_image);
 
@@ -12893,7 +13056,7 @@ VALUE
 Image_class_type(VALUE self)
 {
     Image *image = rm_check_destroyed(self);
-    return ClassType_new(image->storage_class);
+    return ClassType_find(image->storage_class);
 }
 
 
@@ -12908,7 +13071,7 @@ Image_class_type(VALUE self)
  *
  * @param self this object
  * @param new_class_type the storage class
- * @return self
+ * @return new_class_type
  */
 VALUE
 Image_class_type_eq(VALUE self, VALUE new_class_type)
@@ -12921,6 +13084,11 @@ Image_class_type_eq(VALUE self, VALUE new_class_type)
 
     VALUE_TO_ENUM(new_class_type, class_type, ClassType);
 
+    if (class_type == UndefinedClass)
+    {
+        rb_raise(rb_eArgError, "Invalid class type specified.");
+    }
+
     if (image->storage_class == PseudoClass && class_type == DirectClass)
     {
         (void) SyncImage(image);
@@ -12935,7 +13103,7 @@ Image_class_type_eq(VALUE self, VALUE new_class_type)
     }
 
     (void) SetImageStorageClass(image, class_type);
-    return self;
+    return new_class_type;
 }
 
 
@@ -12963,13 +13131,14 @@ 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;
+    Pixel *pixel;
     VALUE new_pixel;
     long n, size;
     long x, y;
     unsigned long cols, rows;
     unsigned int okay;
     ExceptionInfo *exception;
+    PixelPacket *pixels;
 
     image = rm_check_destroyed(self);
 
@@ -13084,10 +13253,12 @@ Image_swirl(VALUE self, VALUE degrees_obj)
  *
  * @param self this object
  * @return true if succeeded, otherwise false
+ * @deprecated This method has been deprecated.
  */
 VALUE
 Image_sync_profiles(VALUE self)
 {
+    rb_warning("Image#sync_profiles is deprecated");
     Image *image = rm_check_destroyed(self);
     VALUE okay =  SyncImageProfiles(image) ? Qtrue : Qfalse;
     rm_check_image_exception(image, RetainOnError);
@@ -13234,7 +13405,7 @@ static
 VALUE threshold_image(int argc, VALUE *argv, VALUE self, thresholder_t thresholder)
 {
     Image *image, *new_image;
-    double red, green, blue, opacity;
+    double red, green, blue, alpha;
     char ctarg[200];
 
     image = rm_check_destroyed(self);
@@ -13245,8 +13416,8 @@ VALUE threshold_image(int argc, VALUE *argv, VALUE self, thresholder_t threshold
             red     = NUM2DBL(argv[0]);
             green   = NUM2DBL(argv[1]);
             blue    = NUM2DBL(argv[2]);
-            opacity = NUM2DBL(argv[3]);
-            sprintf(ctarg, "%f,%f,%f,%f", red, green, blue, opacity);
+            alpha   = get_named_alpha_value(argv[3]);
+            sprintf(ctarg, "%f,%f,%f,%f", red, green, blue, QuantumRange - alpha);
             break;
         case 3:
             red     = NUM2DBL(argv[0]);
@@ -13298,6 +13469,8 @@ thumbnail(int bang, int argc, VALUE *argv, VALUE self)
     Image *image, *new_image;
     unsigned long columns, rows;
     double scale_arg, drows, dcols;
+    char image_geometry[MaxTextExtent];
+    RectangleInfo geometry;
     ExceptionInfo *exception;
 
     Data_Get_Struct(self, Image, image);
@@ -13332,8 +13505,13 @@ thumbnail(int bang, int argc, VALUE *argv, VALUE self)
             break;
     }
 
+    snprintf(image_geometry, sizeof(image_geometry), "%ldx%ld", columns, rows);
+
     exception = AcquireExceptionInfo();
-    new_image = ThumbnailImage(image, columns, rows, exception);
+    (void) ParseRegionGeometry(image, image_geometry, &geometry, exception);
+    rm_check_exception(exception, image, RetainOnError);
+
+    new_image = ThumbnailImage(image, geometry.width, geometry.height, exception);
     rm_check_exception(exception, new_image, DestroyOnError);
 
     (void) DestroyExceptionInfo(exception);
@@ -13420,14 +13598,14 @@ Image_ticks_per_second(VALUE self)
  *
  * @param self this object
  * @param tps ticks per second
- * @return self
+ * @return tps
  */
 VALUE
 Image_ticks_per_second_eq(VALUE self, VALUE tps)
 {
     Image *image = rm_check_frozen(self);
     image->ticks_per_second = NUM2ULONG(tps);
-    return self;
+    return tps;
 }
 
 
@@ -13435,16 +13613,16 @@ Image_ticks_per_second_eq(VALUE self, VALUE tps)
  * Call TintImage.
  *
  * Ruby usage:
- *   - @verbatim Image#tint(tint, red_opacity) @endverbatim
- *   - @verbatim Image#tint(tint, red_opacity, green_opacity) @endverbatim
- *   - @verbatim Image#tint(tint, red_opacity, green_opacity, blue_opacity) @endverbatim
- *   - @verbatim Image#tint(tint, red_opacity, green_opacity, blue_opacity, alpha_opacity) @endverbatim
+ *   - @verbatim Image#tint(tint, red_alpha) @endverbatim
+ *   - @verbatim Image#tint(tint, red_alpha, green_alpha) @endverbatim
+ *   - @verbatim Image#tint(tint, red_alpha, green_alpha, blue_alpha) @endverbatim
+ *   - @verbatim Image#tint(tint, red_alpha, green_alpha, blue_alpha, alpha_alpha) @endverbatim
  *
  * Notes:
- *   - Default green_opacity is red_opacity
- *   - Default blue_opacity is red_opacity
- *   - Default alpha_opacity is 1.0
- *   - Opacity values are percentages: 0.10 -> 10%.
+ *   - Default green_alpha is red_alpha
+ *   - Default blue_alpha is red_alpha
+ *   - Default alpha_alpha is 1.0
+ *   - Alpha values are percentages: 0.10 -> 10%.
  *
  * @param argc number of input arguments
  * @param argv array of input arguments
@@ -13458,7 +13636,7 @@ Image_tint(int argc, VALUE *argv, VALUE self)
     PixelColor tint;
     double red_pct_opaque, green_pct_opaque, blue_pct_opaque;
     double alpha_pct_opaque = 1.0;
-    char opacity[50];
+    char alpha[50];
     ExceptionInfo *exception;
 
     image = rm_check_destroyed(self);
@@ -13493,21 +13671,17 @@ Image_tint(int argc, VALUE *argv, VALUE self)
     if (red_pct_opaque < 0.0 || green_pct_opaque < 0.0
         || blue_pct_opaque < 0.0 || alpha_pct_opaque < 0.0)
     {
-        rb_raise(rb_eArgError, "opacity percentages must be non-negative.");
+        rb_raise(rb_eArgError, "alpha percentages must be non-negative.");
     }
 
-#if defined(HAVE_SNPRINTF)
-    snprintf(opacity, sizeof(opacity),
-#else
-    sprintf(opacity,
-#endif
+    snprintf(alpha, sizeof(alpha),
             "%g,%g,%g,%g", red_pct_opaque*100.0, green_pct_opaque*100.0
             , blue_pct_opaque*100.0, alpha_pct_opaque*100.0);
 
     Color_to_PixelColor(&tint, argv[0]);
     exception = AcquireExceptionInfo();
 
-    new_image = TintImage(image, opacity, tint, exception);
+    new_image = TintImage(image, alpha, tint, exception);
     rm_check_exception(exception, new_image, DestroyOnError);
 
     (void) DestroyExceptionInfo(exception);
@@ -13639,7 +13813,6 @@ Image_to_color(VALUE self, VALUE pixel_arg)
     // doesn't have a "real" name, just a sequence of hex digits. We don't care
     // about that.
 
-    name[0] = '\0';
     (void) QueryColorname(image, &pixel, AllCompliance, name, exception);
     CHECK_EXCEPTION()
 
@@ -13701,13 +13874,13 @@ Image_total_ink_density(VALUE self)
  *
  * Ruby usage:
  *   - @verbatim Image#transparent(color-name) @endverbatim
- *   - @verbatim Image#transparent(color-name, opacity) @endverbatim
+ *   - @verbatim Image#transparent(color-name, alpha: alpha) @endverbatim
  *   - @verbatim Image#transparent(pixel) @endverbatim
- *   - @verbatim Image#transparent(pixel, opacity) @endverbatim
+ *   - @verbatim Image#transparent(pixel, alpha: alpha) @endverbatim
  *
  * Notes:
- *   - Default opacity is Magick::TransparentOpacity.
- *   - Can use Magick::OpaqueOpacity or Magick::TransparentOpacity, or any
+ *   - Default alpha is Magick::TransparentAlpha.
+ *   - Can use Magick::OpaqueAlpha or Magick::TransparentAlpha, or any
  *     value >= 0 && <= QuantumRange.
  *   - Use Image#fuzz= to define the tolerance level.
  *
@@ -13721,7 +13894,7 @@ Image_transparent(int argc, VALUE *argv, VALUE self)
 {
     Image *image, *new_image;
     MagickPixel color;
-    Quantum opacity = TransparentOpacity;
+    Quantum alpha = TransparentAlpha;
     MagickBooleanType okay;
 
     image = rm_check_destroyed(self);
@@ -13729,7 +13902,7 @@ Image_transparent(int argc, VALUE *argv, VALUE self)
     switch (argc)
     {
         case 2:
-            opacity = APP2QUANTUM(argv[1]);
+            alpha = get_named_alpha_value(argv[1]);
         case 1:
             Color_to_MagickPixel(image, &color, argv[0]);
             break;
@@ -13740,7 +13913,7 @@ Image_transparent(int argc, VALUE *argv, VALUE self)
 
     new_image = rm_clone_image(image);
 
-    okay = TransparentPaintImage(new_image, &color, opacity, MagickFalse);
+    okay = TransparentPaintImage(new_image, &color, QuantumRange - alpha, MagickFalse);
     rm_check_image_exception(new_image, DestroyOnError);
     if (!okay)
     {
@@ -13758,11 +13931,11 @@ Image_transparent(int argc, VALUE *argv, VALUE self)
  *
  * Ruby usage:
  *   - @verbatim Image#transparent_chroma(low, high) @endverbatim
- *   - @verbatim Image#transparent_chroma(low, high, opacity) @endverbatim
- *   - @verbatim Image#transparent_chroma(low, high, opacity, invert) @endverbatim
+ *   - @verbatim Image#transparent_chroma(low, high, alpha: alpha) @endverbatim
+ *   - @verbatim Image#transparent_chroma(low, high, invert, alpha: alpha) @endverbatim
  *
  * Notes:
- *   - Default opacity is TransparentOpacity
+ *   - Default alpha is TransparentAlpha
  *   - Default invert is false
  *   - Available in ImageMagick >= 6.4.5-6
  *
@@ -13775,7 +13948,7 @@ VALUE
 Image_transparent_chroma(int argc, VALUE *argv, VALUE self)
 {
     Image *image, *new_image;
-    Quantum opacity = TransparentOpacity;
+    Quantum alpha = TransparentAlpha;
     MagickPixel low, high;
     MagickBooleanType invert = MagickFalse;
     MagickBooleanType okay;
@@ -13785,9 +13958,23 @@ Image_transparent_chroma(int argc, VALUE *argv, VALUE self)
     switch (argc)
     {
         case 4:
-            invert = RTEST(argv[3]);
+            if (TYPE(argv[argc - 1]) == T_HASH)
+            {
+                invert = RTEST(argv[3]);
+            }
+            else
+            {
+                invert = RTEST(argv[2]);
+            }
         case 3:
-            opacity = APP2QUANTUM(argv[2]);
+            if (TYPE(argv[argc - 1]) == T_HASH)
+            {
+                alpha = get_alpha_from_hash(argv[argc - 1]);
+            }
+            else
+            {
+                alpha = get_alpha_from_opacity(argv[2]);
+            }
         case 2:
             Color_to_MagickPixel(image, &high, argv[1]);
             Color_to_MagickPixel(image, &low, argv[0]);
@@ -13799,7 +13986,7 @@ Image_transparent_chroma(int argc, VALUE *argv, VALUE self)
 
     new_image = rm_clone_image(image);
 
-    okay = TransparentPaintImageChroma(new_image, &low, &high, opacity, invert);
+    okay = TransparentPaintImageChroma(new_image, &low, &high, QuantumRange - alpha, invert);
     rm_check_image_exception(new_image, DestroyOnError);
     if (!okay)
     {
@@ -13837,14 +14024,14 @@ Image_transparent_color(VALUE self)
  *
  * @param self this object
  * @param color the transparent color
- * @return self
+ * @return color
  */
 VALUE
 Image_transparent_color_eq(VALUE self, VALUE color)
 {
     Image *image = rm_check_frozen(self);
     Color_to_PixelColor(&image->transparent_color, color);
-    return self;
+    return color;
 }
 
 
@@ -14047,7 +14234,7 @@ Image_trim_bang(int argc, VALUE *argv, VALUE self)
 VALUE Image_gravity(VALUE self)
 {
     Image *image = rm_check_destroyed(self);
-    return GravityType_new(image->gravity);
+    return GravityType_find(image->gravity);
 }
 
 
@@ -14091,7 +14278,7 @@ VALUE Image_image_type(VALUE self)
 
     (void) DestroyExceptionInfo(exception);
 
-    return ImageType_new(type);
+    return ImageType_find(type);
 }
 
 
@@ -14186,7 +14373,7 @@ VALUE
 Image_units(VALUE self)
 {
     Image *image = rm_check_destroyed(self);
-    return ResolutionType_new(image->units);
+    return ResolutionType_find(image->units);
 }
 
 
@@ -14198,7 +14385,7 @@ Image_units(VALUE self)
  *
  * @param self this object
  * @param restype the resolution type
- * @return self
+ * @return restype
  */
 VALUE
 Image_units_eq(VALUE self, VALUE restype)
@@ -14238,7 +14425,7 @@ Image_units_eq(VALUE self, VALUE restype)
         image->units = units;
     }
 
-    return self;
+    return restype;
 }
 
 
@@ -14388,8 +14575,7 @@ Image_unsharp_mask_channel(int argc, VALUE *argv, VALUE self)
     unsharp_mask_args(argc, argv, &radius, &sigma, &amount, &threshold);
 
     exception = AcquireExceptionInfo();
-    new_image = UnsharpMaskImageChannel(image, channels, radius, sigma, amount
-                                        , threshold, exception);
+    new_image = UnsharpMaskImageChannel(image, channels, radius, sigma, amount, threshold, exception);
     rm_check_exception(exception, new_image, DestroyOnError);
 
     (void) DestroyExceptionInfo(exception);
@@ -14482,8 +14668,7 @@ Image_virtual_pixel_method(VALUE self)
 
     image = rm_check_destroyed(self);
     vpm = GetImageVirtualPixelMethod(image);
-    rm_check_image_exception(image, RetainOnError);
-    return VirtualPixelMethod_new(vpm);
+    return VirtualPixelMethod_find(vpm);
 }
 
 
@@ -14495,7 +14680,7 @@ Image_virtual_pixel_method(VALUE self)
  *
  * @param self this object
  * @param method the VirtualPixelMethod
- * @return self
+ * @return method
  */
 VALUE
 Image_virtual_pixel_method_eq(VALUE self, VALUE method)
@@ -14507,7 +14692,7 @@ Image_virtual_pixel_method_eq(VALUE self, VALUE method)
     VALUE_TO_ENUM(method, vpm, VirtualPixelMethod);
     (void) SetImageVirtualPixelMethod(image, vpm);
     rm_check_image_exception(image, RetainOnError);
-    return self;
+    return method;
 }
 
 
@@ -14796,10 +14981,10 @@ Image_wet_floor(int argc, VALUE *argv, VALUE self)
  * Call WhiteThresholdImage.
  *
  * Ruby usage:
- *   - @verbatim Image#white_threshold(red_channel) @endverbatim
- *   - @verbatim Image#white_threshold(red_channel, green_channel) @endverbatim
- *   - @verbatim Image#white_threshold(red_channel, green_channel, blue_channel) @endverbatim
- *   - @verbatim Image#white_threshold(red_channel, green_channel, blue_channel, opacity_channel) @endverbatim
+ *   - @verbatim Image#white_threshold(red) @endverbatim
+ *   - @verbatim Image#white_threshold(red, green) @endverbatim
+ *   - @verbatim Image#white_threshold(red, green, blue) @endverbatim
+ *   - @verbatim Image#white_threshold(red, green, blue, alpha: alpha) @endverbatim
  *
  * @param argc number of input arguments
  * @param argv array of input arguments
@@ -15197,11 +15382,15 @@ xform_image(int bang, VALUE self, VALUE x, VALUE y, VALUE width, VALUE height, x
     new_image = (xformer)(image, &rect, exception);
 
     // An exception can occur in either the old or the new images
-    rm_check_image_exception(image, RetainOnError);
     rm_check_exception(exception, new_image, DestroyOnError);
-
     (void) DestroyExceptionInfo(exception);
 
+    if (rm_should_raise_exception(&image->exception, RetainExceptionRetention))
+    {
+        (void) DestroyImage(new_image);
+        rm_check_image_exception(image, RetainOnError);
+    }
+
     rm_ensure_result(new_image);
 
     if (bang)