rmagick 1.12.0 → 1.13.0

data/ext/RMagick/rmagick_config.h.in

@@ -1,6 +1,8 @@
 #undef GRAPHICSMAGICK
 /* Introduced in IM 6.0.0, GM 1.1 */
 #undef HAVE_ACQUIREMAGICKMEMORY
+/* Introduced in IM 6.2.7 */
+#undef HAVE_ADAPTIVESHARPENIMAGE
 /* Introduced in IM 6.0.0 */
 #undef HAVE_ACQUIRESTRINGINFO
 /* GraphicsMagick only */
@@ -28,6 +30,8 @@
 /* Introduced in IM 6.2.6 */
 #undef HAVE_COMPAREIMAGELAYERS
 /* Introduced in IM 6.2.6 */
+#undef HAVE_COMPOSITEIMAGECHANNEL
+/* Introduced in IM 6.2.6 */
 #undef HAVE_CONTRASTSTRETCHIMAGECHANNEL
 /* Introduced in IM 6.0.1 */
 #undef HAVE_CONVOLVEIMAGECHANNEL
@@ -152,6 +156,8 @@
 #undef HAVE_QUANTUMPIXEL
 /* Not available in GM */
 #undef HAVE_RADIALBLURIMAGE
+/* Introduced in IM 6.2.4 */
+#undef HAVE_RADIALBLURIMAGECHANNEL
 #undef HAVE_RANDOMCHANNELTHRESHOLDIMAGE
 #undef HAVE_RANDOMTHRESHOLDIMAGECHANNEL
 /* Introduced in GM 1.2 & IM 6.2.2 */
@@ -170,9 +176,15 @@
 #undef HAVE_SETIMAGECOLORSPACE
 /* Introduced in IM 6.0.0, GM 1.1 */
 #undef HAVE_SETIMAGECHANNELDEPTH
+/* Introduced in IM 6.2.4 */
+#undef HAVE_SETIMAGEEXTENT
+/* Introduced in IM 6.2.1 */
+#undef HAVE_SETIMAGEINFOFILE
 #undef HAVE_SETIMAGEOPTION
 /* Introduced in IM 6.1.0 */
 #undef HAVE_SETIMAGEPROGRESSMONITOR
+/* Introduced in IM 6.2.6 */
+#undef HAVE_SETIMAGESTORAGECLASS
 /* Introduced in IM 6.1.7 */
 #undef HAVE_SHADOWIMAGE
 /* Introduced in IM 6.0.1 */
@@ -192,6 +204,10 @@
 #undef HAVE_TINTIMAGE
 /* Introduced in IM 6.2.4 */
 #undef HAVE_TRANSPARENTVIRTUALPIXELMETHOD
+/* Introduced in IM 6.2.8 */
+#undef HAVE_TRANSPOSEIMAGE
+/* Introduced in IM 6.2.8 */
+#undef HAVE_TRANSVERSEIMAGE
 /* Introduced in IM 6.0.0 */
 #undef HAVE_UNDEFINEDGRAVITY
 #undef HAVE_UNISTD_H

data/ext/RMagick/rmfill.c

@@ -1,4 +1,4 @@
-/* $Id: rmfill.c,v 1.14 2006/05/07 23:46:19 rmagick Exp $ */
+/* $Id: rmfill.c,v 1.15 2006/06/28 23:06:15 rmagick Exp $ */
 /*============================================================================\
 |                Copyright (C) 2006 by Timothy P. Hunter
 | Name:     rmfill.c
@@ -13,12 +13,12 @@ typedef struct
     double x1, y1, x2, y2;
     PixelPacket start_color;
     PixelPacket stop_color;
-} GradientFill;
+} rm_GradientFill;
 
 typedef struct
 {
     Image *texture;
-} TextureFill;
+} rm_TextureFill;
 
 /*
     Static:     free_Fill
@@ -45,7 +45,7 @@ GradientFill_new(
     VALUE start_color,
     VALUE stop_color)
 {
-    GradientFill *fill;
+    rm_GradientFill *fill;
     volatile VALUE new_fill;
     VALUE argv[6];
 
@@ -57,7 +57,7 @@ GradientFill_new(
     argv[5] = stop_color;
 
     new_fill = Data_Make_Struct(class
-                              , GradientFill
+                              , rm_GradientFill
                               , NULL
                               , free_Fill
                               , fill);
@@ -69,9 +69,9 @@ GradientFill_new(
 VALUE
 GradientFill_alloc(VALUE class)
 {
-    GradientFill *fill;
+    rm_GradientFill *fill;
 
-    return Data_Make_Struct(class, GradientFill, NULL, free_Fill, fill);
+    return Data_Make_Struct(class, rm_GradientFill, NULL, free_Fill, fill);
 }
 #endif
 
@@ -89,9 +89,9 @@ GradientFill_initialize(
     VALUE start_color,
     VALUE stop_color)
 {
-    GradientFill *fill;
+    rm_GradientFill *fill;
 
-    Data_Get_Struct(self, GradientFill, fill);
+    Data_Get_Struct(self, rm_GradientFill, fill);
 
     fill->x1 = NUM2DBL(x1);
     fill->y1 = NUM2DBL(y1);
@@ -460,12 +460,12 @@ h_diagonal_fill(
 VALUE
 GradientFill_fill(VALUE self, VALUE image_obj)
 {
-    GradientFill *fill;
+    rm_GradientFill *fill;
     Image *image;
     PixelPacket start_color, stop_color;
     double x1, y1, x2, y2;          // points on the line
 
-    Data_Get_Struct(self, GradientFill, fill);
+    Data_Get_Struct(self, rm_GradientFill, fill);
     Data_Get_Struct(image_obj, Image, image);
 
     x1 = fill->x1;
@@ -527,7 +527,7 @@ GradientFill_fill(VALUE self, VALUE image_obj)
 static void
 free_TextureFill(void *fill_obj)
 {
-    TextureFill *fill = (TextureFill *)fill_obj;
+    rm_TextureFill *fill = (rm_TextureFill *)fill_obj;
 
     DestroyImage(fill->texture);
     xfree(fill);
@@ -542,12 +542,12 @@ free_TextureFill(void *fill_obj)
 VALUE
 TextureFill_new(VALUE class, VALUE texture)
 {
-    TextureFill *fill;
+    rm_TextureFill *fill;
     VALUE argv[1];
     volatile VALUE new_fill;
 
     new_fill = Data_Make_Struct(class
-                              , TextureFill
+                              , rm_TextureFill
                               , NULL
                               , free_TextureFill
                               , fill);
@@ -559,9 +559,9 @@ TextureFill_new(VALUE class, VALUE texture)
 VALUE
 TextureFill_alloc(VALUE class)
 {
-    TextureFill *fill;
+    rm_TextureFill *fill;
     return Data_Make_Struct(class
-                        , TextureFill
+                        , rm_TextureFill
                         , NULL
                         , free_TextureFill
                         , fill);
@@ -575,11 +575,11 @@ TextureFill_alloc(VALUE class)
 VALUE
 TextureFill_initialize(VALUE self, VALUE texture_arg)
 {
-    TextureFill *fill;
+    rm_TextureFill *fill;
     Image *texture;
     volatile VALUE texture_image;
 
-    Data_Get_Struct(self, TextureFill, fill);
+    Data_Get_Struct(self, rm_TextureFill, fill);
 
     texture_image = ImageList_cur_image(texture_arg);
 
@@ -598,11 +598,11 @@ TextureFill_initialize(VALUE self, VALUE texture_arg)
 VALUE
 TextureFill_fill(VALUE self, VALUE image_obj)
 {
-    TextureFill *fill;
+    rm_TextureFill *fill;
     Image *image;
 
     Data_Get_Struct(image_obj, Image, image);
-    Data_Get_Struct(self, TextureFill, fill);
+    Data_Get_Struct(self, rm_TextureFill, fill);
 
     TextureImage(image, fill->texture);
     rm_check_image_exception(image, RetainOnError);

data/ext/RMagick/rmilist.c

@@ -1,4 +1,4 @@
-/* $Id: rmilist.c,v 1.40 2006/05/27 21:05:59 rmagick Exp $ */
+/* $Id: rmilist.c,v 1.41 2006/06/20 23:33:07 rmagick Exp $ */
 /*============================================================================\
 |                Copyright (C) 2006 by Timothy P. Hunter
 | Name:     rmilist.c
@@ -716,7 +716,7 @@ ImageList_write(VALUE self, VALUE file)
 
         // Ensure file is open - raise error if not
         GetOpenFile(file, fptr);
-        info->file = GetReadFile(fptr);
+        SetImageInfoFile(info, GetReadFile(fptr));
     }
     else
     {
@@ -728,7 +728,7 @@ ImageList_write(VALUE self, VALUE file)
         filenameL = min(filenameL, MaxTextExtent-1);
         memcpy(info->filename, filename, (size_t)filenameL);
         info->filename[filenameL] = '\0';
-        info->file = NULL;
+        SetImageInfoFile(info, NULL);
     }
 
     // Copy the filename into each images. Set a scene number to be used if

data/ext/RMagick/rmimage.c

@@ -1,4 +1,4 @@
-/* $Id: rmimage.c,v 1.147 2006/06/02 23:26:53 rmagick Exp $ */
+/* $Id: rmimage.c,v 1.153 2006/06/28 23:07:16 rmagick Exp $ */
 /*============================================================================\
 |                Copyright (C) 2006 by Timothy P. Hunter
 | Name:     rmimage.c
@@ -24,18 +24,121 @@ typedef Image *(scaler_t)(const Image *, const unsigned long, const unsigned lon
 typedef unsigned int (thresholder_t)(Image *, const char *);
 typedef Image *(xformer_t)(const Image *, const RectangleInfo *, ExceptionInfo *);
 
+static VALUE cropper(int, int, VALUE *, VALUE);
 static VALUE effect_image(VALUE, int, VALUE *, effector_t *);
+static VALUE flipflop(int, VALUE, flipper_t);
 static VALUE rd_image(VALUE, VALUE, reader_t);
+static VALUE rotate(int, VALUE, VALUE);
 static VALUE scale(int, int, VALUE *, VALUE, scaler_t *);
-static VALUE cropper(int, int, VALUE *, VALUE);
-static VALUE xform_image(int, VALUE, VALUE, VALUE, VALUE, VALUE, xformer_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 ChannelType extract_channels(int *, VALUE *);
 static void raise_ChannelType_error(VALUE);
 
 static ImageAttribute *Next_Attribute;
 
+
+
+
+/*
+    Method:     Image#adaptive_sharpen(radius=0.0, sigma=1.0)
+    Purpose:    call AdaptiveSharpenImage
+*/
+VALUE
+Image_adaptive_sharpen(int argc, VALUE *argv, VALUE self)
+{
+#if defined(HAVE_ADAPTIVESHARPENIMAGE)
+    Image *image, *new_image;
+    double radius = 0.0;
+    double sigma = 1.0;
+    ExceptionInfo exception;
+
+    switch (argc)
+    {
+        case 2:
+            sigma = NUM2DBL(argv[1]);
+        case 1:
+            radius = NUM2DBL(argv[0]);
+        case 0:
+            break;
+        default:
+            rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 to 2)", argc);
+            break;
+    }
+
+    Data_Get_Struct(self, Image, image);
+
+    GetExceptionInfo(&exception);
+
+    new_image = AdaptiveSharpenImage(image, radius, sigma, &exception);
+    rm_check_exception(&exception, new_image, DestroyOnError);
+
+    DestroyExceptionInfo(&exception);
+
+    rm_ensure_result(new_image);
+
+    return rm_image_new(new_image);
+
+#else
+
+    rm_not_implemented();
+    return (VALUE)0;
+#endif
+}
+
+
+/*
+    Method:     Image#adaptive_sharpen_channel(radius=0.0, sigma=1.0[, channel...])
+    Purpose:    Call AdaptiveSharpenImageChannel
+*/
+VALUE
+Image_adaptive_sharpen_channel(int argc, VALUE *argv, VALUE self)
+{
+#if defined(HAVE_ADAPTIVESHARPENIMAGE)
+
+    Image *image, *new_image;
+    double radius = 0.0;
+    double sigma = 1.0;
+    ExceptionInfo exception;
+    ChannelType channels;
+
+    channels = extract_channels(&argc, argv);
+
+    switch (argc)
+    {
+        case 2:
+            sigma = NUM2DBL(argv[1]);
+        case 1:
+            radius = NUM2DBL(argv[0]);
+        case 0:
+            break;
+        default:
+            raise_ChannelType_error(argv[argc-1]);
+            break;
+    }
+
+    Data_Get_Struct(self, Image, image);
+
+    GetExceptionInfo(&exception);
+
+    new_image = AdaptiveSharpenImageChannel(image, channels, radius, sigma, &exception);
+    rm_check_exception(&exception, new_image, DestroyOnError);
+
+    DestroyExceptionInfo(&exception);
+
+    rm_ensure_result(new_image);
+
+    return rm_image_new(new_image);
+#else
+
+    rm_not_implemented();
+    return (VALUE)0;
+#endif
+}
+
+
+
 /*
     Method:     Image#adaptive_threshold(width=3, height=3, offset=0)
     Purpose:    selects an individual threshold for each pixel based on
@@ -297,6 +400,124 @@ Image_aset(VALUE self, VALUE key_arg, VALUE attr_arg)
 }
 
 
+/*
+    Static:     crisscross
+    Purpose:    Handle #transverse, #transform methods
+*/
+#if defined(HAVE_TRANSPOSEIMAGE) || defined(HAVE_TRANSVERSEIMAGE)
+static VALUE
+crisscross(
+    int bang,
+    VALUE self,
+    Image *(fp)(const Image *, ExceptionInfo *))
+{
+    Image *image, *new_image;
+    ExceptionInfo exception;
+
+
+    Data_Get_Struct(self, Image, image);
+    GetExceptionInfo(&exception);
+
+    new_image = (fp)(image, &exception);
+    rm_check_exception(&exception, new_image, DestroyOnError);
+
+    DestroyExceptionInfo(&exception);
+
+    rm_ensure_result(new_image);
+
+    if (bang)
+    {
+        DATA_PTR(self) = new_image;
+        DestroyImage(image);
+        return self;
+    }
+
+    return rm_image_new(new_image);
+
+}
+#endif
+
+
+/*
+    Method:     Image#auto_orient
+    Purpose:    Implement mogrify's -auto_orient option
+                automatically orient image based on EXIF orientation value
+    Notes:      See mogrify.c in ImageMagick 6.2.8.
+*/
+static VALUE auto_orient(int bang, VALUE self)
+{
+#if defined(HAVE_TRANSPOSEIMAGE) || defined(HAVE_TRANSVERSEIMAGE)
+    Image *image;
+    volatile VALUE new_image;
+
+    Data_Get_Struct(self, Image, image);
+
+    switch (image->orientation)
+    {
+        case TopRightOrientation:
+            new_image = flipflop(bang, self, FlopImage);
+            break;
+
+        case BottomRightOrientation:
+            new_image = rotate(bang, self, rb_float_new(180.0));
+            break;
+
+        case BottomLeftOrientation:
+            new_image = flipflop(bang, self, FlipImage);
+            break;
+
+        case LeftTopOrientation:
+            new_image = crisscross(bang, self, TransposeImage);
+            break;
+
+        case RightTopOrientation:
+            new_image = rotate(bang, self, rb_float_new(90.0));
+            break;
+
+        case RightBottomOrientation:
+            new_image = crisscross(bang, self, TransverseImage);
+            break;
+
+        case LeftBottomOrientation:
+            new_image = rotate(bang, self, rb_float_new(270.0));
+            break;
+
+        default:                // Return IMMEDIATELY
+            return bang ? Qnil : Image_copy(self);
+            break;
+    }
+
+
+    Data_Get_Struct(new_image, Image, image);
+    image->orientation = TopLeftOrientation;
+
+    return new_image;
+
+#else
+    rm_not_implemented();
+    return (VALUE)0;
+#endif
+}
+
+
+VALUE
+Image_auto_orient(VALUE self)
+{
+    return auto_orient(False, self);
+}
+
+/*
+    Returns nil if the image is already properly oriented
+*/
+VALUE
+Image_auto_orient_bang(VALUE self)
+{
+    rm_check_frozen(self);
+    return auto_orient(True, self);
+}
+
+
+
 /*
     Method:     Image#background_color
     Purpose:    Return the name of the background color as a String.
@@ -1831,7 +2052,8 @@ static VALUE composite(
     int bang,
     int argc,
     VALUE *argv,
-    VALUE self)
+    VALUE self,
+    ChannelType channels)
 {
     Image *image, *new_image;
     Image *comp_image;
@@ -1939,7 +2161,11 @@ static VALUE composite(
     if (bang)
     {
         rm_check_frozen(self);
+#if defined(HAVE_COMPOSITEIMAGECHANNEL)
+        (void) CompositeImageChannel(image, channels, operator, comp_image, x_offset, y_offset);
+#else
         (void) CompositeImage(image, operator, comp_image, x_offset, y_offset);
+#endif
         rm_check_image_exception(image, RetainOnError);
         return self;
     }
@@ -1947,7 +2173,11 @@ static VALUE composite(
     {
         new_image = rm_clone_image(image);
 
+#if defined(HAVE_COMPOSITEIMAGECHANNEL)
+        (void) CompositeImageChannel(new_image, channels, operator, comp_image, x_offset, y_offset);
+#else
         (void) CompositeImage(new_image, operator, comp_image, x_offset, y_offset);
+#endif
         rm_check_image_exception(new_image, DestroyOnError);
 
         return rm_image_new(new_image);
@@ -1960,7 +2190,12 @@ VALUE Image_composite_bang(
     VALUE *argv,
     VALUE self)
 {
-    return composite(True, argc, argv, self);
+#if defined(HAVE_ALLCHANNELS)
+        ChannelType channels = (AllChannels &~ OpacityChannel);
+#else
+        ChannelType channels = (0xff &~ OpacityChannel);
+#endif
+    return composite(True, argc, argv, self, channels);
 }
 
 VALUE Image_composite(
@@ -1968,7 +2203,12 @@ VALUE Image_composite(
     VALUE *argv,
     VALUE self)
 {
-    return composite(False, argc, argv, self);
+#if defined(HAVE_ALLCHANNELS)
+        ChannelType channels = (AllChannels &~ OpacityChannel);
+#else
+        ChannelType channels = (0xff &~ OpacityChannel);
+#endif
+    return composite(False, argc, argv, self, channels);
 }
 
 
@@ -1998,6 +2238,50 @@ Image_composite_affine(
     return rm_image_new(new_image);
 }
 
+
+/*
+    Method:     Image#composite_channel(src_image, geometry, composite_operator[, channel...])
+                Image#composite_channel!(src_image, geometry, composite_operator[, channel...])
+    Purpose:    Call CompositeImageChannel
+*/
+static VALUE
+composite_channel(int bang, int argc, VALUE *argv, VALUE self)
+{
+#if defined(HAVE_COMPOSITEIMAGECHANNEL)
+    ChannelType channels;
+
+    channels = extract_channels(&argc, argv);
+
+    // There must be 3, 4, or 5 remaining arguments.
+    if (argc < 3)
+    {
+        rb_raise(rb_eArgError, "composite operator not specified");
+    }
+    else if (argc > 5)
+    {
+        raise_ChannelType_error(argv[argc-1]);
+    }
+
+    return composite(bang, argc, argv, self, channels);
+
+#else
+    rm_not_implemented();
+    return (VALUE)0;
+#endif
+}
+
+VALUE Image_composite_channel(int argc, VALUE *argv, VALUE self)
+{
+    return composite_channel(False, argc, argv, self);
+}
+
+
+VALUE Image_composite_channel_bang(int argc, VALUE *argv, VALUE self)
+{
+    return composite_channel(True, argc, argv, self);
+}
+
+
 /*
     Method:     Image#compression
                 Image#compression=
@@ -2156,13 +2440,9 @@ Image_constitute(VALUE class, VALUE width_arg, VALUE height_arg
     {
         rb_raise(rb_eNoMemError, "not enough memory to continue.");
     }
-    image->columns = width;
-    image->rows = height;
-#if defined(HAVE_SETIMAGEBACKGROUNDCOLOR)
+    SetImageExtent(image, width, height);
     SetImageBackgroundColor(image);
-#else
-    SetImage(image, OpaqueOpacity);
-#endif
+
     (void) ImportImagePixels(image, 0, 0, width, height, map, stg_type, (void *)pixels.v);
     rm_check_image_exception(image, DestroyOnError);
 #else
@@ -2421,6 +2701,7 @@ Image_init_copy(VALUE copy, VALUE orig)
     return copy;
 }
 
+
 /*
     Method:     Image#crop(x, y, width, height)
                 Image#crop(gravity, width, height)
@@ -2656,7 +2937,7 @@ Image_dispatch(int argc, VALUE *argv, VALUE self)
     StorageType stg_type = FIX_STG_TYPE;
     char *map;
     long mapL;
-    boolean okay;
+    MagickBooleanType okay;
     ExceptionInfo exception;
     union
     {
@@ -3128,11 +3409,7 @@ Image_erase_bang(VALUE self)
     rm_check_frozen(self);
     Data_Get_Struct(self, Image, image);
 
-#if defined(HAVE_SETIMAGEBACKGROUNDCOLOR)
     SetImageBackgroundColor(image);
-#else
-    SetImage(image, OpaqueOpacity);
-#endif
 
     rm_check_image_exception(image, RetainOnError);
 
@@ -5287,10 +5564,10 @@ Image_initialize(VALUE self, VALUE info_obj, VALUE width, VALUE height, VALUE fi
 {
     Image *image;
     Info *info;
-    int cols, rows;
+    unsigned long cols, rows;
 
-    cols = NUM2INT(width);
-    rows = NUM2INT(height);
+    cols = NUM2ULONG(width);
+    rows = NUM2ULONG(height);
 
     if (cols <= 0 || rows <= 0)
     {
@@ -5299,19 +5576,15 @@ Image_initialize(VALUE self, VALUE info_obj, VALUE width, VALUE height, VALUE fi
 
     Data_Get_Struct(info_obj, Info, info);
     Data_Get_Struct(self, Image, image);
-    image->columns = cols;
-    image->rows = rows;
+
+    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 (!fill)
     {
-#if defined(HAVE_SETIMAGEBACKGROUNDCOLOR)
         SetImageBackgroundColor(image);
-#else
-        SetImage(image, OpaqueOpacity);
-#endif
     }
     // fillobj.fill(self)
     else
@@ -5352,15 +5625,15 @@ Image_initialize(int argc, VALUE *argv, VALUE self)
     Info *info;
     volatile VALUE info_obj;
     Image *image;
-    int cols, rows;
+    unsigned long cols, rows;
 
     switch (argc)
     {
         case 3:
             fill = argv[2];
         case 2:
-            rows = NUM2INT(argv[1]);
-            cols = NUM2INT(argv[0]);
+            rows = NUM2ULONG(argv[1]);
+            cols = NUM2ULONG(argv[0]);
             break;
         default:
             rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc);
@@ -5380,15 +5653,14 @@ Image_initialize(int argc, VALUE *argv, VALUE self)
     // NOW store a real image in the image object.
     DATA_PTR(self) = image;
 
-    image->columns = cols;
-    image->rows = rows;
+    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 (!fill)
     {
-        SetImage(image, OpaqueOpacity);
+        SetImageBackgroundColor(image);
     }
     // fillobj.fill(self)
     else
@@ -5639,6 +5911,7 @@ Image_ordered_dither(int argc, VALUE *argv, VALUE self)
     return rm_image_new(new_image);
 }
 
+
 /*
     Method:     Image#orientation
     Purpose:    Return the orientation attribute as an OrientationType enum value.
@@ -5657,6 +5930,29 @@ Image_orientation(VALUE self)
 #endif
 }
 
+
+/*
+    Method:     Image#orientation=
+    Purpose:    Set the orientation attribute
+*/
+VALUE
+Image_orientation_eq(VALUE self, VALUE orientation)
+{
+#if defined(HAVE_IMAGE_ORIENTATION)
+    Image *image;
+
+    rm_check_frozen(self);
+    Data_Get_Struct(self, Image, image);
+    VALUE_TO_ENUM(orientation, image->orientation, OrientationType);
+    return self;
+
+#else
+    rm_not_implemented();
+    return (VALUE)0;
+#endif
+}
+
+
 /*
     Method:     Image#page
     Purpose:    the page attribute getter
@@ -6248,6 +6544,51 @@ Image_radial_blur(VALUE self, VALUE angle)
 #endif
 }
 
+/*
+    Method:     Image#radial_blur_channel(angle[, channel..])
+    Purpose:    Call RadialBlurImageChannel
+    Notes:      Angle is in degrees
+*/
+VALUE
+Image_radial_blur_channel(
+    int argc,
+    VALUE *argv,
+    VALUE self)
+{
+#if defined(HAVE_RADIALBLURIMAGECHANNEL)
+    Image *image, *new_image;
+    ExceptionInfo exception;
+    ChannelType channels;
+
+    channels = extract_channels(&argc, argv);
+
+    // There must be 1 remaining argument.
+    if (argc == 0)
+    {
+        rb_raise(rb_eArgError, "wrong number of arguments (0 for 1 or more)");
+    }
+    else if (argc > 1)
+    {
+        raise_ChannelType_error(argv[argc-1]);
+    }
+
+    Data_Get_Struct(self, Image, image);
+    GetExceptionInfo(&exception);
+
+    new_image = RadialBlurImageChannel(image, channels, NUM2DBL(argv[0]), &exception);
+
+    rm_check_exception(&exception, new_image, DestroyOnError);
+    DestroyExceptionInfo(&exception);
+    rm_ensure_result(new_image);
+
+    return rm_image_new(new_image);
+
+#else
+    rm_not_implemented();
+    return (VALUE)0;
+#endif
+}
+
 
 /*
     Method:     Image#random_channel_threshold
@@ -6451,7 +6792,7 @@ rd_image(VALUE class, VALUE file, reader_t reader)
         // Ensure file is open - raise error if not
         GetOpenFile(file, fptr);
         rb_io_check_readable(fptr);
-        info->file = GetReadFile(fptr);
+        SetImageInfoFile(info, GetReadFile(fptr));
     }
     else
     {
@@ -6462,7 +6803,7 @@ rd_image(VALUE class, VALUE file, reader_t reader)
         filename_l = min(filename_l, MaxTextExtent-1);
         memcpy(info->filename, filename, (size_t)filename_l);
         info->filename[filename_l] = '\0';
-        info->file = NULL;      // Reset FILE *, if any
+        SetImageInfoFile(info, NULL);
     }
 
     GetExceptionInfo(&exception);
@@ -7704,7 +8045,11 @@ Image_class_type_eq(VALUE self, VALUE new_class_type)
         QuantizeImage(&qinfo, image);
     }
 
+#if defined(HAVE_SETIMAGESTORAGECLASS)
+    SetImageStorageClass(image, class_type);
+#else
     image->storage_class = class_type;
+#endif
     return self;
 }
 
@@ -8366,11 +8711,70 @@ Image_transparent(int argc, VALUE *argv, VALUE self)
 }
 
 
+/*
+ *  Method:     Image#transpose
+ *              Image#transpose!
+ *  Purpose:    Call TransposeImage
+ */
+VALUE
+Image_transpose(VALUE self)
+{
+#if defined(HAVE_TRANSPOSEIMAGE)
+    return crisscross(False, self, TransposeImage);
+#else
+    rm_not_implemented();
+    return (VALUE)0;
+#endif
+}
+
+
+VALUE
+Image_transpose_bang(VALUE self)
+{
+#if defined(HAVE_TRANSPOSEIMAGE)
+    rm_check_frozen(self);
+    return crisscross(True, self, TransposeImage);
+#else
+    rm_not_implemented();
+    return (VALUE)0;
+#endif
+}
+
+
+/*
+ *  Method:     Image#transverse
+ *              Image#transverse!
+ *  Purpose:    Call TransverseImage
+ */
+VALUE
+Image_transverse(VALUE self)
+{
+#if defined(HAVE_TRANSVERSEIMAGE)
+    return crisscross(False, self, TransverseImage);
+#else
+    rm_not_implemented();
+    return (VALUE)0;
+#endif
+}
+
+VALUE
+Image_transverse_bang(VALUE self)
+{
+#if defined(HAVE_TRANSVERSEIMAGE)
+    rm_check_frozen(self);
+    return crisscross(True, self, TransverseImage);
+#else
+    rm_not_implemented();
+    return (VALUE)0;
+#endif
+}
+
+
 /*
  *  Method:     Image#trim, Image#trim!
  *  Purpose:    convenience front-end to CropImage
  *  Notes:      respects fuzz attribute
-*/
+ */
 
 static VALUE
 trimmer(int bang, VALUE self)
@@ -8778,7 +9182,7 @@ Image_write(VALUE self, VALUE file)
         // Ensure file is open - raise error if not
         GetOpenFile(file, fptr);
         rb_io_check_writable(fptr);
-        info->file = GetWriteFile(fptr);
+        SetImageInfoFile(info, GetWriteFile(fptr));
     }
     else
     {
@@ -8804,7 +9208,7 @@ Image_write(VALUE self, VALUE file)
         {
             return Qnil;
         }
-        info->file = NULL;
+        SetImageInfoFile(info, NULL);
     }
 
     info->adjoin = False;