rmagick 2.3.0 → 2.4.0

data/ext/RMagick/rmagick.h

@@ -1,4 +1,4 @@
-/* $Id: rmagick.h,v 1.231 2008/03/29 15:23:12 rmagick Exp $ */
+/* $Id: rmagick.h,v 1.234 2008/06/02 22:47:37 rmagick Exp $ */
 /*=============================================================================
 |               Copyright (C) 2008 by Timothy P. Hunter
 | Name:     rmagick.h
@@ -122,6 +122,12 @@
 #define RARRAY_PTR(a) RARRAY((a))->ptr
 #endif
 
+// These two functions are defined in IM starting with 6.3.2.
+#if !defined(HAVE_GETSTRINGINFODATUM)
+#define GetStringInfoDatum(p) (unsigned char *)((p)->datum)
+#define GetStringInfoLength(p) (size_t)((p)->length)
+#endif
+
 // ImageLayerMethod replaced MagickLayerMethod starting with 6.3.6
 #if defined(HAVE_TYPE_IMAGELAYERMETHOD)
 #define LAYERMETHODTYPE ImageLayerMethod
@@ -530,6 +536,14 @@ Pixel_##_cmyk_channel_(VALUE self) \
 // declaration can refer to a function defined in another source file or
 // the same source file.
 
+
+// rmmain.c
+extern void Init_RMagick2(void);
+extern VALUE Magick_colors(VALUE);
+extern VALUE Magick_fonts(VALUE);
+extern VALUE Magick_init_formats(VALUE);
+
+
 // rmdraw.c
 ATTR_WRITER(Draw, affine)
 ATTR_WRITER(Draw, align)
@@ -598,10 +612,6 @@ ATTR_WRITER(PolaroidOptions, shadow_color);
 ATTR_WRITER(PolaroidOptions, border_color);
 
 
-// rmmain.c
-extern VALUE rm_montage_new(void);
-
-
  // rmilist.c
 extern VALUE ImageList_animate(int, VALUE *, VALUE);
 extern VALUE ImageList_append(VALUE, VALUE);
@@ -719,7 +729,7 @@ ATTR_ACCESSOR(Image, fuzz)
 ATTR_ACCESSOR(Image, gamma)
 ATTR_ACCESSOR(Image, geometry)
 ATTR_ACCESSOR(Image, gravity)
-ATTR_READER(Image, image_type)
+ATTR_ACCESSOR(Image, image_type)
 ATTR_ACCESSOR(Image, interlace)
 ATTR_ACCESSOR(Image, iptc_profile)
 ATTR_ACCESSOR(Image, iterations)
@@ -1025,7 +1035,7 @@ extern VALUE  Pixel_to_hsla(VALUE);
 extern VALUE  Pixel_to_s(VALUE);
 extern VALUE  PixelPacket_to_Color_Name(Image *, PixelPacket *);
 extern VALUE  PixelPacket_to_Color_Name_Info(Info *, PixelPacket *);
-extern VALUE  Pixel_from_PixelPacket(PixelPacket *);
+extern VALUE  Pixel_from_PixelPacket(const PixelPacket *);
 
 extern void   Point_to_PointInfo(PointInfo *, VALUE);
 extern VALUE  PointInfo_to_Point(PointInfo *);
@@ -1047,11 +1057,12 @@ extern void   Rectangle_to_RectangleInfo(RectangleInfo *, VALUE);
 extern void   Segment_to_SegmentInfo(SegmentInfo *, VALUE);
 extern void   Font_to_TypeInfo(TypeInfo *, VALUE);
 extern void   TypeMetric_to_TypeMetric(TypeMetric *, VALUE);
-extern VALUE  Font_from_TypeInfo(TypeInfo *);
+extern VALUE  Font_from_TypeInfo(const TypeInfo *);
 extern VALUE  TypeMetric_to_s(VALUE);
 extern VALUE  TypeMetric_from_TypeMetric(TypeMetric *);
 extern const char *StorageType_name(StorageType);
 extern VALUE  VirtualPixelMethod_new(VirtualPixelMethod);
+extern VALUE  LAYERMETHODTYPE_NEW(LAYERMETHODTYPE);
 
 extern VALUE  Enum_alloc(VALUE);
 extern VALUE  Enum_initialize(VALUE, VALUE, VALUE);
@@ -1086,7 +1097,7 @@ extern double rm_fuzz_to_dbl(VALUE);
 extern Quantum rm_app2quantum(VALUE);
 extern double rm_percentage(VALUE);
 extern double rm_str_to_pct(VALUE);
-extern VALUE  rm_define_enum_type(char *);
+extern VALUE  rm_define_enum_type(const char *);
 extern void   rm_write_temp_image(Image *, char *);
 extern void   rm_delete_temp_image(char *);
 extern void   rm_not_implemented(void);

data/ext/RMagick/rmdraw.c

@@ -1,4 +1,4 @@
-/* $Id: rmdraw.c,v 1.62 2008/03/29 15:20:36 rmagick Exp $ */
+/* $Id: rmdraw.c,v 1.64 2008/05/21 22:32:40 rmagick Exp $ */
 /*============================================================================\
 |                Copyright (C) 2008 by Timothy P. Hunter
 | Name:     rmdraw.c
@@ -489,7 +489,11 @@ VALUE Draw_annotate(
     }
 
     // Translate & store in Draw structure
+#if defined(HAVE_INTERPRETIMAGEPROPERTIES)
+    draw->info->text = InterpretImageProperties(NULL, image, StringValuePtr(text));
+#else
     draw->info->text = InterpretImageAttributes(NULL, image, StringValuePtr(text));
+#endif
     if (!draw->info->text)
     {
         rb_raise(rb_eArgError, "no text");
@@ -561,7 +565,7 @@ Draw_composite(int argc, VALUE *argv, VALUE self)
     CompositeOperator cop = OverCompositeOp;
     volatile VALUE image;
     Image *comp_img;
-    struct TmpFile_Name *tmpfile;
+    struct TmpFile_Name *tmpfile_name;
     char name[MaxTextExtent];
     // Buffer for "image" primitive
     char primitive[MaxTextExtent];
@@ -656,10 +660,10 @@ Draw_composite(int argc, VALUE *argv, VALUE self)
     // Add the temp filename to the filename array.
     // Use Magick storage since we need to keep the list around
     // until destroy_Draw is called.
-    tmpfile = magick_malloc(sizeof(struct TmpFile_Name)+strlen(name));
-    strcpy(tmpfile->name, name);
-    tmpfile->next = draw->tmpfile_ary;
-    draw->tmpfile_ary = tmpfile;
+    tmpfile_name = magick_malloc(sizeof(struct TmpFile_Name)+strlen(name));
+    strcpy(tmpfile_name->name, name);
+    tmpfile_name->next = draw->tmpfile_ary;
+    draw->tmpfile_ary = tmpfile_name;
 
     // Form the drawing primitive
     (void) sprintf(primitive, "image %s %g,%g,%g,%g '%s'", op, x, y, width, height, name);
@@ -879,7 +883,7 @@ static void
 destroy_Draw(void *drawptr)
 {
     Draw *draw = (Draw *)drawptr;
-    struct TmpFile_Name *tmpfile;
+    struct TmpFile_Name *tmpfile_name;
 
     if (draw->info)
     {
@@ -890,10 +894,10 @@ destroy_Draw(void *drawptr)
     // Erase any temporary image files.
     while (draw->tmpfile_ary)
     {
-        tmpfile = draw->tmpfile_ary;
+        tmpfile_name = draw->tmpfile_ary;
         draw->tmpfile_ary = draw->tmpfile_ary->next;
-        rm_delete_temp_image(tmpfile->name);
-        magick_free(tmpfile);
+        rm_delete_temp_image(tmpfile_name->name);
+        magick_free(tmpfile_name);
     }
 
     xfree(drawptr);
@@ -1254,7 +1258,7 @@ Montage_texture_eq(VALUE self, VALUE texture)
 {
     Montage *montage;
     Image *texture_image;
-    char tmpnam[MaxTextExtent];
+    char temp_name[MaxTextExtent];
 
     Data_Get_Struct(self, Montage, montage);
 
@@ -1271,8 +1275,8 @@ Montage_texture_eq(VALUE self, VALUE texture)
     texture_image = rm_check_destroyed(texture);
 
     // Write a temp copy of the image & save its name.
-    rm_write_temp_image(texture_image, tmpnam);
-    magick_clone_string(&montage->info->texture, tmpnam);
+    rm_write_temp_image(texture_image, temp_name);
+    magick_clone_string(&montage->info->texture, temp_name);
 
     return self;
 }
@@ -1500,7 +1504,11 @@ get_type_metrics(
     }
 
     Data_Get_Struct(self, Draw, draw);
+#if defined(HAVE_INTERPRETIMAGEPROPERTIES)
+    draw->info->text = InterpretImageProperties(NULL, image, text);
+#else
     draw->info->text = InterpretImageAttributes(NULL, image, text);
+#endif
     if (!draw->info->text)
     {
         rb_raise(rb_eArgError, "no text to measure");

data/ext/RMagick/rmfill.c

@@ -1,4 +1,4 @@
-/* $Id: rmfill.c,v 1.26 2008/01/01 23:18:31 rmagick Exp $ */
+/* $Id: rmfill.c,v 1.29 2008/05/28 22:40:15 rmagick Exp $ */
 /*============================================================================\
 |                Copyright (C) 2008 by Timothy P. Hunter
 | Name:     rmfill.c
@@ -131,20 +131,10 @@ vertical_fill(
 {
     double steps;
     unsigned long x, y;
-    volatile PixelPacket *master;
+    PixelPacket *master;
     MagickRealType red_step, green_step, blue_step;
 
-    // Keep in mind that x1 could be < 0 or > image->columns. If steps
-    // is negative, swap the start and end colors and use the absolute
-    // value.
     steps = FMAX(x1, ((long)image->columns)-x1);
-    if (steps < 0)
-    {
-        PixelPacket t = *start_color;
-        *start_color = *stop_color;
-        *stop_color = t;
-        steps = -steps;
-    }
 
     // If x is to the left of the x-axis, add that many steps so that
     // the color at the right side will be that many steps away from
@@ -181,14 +171,14 @@ vertical_fill(
             rm_check_image_exception(image, RetainOnError);
         }
 
-        memcpy(row_pixels, (PixelPacket *)master, image->columns * sizeof(PixelPacket));
+        memcpy(row_pixels, master, image->columns * sizeof(PixelPacket));
         if (!SyncImagePixels(image))
         {
             rm_check_image_exception(image, RetainOnError);
         }
     }
 
-    xfree((PixelPacket *)master);
+    xfree((void *)master);
 }
 
 /*
@@ -204,19 +194,10 @@ horizontal_fill(
 {
     double steps;
     unsigned long x, y;
-    volatile PixelPacket *master;
+    PixelPacket *master;
     MagickRealType red_step, green_step, blue_step;
 
-    // Bear in mind that y1 could be < 0 or > image->rows. If steps is
-    // negative, swap the start and end colors and use the absolute value.
     steps = FMAX(y1, ((long)image->rows)-y1);
-    if (steps < 0)
-    {
-        PixelPacket t = *start_color;
-        *start_color = *stop_color;
-        *stop_color = t;
-        steps = -steps;
-    }
 
     // If the line is below the y-axis, add that many steps so the color
     // at the bottom of the image is that many steps away from the stop color
@@ -231,7 +212,7 @@ horizontal_fill(
 
     // All the columns are the same, so make a master column and copy it to
     // each of the "real" columns.
-    master = ALLOC_N(volatile PixelPacket, image->rows);
+    master = ALLOC_N(PixelPacket, image->rows);
 
     for (y = 0; y < image->rows; y++)
     {
@@ -250,7 +231,7 @@ horizontal_fill(
         {
             rm_check_image_exception(image, RetainOnError);
         }
-        memcpy(col_pixels, (PixelPacket *)master, image->rows * sizeof(PixelPacket));
+        memcpy(col_pixels, master, image->rows * sizeof(PixelPacket));
         if (!SyncImagePixels(image))
         {
             rm_check_image_exception(image, RetainOnError);
@@ -452,8 +433,7 @@ GradientFill_fill(VALUE self, VALUE image_obj)
             point_fill(image, x1, y1, &start_color, &stop_color);
         }
 
-        // A vertical line is a special case. (Yes, really do pass x1
-        // as both the 2nd and 4th arguments!)
+        // A vertical line is a special case.
         else
         {
             vertical_fill(image, x1, &start_color, &stop_color);
@@ -463,7 +443,6 @@ GradientFill_fill(VALUE self, VALUE image_obj)
     // A horizontal line is a special case.
     else if (fabs(y2-y1) < 0.5)
     {
-        // Pass y1 as both the 3rd and 5th arguments!
         horizontal_fill(image, y1, &start_color, &stop_color);
     }
 

data/ext/RMagick/rmilist.c

@@ -1,4 +1,4 @@
-/* $Id: rmilist.c,v 1.69 2008/01/03 15:32:00 rmagick Exp $ */
+/* $Id: rmilist.c,v 1.71 2008/05/21 22:32:40 rmagick Exp $ */
 /*============================================================================\
 |                Copyright (C) 2008 by Timothy P. Hunter
 | Name:     rmilist.c
@@ -611,7 +611,7 @@ ImageList_optimize_layers(VALUE self, VALUE method)
     Notes:      this simply calls ImageList.new() in RMagick.rb
 */
 static VALUE
-ImageList_new()
+ImageList_new(void)
 {
     return rb_funcall(Class_ImageList, rm_ID_new, 0);
 }
@@ -799,7 +799,7 @@ ImageList_quantize(int argc, VALUE *argv, VALUE self)
     // Create new ImageList object, convert mapped image sequence to images,
     // append to images array.
     new_imagelist = ImageList_new();
-    while ((new_image = ShiftImageList(&new_images)))
+    while ((new_image = RemoveFirstImageFromList(&new_images)))
     {
         imagelist_push(new_imagelist, rm_image_new(new_image));
     }

data/ext/RMagick/rmimage.c

@@ -1,4 +1,4 @@
-/* $Id: rmimage.c,v 1.288 2008/03/23 15:15:46 rmagick Exp $ */
+/* $Id: rmimage.c,v 1.295 2008/06/02 22:47:37 rmagick Exp $ */
 /*============================================================================\
 |                Copyright (C) 2008 by Timothy P. Hunter
 | Name:     rmimage.c
@@ -26,7 +26,7 @@ static VALUE scale(int, int, VALUE *, VALUE, scaler_t);
 static VALUE threshold_image(int, VALUE *, VALUE, thresholder_t);
 static VALUE xform_image(int, VALUE, VALUE, VALUE, VALUE, VALUE, xformer_t);
 static VALUE array_from_images(Image *);
-static void call_trace_proc(Image *, char *);
+static void call_trace_proc(Image *, const char *);
 
 static const char *BlackPointCompensationKey = "PROFILE:black-point-compensation";
 
@@ -146,7 +146,7 @@ Image_adaptive_blur_channel(int argc, VALUE *argv, VALUE self)
 
 
 /*
-    Method:     Image#adaptive_resize(scale)
+    Method:     Image#adaptive_resize(scale_val)
                 Image#adaptive_resize(cols, rows)
     Purpose:    Call AdaptiveResizeImage
 */
@@ -155,7 +155,7 @@ Image_adaptive_resize(int argc, VALUE *argv, VALUE self)
 {
     Image *image, *new_image;
     unsigned long rows, columns;
-    double scale, drows, dcols;
+    double scale_val, drows, dcols;
     ExceptionInfo exception;
 
     image = rm_check_destroyed(self);
@@ -167,13 +167,13 @@ Image_adaptive_resize(int argc, VALUE *argv, VALUE self)
             columns = NUM2ULONG(argv[0]);
             break;
         case 1:
-            scale = NUM2DBL(argv[0]);
-            if (scale < 0.0)
+            scale_val = NUM2DBL(argv[0]);
+            if (scale_val < 0.0)
             {
-                rb_raise(rb_eArgError, "invalid scale value (%g given)", scale);
+                rb_raise(rb_eArgError, "invalid scale_val value (%g given)", scale_val);
             }
-            drows = scale * image->rows + 0.5;
-            dcols = scale * image->columns + 0.5;
+            drows = scale_val * image->rows + 0.5;
+            dcols = scale_val * image->columns + 0.5;
             if (drows > (double)ULONG_MAX || dcols > (double)ULONG_MAX)
             {
                 rb_raise(rb_eRangeError, "resized image too big");
@@ -360,8 +360,15 @@ Image_add_profile(VALUE self, VALUE name)
     {
         rb_raise(rb_eNoMemError, "not enough memory to continue");
     }
-    info->client_data= (void *)GetImageProfile(image,"8bim");
-
+#if defined(HAVE_ST_PROFILE)
+    profile = GetImageProfile(image, "iptc");
+    if (profile)
+    {
+        info->profile = (void *)CloneStringInfo(profile);
+    }
+#else
+    info->client_data = GetImageProfile(image, "8bim");
+#endif
     strncpy(info->filename, profile_filename, min((size_t)profile_filename_l, sizeof(info->filename)));
     info->filename[MaxTextExtent-1] = '\0';
 
@@ -379,7 +386,8 @@ Image_add_profile(VALUE self, VALUE name)
         profile = GetImageProfile(profile_image, profile_name);
         if (profile)
         {
-            (void)ProfileImage(image, profile_name, profile->datum, (unsigned long)profile->length, MagickFalse);
+            (void)ProfileImage(image, profile_name, GetStringInfoDatum(profile)
+                             , GetStringInfoLength(profile), MagickFalse);
             if (image->exception.severity >= ErrorException)
             {
                 break;
@@ -602,13 +610,13 @@ Image_aref(VALUE self, VALUE key_arg)
     Returns:    self
     Notes:      Specify attr=nil to remove the key from the list.
 
-                SetImageAttribute normally APPENDS the new value
+                SetImageProperty normally APPENDS the new value
                 to any existing value. Since this usage is tremendously
                 counter-intuitive, this function always deletes the
                 existing value before setting the new value.
 
                 There's no use checking the return value since
-                SetImageAttribute returns "False" for many reasons,
+                SetImageProperty returns "False" for many reasons,
                 some legitimate.
 */
 VALUE
@@ -642,7 +650,7 @@ Image_aset(VALUE self, VALUE key_arg, VALUE attr_arg)
     }
 
 
-    // Delete existing value. SetImageAttribute returns False if
+    // Delete existing value. SetImageProperty returns False if
     // the attribute doesn't exist - we don't care.
     (void) rm_set_property(image, key, NULL);
     // Set new value
@@ -651,7 +659,7 @@ Image_aset(VALUE self, VALUE key_arg, VALUE attr_arg)
         okay = rm_set_property(image, key, attr);
         if (!okay)
         {
-            rb_warning("SetImageAttribute failed (probably out of memory)");
+            rb_warning("SetImageProperty failed (probably out of memory)");
         }
     }
     return self;
@@ -924,7 +932,7 @@ VALUE
 Image_black_point_compensation_eq(VALUE self, VALUE arg)
 {
     Image *image;
-    char *value;
+    const char *value;
 
     image = rm_check_frozen(self);
     (void) rm_set_property(image, BlackPointCompensationKey, NULL);
@@ -960,7 +968,7 @@ get_relative_offsets(
                     long *x_offset,
                     long *y_offset)
 {
-    MagickEnum *magick_enum;
+    MagickEnum *m_enum;
     GravityType gravity;
 
     VALUE_TO_ENUM(grav, gravity, GravityType);
@@ -999,8 +1007,8 @@ get_relative_offsets(
             // Don't let these run into the default case
             break;
         default:
-            Data_Get_Struct(grav, MagickEnum, magick_enum);
-            rb_warning("gravity type `%s' has no effect", rb_id2name(magick_enum->id));
+            Data_Get_Struct(grav, MagickEnum, m_enum);
+            rb_warning("gravity type `%s' has no effect", rb_id2name(m_enum->id));
             break;
     }
 
@@ -2067,7 +2075,32 @@ Image_color_flood_fill(
 
     new_image = rm_clone_image(image);
 
+#if defined(HAVE_FLOODFILLPAINTIMAGE)
+    {
+    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;
+    }
+
+    (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);
+#endif
     // No need to check for error
 
     (void) DestroyDrawInfo(draw_info);
@@ -2141,7 +2174,7 @@ VALUE
 Image_colormap(int argc, VALUE *argv, VALUE self)
 {
     Image *image;
-    unsigned long index;
+    unsigned long idx;
     PixelPacket color, new_color;
 
     image = rm_check_destroyed(self);
@@ -2152,8 +2185,8 @@ Image_colormap(int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc);
     }
 
-    index = NUM2ULONG(argv[0]);
-    if (index > QuantumRange)
+    idx = NUM2ULONG(argv[0]);
+    if (idx > QuantumRange)
     {
         rb_raise(rb_eIndexError, "index out of range");
     }
@@ -2167,11 +2200,11 @@ Image_colormap(int argc, VALUE *argv, VALUE self)
         }
         // Validate the index
 
-        if (index > image->colors-1)
+        if (idx > image->colors-1)
         {
             rb_raise(rb_eIndexError, "index out of range");
         }
-        return PixelPacket_to_Color_Name(image, &image->colormap[index]);
+        return PixelPacket_to_Color_Name(image, &image->colormap[idx]);
     }
 
     // This is a "set" operation. Things are different.
@@ -2183,7 +2216,7 @@ Image_colormap(int argc, VALUE *argv, VALUE self)
     Color_to_PixelPacket(&new_color, argv[1]);
 
     // Handle no colormap or current colormap too small.
-    if (!image->colormap || index > image->colors-1)
+    if (!image->colormap || idx > image->colors-1)
     {
         PixelPacket black;
         unsigned long i;
@@ -2192,24 +2225,24 @@ Image_colormap(int argc, VALUE *argv, VALUE self)
 
         if (!image->colormap)
         {
-            image->colormap = (PixelPacket *)magick_safe_malloc((index+1), sizeof(PixelPacket));
+            image->colormap = (PixelPacket *)magick_safe_malloc((idx+1), sizeof(PixelPacket));
             image->colors = 0;
         }
         else
         {
-            image->colormap = (PixelPacket *)magick_safe_realloc(image->colormap, (index+1), sizeof(PixelPacket));
+            image->colormap = (PixelPacket *)magick_safe_realloc(image->colormap, (idx+1), sizeof(PixelPacket));
         }
 
-        for (i = image->colors; i < index; i++)
+        for (i = image->colors; i < idx; i++)
         {
             image->colormap[i] = black;
         }
-        image->colors = index+1;
+        image->colors = idx+1;
     }
 
     // Save the current color so we can return it. Set the new color.
-    color = image->colormap[index];
-    image->colormap[index] = new_color;
+    color = image->colormap[idx];
+    image->colormap[idx] = new_color;
 
     return PixelPacket_to_Color_Name(image, &color);
 }
@@ -2439,7 +2472,7 @@ static VALUE composite(
     Image *comp_image;
     CompositeOperator operator = UndefinedCompositeOp;
     GravityType gravity;
-    MagickEnum *magick_enum;
+    MagickEnum *m_enum;
     volatile VALUE comp;
     signed long x_offset = 0;
     signed long y_offset = 0;
@@ -2557,8 +2590,8 @@ static VALUE composite(
                     // Don't let these run into the default case
                     break;
                 default:
-                    Data_Get_Struct(argv[1], MagickEnum, magick_enum);
-                    rb_warning("gravity type `%s' has no effect", rb_id2name(magick_enum->id));
+                    Data_Get_Struct(argv[1], MagickEnum, m_enum);
+                    rb_warning("gravity type `%s' has no effect", rb_id2name(m_enum->id));
                     break;
             }
             break;
@@ -2613,15 +2646,15 @@ Image_composite_affine(
                       VALUE source,
                       VALUE affine_matrix)
 {
-    Image *image, *composite, *new_image;
+    Image *image, *composite_image, *new_image;
     AffineMatrix affine;
 
     image = rm_check_destroyed(self);
-    composite = rm_check_destroyed(source);
+    composite_image = rm_check_destroyed(source);
     new_image = rm_clone_image(image);
 
     AffineMatrix_to_AffineMatrix(&affine, affine_matrix);
-    (void) DrawAffineImage(new_image, composite, &affine);
+    (void) DrawAffineImage(new_image, composite_image, &affine);
     rm_check_image_exception(new_image, DestroyOnError);
 
     return rm_image_new(new_image);
@@ -2730,11 +2763,11 @@ Image_constitute(VALUE class, VALUE width_arg, VALUE height_arg
     long x, npixels;
     char *map;
     long map_l;
-    union
+    volatile union
     {
-        volatile double *f;
-        volatile Quantum *i;
-        volatile void *v;
+        double *f;
+        Quantum *i;
+        void *v;
     } pixels;
     volatile VALUE pixel_class;
     StorageType stg_type;
@@ -2767,13 +2800,13 @@ Image_constitute(VALUE class, VALUE width_arg, VALUE height_arg
     pixel0 = rb_ary_entry(pixels_arg, 0);
     if (rb_obj_is_kind_of(pixel0, rb_cFloat) == Qtrue)
     {
-        pixels.f = ALLOC_N(volatile double, npixels);
+        pixels.f = ALLOC_N(double, npixels);
         stg_type = DoublePixel;
         pixel_class = rb_cFloat;
     }
     else if (rb_obj_is_kind_of(pixel0, rb_cInteger) == Qtrue)
     {
-        pixels.i = ALLOC_N(volatile Quantum, npixels);
+        pixels.i = ALLOC_N(Quantum, npixels);
         stg_type = QuantumPixel;
         pixel_class = rb_cInteger;
     }
@@ -2824,8 +2857,8 @@ Image_constitute(VALUE class, VALUE width_arg, VALUE height_arg
     (void) SetImageBackgroundColor(image);
     rm_check_image_exception(image, DestroyOnError);
 
-    (void) ImportImagePixels(image, 0, 0, width, height, map, stg_type, (void *)pixels.v);
-    xfree((void *)pixels.v);
+    (void) ImportImagePixels(image, 0, 0, width, height, map, stg_type, (const void *)pixels.v);
+    xfree(pixels.v);
     rm_check_image_exception(image, DestroyOnError);
 
     (void) DestroyExceptionInfo(&exception);
@@ -2969,7 +3002,7 @@ Image_convolve(
               VALUE kernel_arg)
 {
     Image *image, *new_image;
-    volatile double *kernel;
+    double *kernel;
     unsigned int x, order;
     ExceptionInfo exception;
 
@@ -2982,7 +3015,7 @@ Image_convolve(
 
     // Convert the kernel array argument to an array of doubles
 
-    kernel = (volatile double *)ALLOC_N(double, order*order);
+    kernel = (double *)ALLOC_N(double, order*order);
     for (x = 0; x < order*order; x++)
     {
         kernel[x] = NUM2DBL(rb_ary_entry(kernel_arg, (long)x));
@@ -2990,8 +3023,8 @@ Image_convolve(
 
     GetExceptionInfo(&exception);
 
-    new_image = ConvolveImage(image, order, (double *)kernel, &exception);
-    xfree((double *)kernel);
+    new_image = ConvolveImage((const Image *)image, order, (double *)kernel, &exception);
+    xfree((void *)kernel);
     rm_check_exception(&exception, new_image, DestroyOnError);
 
     (void) DestroyExceptionInfo(&exception);
@@ -3013,7 +3046,7 @@ Image_convolve_channel(
                       VALUE self)
 {
     Image *image, *new_image;
-    volatile double *kernel;
+    double *kernel;
     volatile VALUE ary;
     unsigned int x, order;
     ChannelType channels;
@@ -3048,8 +3081,8 @@ Image_convolve_channel(
 
     GetExceptionInfo(&exception);
 
-    new_image = ConvolveImageChannel(image, channels, order, (double *)kernel, &exception);
-    xfree((double *)kernel);
+    new_image = ConvolveImageChannel(image, channels, order, kernel, &exception);
+    xfree((void *)kernel);
     rm_check_exception(&exception, new_image, DestroyOnError);
 
     (void) DestroyExceptionInfo(&exception);
@@ -3459,11 +3492,11 @@ Image_dispatch(int argc, VALUE *argv, VALUE self)
     long mapL;
     MagickBooleanType okay;
     ExceptionInfo exception;
-    union
+    volatile union
     {
-        volatile Quantum *i;
-        volatile double *f;
-        volatile void *v;
+        Quantum *i;
+        double *f;
+        void *v;
     } pixels;
 
     (void) rm_check_destroyed(self);
@@ -3579,7 +3612,7 @@ Image_dispose_eq(VALUE self, VALUE dispose)
 /*
     Method:     Image#dissolve(overlay, src_percent, dst_percent, x_offset=0, y_offset=0)
                 Image#dissolve(overlay, src_percent, dst_percent, gravity, x_offset=0, y_offset=0)
-    Purpose:    Corresponds to the composite -dissolve operation
+    Purpose:    Corresponds to the composite_image -dissolve operation
     Notes:      `percent' can be a number or a string in the form "NN%"
                 The "default" value of dst_percent is -1.0, which tells
                 blend_geometry to leave it out of the geometry string.
@@ -3590,7 +3623,7 @@ Image_dissolve(int argc, VALUE *argv, VALUE self)
     Image *image, *overlay;
     double src_percent, dst_percent = -1.0;
     long x_offset = 0L, y_offset = 0L;
-    volatile VALUE composite, ovly;
+    volatile VALUE composite_image, ovly;
 
     image = rm_check_destroyed(self);
 
@@ -3621,10 +3654,10 @@ Image_dissolve(int argc, VALUE *argv, VALUE self)
             break;
     }
 
-    composite =  special_composite(image, overlay, src_percent, dst_percent
-                                   , x_offset, y_offset, DissolveCompositeOp);
+    composite_image =  special_composite(image, overlay, src_percent, dst_percent
+                                       , x_offset, y_offset, DissolveCompositeOp);
 
-    return composite;
+    return composite_image;
 }
 
 
@@ -4174,8 +4207,8 @@ Image_export_pixels(int argc, VALUE *argv, VALUE self)
     unsigned long cols, rows;
     long n, npixels;
     unsigned int okay;
-    char *map = "RGB";
-    volatile Quantum *pixels;
+    const char *map = "RGB";
+    Quantum *pixels;
     volatile VALUE ary;
     ExceptionInfo exception;
 
@@ -4223,7 +4256,7 @@ Image_export_pixels(int argc, VALUE *argv, VALUE self)
     okay = ExportImagePixels(image, x_off, y_off, cols, rows, map, QuantumPixel, (void *)pixels, &exception);
     if (!okay)
     {
-        xfree((unsigned int *)pixels);
+        xfree((void *)pixels);
         CHECK_EXCEPTION()
 
         // Should never get here...
@@ -4238,7 +4271,7 @@ Image_export_pixels(int argc, VALUE *argv, VALUE self)
         (void) rb_ary_push(ary, QUANTUM2NUM(pixels[n]));
     }
 
-    xfree((unsigned int *)pixels);
+    xfree((void *)pixels);
 
     return ary;
 }
@@ -4324,7 +4357,7 @@ Image_export_pixels_to_str(int argc, VALUE *argv, VALUE self)
     unsigned long npixels;
     size_t sz;
     unsigned int okay;
-    char *map = "RGB";
+    const char *map = "RGB";
     StorageType type = CharPixel;
     volatile VALUE string;
     char *str;
@@ -4827,7 +4860,7 @@ Image_gamma_correct(int argc, VALUE *argv, VALUE self)
 {
     Image *image, *new_image;
     double red_gamma, green_gamma, blue_gamma;
-    char gamma[50];
+    char gamma_arg[50];
 
     image = rm_check_destroyed(self);
     switch (argc)
@@ -4859,11 +4892,11 @@ Image_gamma_correct(int argc, VALUE *argv, VALUE self)
             break;
     }
 
-    sprintf(gamma, "%f,%f,%f", red_gamma, green_gamma, blue_gamma);
+    sprintf(gamma_arg, "%f,%f,%f", red_gamma, green_gamma, blue_gamma);
 
     new_image = rm_clone_image(image);
 
-    (void) GammaImage(new_image, gamma);
+    (void) GammaImage(new_image, gamma_arg);
     rm_check_image_exception(new_image, DestroyOnError);
 
     return rm_image_new(new_image);
@@ -4976,7 +5009,7 @@ Image_get_pixels(
                 VALUE rows_arg)
 {
     Image *image;
-    PixelPacket *pixels;
+    const PixelPacket *pixels;
     ExceptionInfo exception;
     long x, y;
     unsigned long columns, rows;
@@ -4998,7 +5031,7 @@ Image_get_pixels(
     // Cast AcquireImagePixels to get rid of the const qualifier. We're not going
     // to change the pixels but I don't want to make "pixels" const.
     GetExceptionInfo(&exception);
-    pixels = (PixelPacket *)AcquireImagePixels(image, x, y, columns, rows, &exception);
+    pixels = AcquireImagePixels(image, x, y, columns, rows, &exception);
     CHECK_EXCEPTION()
 
     (void) DestroyExceptionInfo(&exception);
@@ -5120,9 +5153,9 @@ Image_import_pixels(int argc, VALUE *argv, VALUE self)
     volatile VALUE pixel_arg, pixel_ary;
     StorageType stg_type = CharPixel;
     size_t type_sz, map_l;
-    volatile Quantum *pixels = NULL;
-    volatile double *fpixels = NULL;
-    volatile void *buffer;
+    Quantum *pixels = NULL;
+    double *fpixels = NULL;
+    void *buffer;
     unsigned int okay;
 
     image = rm_check_frozen(self);
@@ -5245,7 +5278,7 @@ Image_import_pixels(int argc, VALUE *argv, VALUE self)
     }
 
 
-    okay = ImportImagePixels(image, x_off, y_off, cols, rows, map, stg_type, (const void *)buffer);
+    okay = ImportImagePixels(image, x_off, y_off, cols, rows, map, stg_type, buffer);
 
     // Free pixel array before checking for errors.
     if (pixels)
@@ -5272,7 +5305,7 @@ Image_import_pixels(int argc, VALUE *argv, VALUE self)
     Purpose:    Overrides Object#inspect - returns a string description of the
                 image.
     Returns:    the string
-    Notes:      this is essentially the DescribeImage except the description is
+    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)
@@ -5363,19 +5396,19 @@ static void build_inspect_string(Image *image, char *buffer, size_t len)
     x += sprintf(buffer+x, "%lu-bit", quantum_depth);
 
     // Print blob info if appropriate.
-    if (SizeBlob(image) != 0)
+    if (GetBlobSize(image) != 0)
     {
-        if (SizeBlob(image) >= (1 << 24))
+        if (GetBlobSize(image) >= (1 << 24))
         {
-            x += sprintf(buffer+x, " %lumb", (unsigned long) (SizeBlob(image)/1024/1024));
+            x += sprintf(buffer+x, " %lumb", (unsigned long) (GetBlobSize(image)/1024/1024));
         }
-        else if (SizeBlob(image) >= 1024)
+        else if (GetBlobSize(image) >= 1024)
         {
-            x += sprintf(buffer+x, " %lukb", (unsigned long) (SizeBlob(image)/1024));
+            x += sprintf(buffer+x, " %lukb", (unsigned long) (GetBlobSize(image)/1024));
         }
         else
         {
-            x += sprintf(buffer+x, " %lub", (unsigned long) SizeBlob(image));
+            x += sprintf(buffer+x, " %lub", (unsigned long) GetBlobSize(image));
         }
     }
 
@@ -5484,7 +5517,7 @@ VALUE
 Image_level2(int argc, VALUE *argv, VALUE self)
 {
     Image *image, *new_image;
-    double black_point = 0.0, gamma = 1.0, white_point = (double)QuantumRange;
+    double black_point = 0.0, gamma_val = 1.0, white_point = (double)QuantumRange;
     char level[50];
 
     image = rm_check_destroyed(self);
@@ -5503,7 +5536,7 @@ Image_level2(int argc, VALUE *argv, VALUE self)
         case 3:
             black_point = NUM2DBL(argv[0]);
             white_point = NUM2DBL(argv[1]);
-            gamma       = NUM2DBL(argv[2]);
+            gamma_val   = NUM2DBL(argv[2]);
             break;
         default:
             rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 to 3)", argc);
@@ -5512,7 +5545,7 @@ Image_level2(int argc, VALUE *argv, VALUE self)
 
     new_image = rm_clone_image(image);
 
-    sprintf(level, "%gx%g+%g", black_point, white_point, gamma);
+    sprintf(level, "%gx%g+%g", black_point, white_point, gamma_val);
     (void) LevelImage(new_image, level);
     rm_check_image_exception(new_image, DestroyOnError);
 
@@ -5528,7 +5561,7 @@ VALUE
 Image_level_channel(int argc, VALUE *argv, VALUE self)
 {
     Image *image, *new_image;
-    double black_point = 0.0, gamma = 1.0, white_point = (double)QuantumRange;
+    double black_point = 0.0, gamma_val = 1.0, white_point = (double)QuantumRange;
     ChannelType channel;
 
     image = rm_check_destroyed(self);
@@ -5547,7 +5580,7 @@ Image_level_channel(int argc, VALUE *argv, VALUE self)
         case 4:
             black_point = NUM2DBL(argv[1]);
             white_point = NUM2DBL(argv[2]);
-            gamma       = NUM2DBL(argv[3]);
+            gamma_val   = NUM2DBL(argv[3]);
             break;
         default:
             rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 to 4)", argc);
@@ -5558,7 +5591,7 @@ Image_level_channel(int argc, VALUE *argv, VALUE self)
 
     new_image = rm_clone_image(image);
 
-    (void) LevelImageChannel(new_image, channel, black_point, white_point, gamma);
+    (void) LevelImageChannel(new_image, channel, black_point, white_point, gamma_val);
     rm_check_image_exception(new_image, DestroyOnError);
 
     return rm_image_new(new_image);
@@ -6009,7 +6042,7 @@ Image_matte_color_eq(VALUE self, VALUE color)
 }
 
 /*
-    Method:     Image#matte_flood_fill(color, opacity, x, y, method)
+    Method:     Image#matte_flood_fill(color, opacity, x, y, method_obj)
     Purpose:    Call MatteFloodFillImage
 */
 VALUE
@@ -6019,24 +6052,24 @@ Image_matte_flood_fill(
                       VALUE opacity,
                       VALUE x_obj,
                       VALUE y_obj,
-                      VALUE method)
+                      VALUE method_obj)
 {
     Image *image, *new_image;
     PixelPacket target;
     Quantum op;
     long x, y;
-    PaintMethod pm;
+    PaintMethod method;
 
     image = rm_check_destroyed(self);
     Color_to_PixelPacket(&target, color);
 
     op = APP2QUANTUM(opacity);
 
-    VALUE_TO_ENUM(method, pm, PaintMethod);
-    if (!(pm == FloodfillMethod || pm == FillToBorderMethod))
+    VALUE_TO_ENUM(method_obj, method, PaintMethod);
+    if (!(method == FloodfillMethod || method == FillToBorderMethod))
     {
-        rb_raise(rb_eArgError, "paint method must be FloodfillMethod or "
-                 "FillToBorderMethod (%d given)", pm);
+        rb_raise(rb_eArgError, "paint method_obj must be FloodfillMethod or "
+                 "FillToBorderMethod (%d given)", method);
     }
     x = NUM2LONG(x_obj);
     y = NUM2LONG(y_obj);
@@ -6049,7 +6082,40 @@ Image_matte_flood_fill(
 
     new_image = rm_clone_image(image);
 
-    (void) MatteFloodfillImage(new_image, target, op, x, y, pm);
+#if defined(HAVE_FLOODFILLPAINTIMAGE)
+    {
+    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;
+
+    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);
+    }
+#else
+    (void) MatteFloodfillImage(new_image, target, op, x, y, method);
+#endif
     rm_check_image_exception(new_image, DestroyOnError);
 
     return rm_image_new(new_image);
@@ -6429,9 +6495,9 @@ Image_initialize(int argc, VALUE *argv, VALUE self)
 
     SetImageExtent(image, cols, rows);
 
-    // If the caller did not supply a fill argument, call SetImage to fill the
-    // image using the background color. The background color can be set by
-    // specifying it when creating the Info parm block.
+    // If the caller did not supply a fill argument, call SetImageBackgroundColor
+    // to fill the image using the background color. The background color can
+    // be set by specifying it when creating the Info parm block.
     if (!fill)
     {
         (void) SetImageBackgroundColor(image);
@@ -6853,7 +6919,7 @@ Image_paint_transparent(int argc, VALUE *argv, VALUE self)
     keep = new_image->fuzz;
     new_image->fuzz = fuzz;
 
-    okay = TransparentPaintImage(new_image, &color, opacity, invert);
+    okay = TransparentPaintImage(new_image, (const MagickPixelPacket *)&color, opacity, invert);
     new_image->fuzz = keep;
 
     // Is it possible for TransparentPaintImage to silently fail?
@@ -7759,7 +7825,7 @@ static VALUE
 resize(int bang, int argc, VALUE *argv, VALUE self)
 {
     Image *image, *new_image;
-    double scale;
+    double scale_arg;
     FilterTypes filter;
     unsigned long rows, columns;
     double blur, drows, dcols;
@@ -7788,13 +7854,13 @@ resize(int bang, int argc, VALUE *argv, VALUE self)
             }
             break;
         case 1:
-            scale = NUM2DBL(argv[0]);
-            if (scale < 0.0)
+            scale_arg = NUM2DBL(argv[0]);
+            if (scale_arg < 0.0)
             {
-                rb_raise(rb_eArgError, "invalid scale value (%g given)", scale);
+                rb_raise(rb_eArgError, "invalid scale_arg value (%g given)", scale_arg);
             }
-            drows = scale * image->rows + 0.5;
-            dcols = scale * image->columns + 0.5;
+            drows = scale_arg * image->rows + 0.5;
+            dcols = scale_arg * image->columns + 0.5;
             if (drows > (double)ULONG_MAX || dcols > (double)ULONG_MAX)
             {
                 rb_raise(rb_eRangeError, "resized image too big");
@@ -7993,7 +8059,7 @@ scale(int bang, int argc, VALUE *argv, VALUE self, scaler_t scaler)
 {
     Image *image, *new_image;
     unsigned long columns, rows;
-    double scale, drows, dcols;
+    double scale_arg, drows, dcols;
     ExceptionInfo exception;
 
     Data_Get_Struct(self, Image, image);
@@ -8009,13 +8075,13 @@ scale(int bang, int argc, VALUE *argv, VALUE self, scaler_t scaler)
             }
             break;
         case 1:
-            scale = NUM2DBL(argv[0]);
-            if (scale <= 0)
+            scale_arg = NUM2DBL(argv[0]);
+            if (scale_arg <= 0)
             {
-                rb_raise(rb_eArgError, "invalid scale value (%g given)", scale);
+                rb_raise(rb_eArgError, "invalid scale value (%g given)", scale_arg);
             }
-            drows = scale * image->rows + 0.5;
-            dcols = scale * image->columns + 0.5;
+            drows = scale_arg * image->rows + 0.5;
+            dcols = scale_arg * image->columns + 0.5;
             if (drows > (double)ULONG_MAX || dcols > (double)ULONG_MAX)
             {
                 rb_raise(rb_eRangeError, "resized image too big");
@@ -8723,14 +8789,14 @@ VALUE
 Image_spread(int argc, VALUE *argv, VALUE self)
 {
     Image *image, *new_image;
-    unsigned int radius = 3;
+    double radius = 3.0;
     ExceptionInfo exception;
 
     image = rm_check_destroyed(self);
     switch (argc)
     {
         case 1:
-            radius = NUM2UINT(argv[0]);
+            radius = NUM2DBL(argv[0]);
         case 0:
             break;
         default:
@@ -9059,16 +9125,34 @@ Image_texture_flood_fill(
     draw_info->fill_pattern = rm_clone_image(texture_image);
     new_image = rm_clone_image(image);
 
-    // Hack: By-pass bug in ColorFloodfillImage that tests
-    // the fill color even though the fill color isn't used.
+
+#if defined(HAVE_FLOODFILLPAINTIMAGE)
+    {
+    MagickPixelPacket color_mpp;
+    MagickBooleanType invert;
+
+    GetMagickPixelPacket(new_image, &color_mpp);
     if (method == FillToBorderMethod)
     {
-        draw_info->fill.red = ROUND_TO_QUANTUM(color.red + new_image->fuzz + 1);
-        draw_info->fill.green = color.green;
-        draw_info->fill.blue = color.blue;
+        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);
+    }
+
+#else
     (void) ColorFloodfillImage(new_image, draw_info, color, x, y, method);
+#endif
 
     (void) DestroyDrawInfo(draw_info);
     rm_check_image_exception(new_image, DestroyOnError);
@@ -9164,7 +9248,7 @@ thumbnail(int bang, int argc, VALUE *argv, VALUE self)
 {
     Image *image, *new_image;
     unsigned long columns, rows;
-    double scale, drows, dcols;
+    double scale_arg, drows, dcols;
     ExceptionInfo exception;
 
     Data_Get_Struct(self, Image, image);
@@ -9180,13 +9264,13 @@ thumbnail(int bang, int argc, VALUE *argv, VALUE self)
             }
             break;
         case 1:
-            scale = NUM2DBL(argv[0]);
-            if (scale < 0.0)
+            scale_arg = NUM2DBL(argv[0]);
+            if (scale_arg < 0.0)
             {
-                rb_raise(rb_eArgError, "invalid scale value (%g given)", scale);
+                rb_raise(rb_eArgError, "invalid scale value (%g given)", scale_arg);
             }
-            drows = scale * image->rows + 0.5;
-            dcols = scale * image->columns + 0.5;
+            drows = scale_arg * image->rows + 0.5;
+            dcols = scale_arg * image->columns + 0.5;
             if (drows > (double)ULONG_MAX || dcols > (double)ULONG_MAX)
             {
                 rb_raise(rb_eRangeError, "resized image too big");
@@ -9450,7 +9534,7 @@ Image_total_colors(VALUE self)
 /*
     Method:     Image#transparent(color-name<, opacity>)
                 Image#transparent(pixel<, opacity>)
-    Purpose:    Call TransparentImage
+    Purpose:    Call TransparentPaintImage
     Notes:      Can use Magick::OpaqueOpacity or Magick::TransparentOpacity,
                 or any value >= 0 && <= QuantumRange. The default is
                 Magick::TransparentOpacity.
@@ -9573,7 +9657,6 @@ static VALUE
 trimmer(int bang, int argc, VALUE *argv, VALUE self)
 {
     Image *image, *new_image;
-    RectangleInfo geometry;
     ExceptionInfo exception;
     int reset_page = 0;
 
@@ -9591,11 +9674,7 @@ trimmer(int bang, int argc, VALUE *argv, VALUE self)
     Data_Get_Struct(self, Image, image);
 
     GetExceptionInfo(&exception);
-
-    geometry = GetImageBoundingBox(image, &exception);
-    CHECK_EXCEPTION()
-
-    new_image = CropImage(image, &geometry, &exception);
+    new_image = TrimImage(image, &exception);
     rm_check_exception(&exception, new_image, DestroyOnError);
 
     (void) DestroyExceptionInfo(&exception);
@@ -9658,8 +9737,8 @@ VALUE Image_gravity_eq(VALUE self, VALUE gravity)
 
 
 /*
-    Method:     Image#image_type
-    Purpose:    Call GetImageType to get the image type
+    Method:     Image#image_type, image_type=
+    Purpose:    Call GetImageType/SetImageType to get/set the image type
 */
 VALUE Image_image_type(VALUE self)
 {
@@ -9678,6 +9757,18 @@ VALUE Image_image_type(VALUE self)
 }
 
 
+VALUE Image_image_type_eq(VALUE self, VALUE image_type)
+{
+    Image *image;
+    ImageType type;
+
+    image = rm_check_frozen(self);
+    VALUE_TO_ENUM(image_type, type, ImageType);
+    SetImageType(image, type);
+    return image_type;
+}
+
+
 /*
     Method:     Image#unique_colors
     Purpose:    Call UniqueImageColors
@@ -10072,13 +10163,14 @@ VALUE
 Image_wet_floor(int argc, VALUE *argv, VALUE self)
 {
     Image *image, *reflection, *flip_image;
-    PixelPacket *p, *q;
+    const PixelPacket *p;
+    PixelPacket *q;
     RectangleInfo geometry;
     long x, y, max_rows;
     double initial = 0.5;
     double rate = 1.0;
     double opacity, step;
-    char *func;
+    const char *func;
     MagickBooleanType okay;
     ExceptionInfo exception;
 
@@ -10151,7 +10243,7 @@ Image_wet_floor(int argc, VALUE *argv, VALUE self)
             opacity = TransparentOpacity;
         }
 
-        p = (PixelPacket *)AcquireImagePixels(reflection, 0, y, image->columns, 1, &exception);
+        p = AcquireImagePixels(reflection, 0, y, image->columns, 1, &exception);
         rm_check_exception(&exception, reflection, RetainOnError);
 
         q = SetImagePixels(reflection, 0, y, image->columns, 1);
@@ -10296,7 +10388,7 @@ cropper(int bang, int argc, VALUE *argv, VALUE self)
     unsigned long columns, rows;
     int reset_page = 0;
     GravityType gravity;
-    MagickEnum *magick_enum;
+    MagickEnum *m_enum;
     Image *image;
     VALUE cropped;
 
@@ -10367,8 +10459,8 @@ cropper(int bang, int argc, VALUE *argv, VALUE self)
                     // Don't let these run into the default case
                     break;
                 default:
-                    Data_Get_Struct(argv[0], MagickEnum, magick_enum);
-                    rb_warning("gravity type `%s' has no effect", rb_id2name(magick_enum->id));
+                    Data_Get_Struct(argv[0], MagickEnum, m_enum);
+                    rb_warning("gravity type `%s' has no effect", rb_id2name(m_enum->id));
                     break;
             }
 
@@ -10575,10 +10667,10 @@ raise_ChannelType_error(VALUE arg)
     Purpose:    If Magick.trace_proc is not nil, build an argument
                 list and call the proc.
 */
-static void call_trace_proc(Image *image, char *which)
+static void call_trace_proc(Image *image, const char *which)
 {
     volatile VALUE trace;
-    volatile VALUE trace_args[4];
+    VALUE trace_args[4];
 
     if (rb_ivar_defined(Module_Magick, rm_ID_trace_proc) == Qtrue)
     {