magickwand 0.1.0

data/ext/magickwand/wand.c

@@ -0,0 +1,2296 @@
+/*
+ *  wand.c
+ *  $Id: wand.c 147 2009-05-31 22:01:22Z rmagick $
+ *  Copyright (C) 2009 Timothy Paul Hunter
+ */
+
+#include <math.h>
+#include "magickwand.h"
+
+
+
+
+static void wand_destroy(void *);
+static VALUE wand_length(VALUE);
+static VALUE wand_new(MagickWand *);
+static VALUE wand_signature(VALUE);
+
+
+
+
+
+static VALUE wand_allocate(VALUE klass)
+{
+    Wand *wand;
+    return  Data_Make_Struct(klass, Wand, NULL, wand_destroy, wand);
+}
+
+
+
+
+static void wand_destroy(void *p)
+{
+    Wand *wand = (Wand *)p;
+
+    if (wand->magickwand)
+    {
+        wand->magickwand = DestroyMagickWand(wand->magickwand);
+    }
+}
+
+
+
+
+/*
+ *  wand.add_canvas(width, height = width, background = "white")
+ *  default height is same as width
+ */
+static VALUE wand_add_canvas(int argc, VALUE *argv, VALUE obj)
+{
+    Wand *wand;
+    PixelWand *pixelwand;
+    Image *new_image;
+    volatile VALUE width, height, background;
+    unsigned long columns, rows;
+    char *background_color = "white";
+
+    rb_check_frozen(obj);
+
+    switch (rb_scan_args(argc, argv, "12", &width, &height, &background))
+    {
+        case 3:
+            background_color = StringValuePtr(background);
+            // fall through
+        case 2:
+            rows = NUM2ULONG(height);
+            columns = NUM2ULONG(width);
+            break;
+        case 1:
+            rows = columns = NUM2ULONG(width);
+            break;
+    }
+
+    Data_Get_Struct(obj, Wand, wand);
+
+    pixelwand = NewPixelWand();
+    PixelSetColor(pixelwand, background_color);
+    mwr_check_pixelwand_error(pixelwand);
+
+    // New images are added at the end.
+    MagickSetLastIterator(wand->magickwand);
+    // The image background color is NOT taken from the pixelwand!
+    // This must be done separately.
+    if (MagickNewImage(wand->magickwand, columns, rows, pixelwand) != MagickFalse)
+    {
+        new_image = GetImageFromMagickWand(wand->magickwand);
+        mwr_get_pixelpacket_from_pixelwand(&new_image->background_color, pixelwand);
+        SetImageBackgroundColor(new_image);
+    }
+    DestroyPixelWand(pixelwand);
+    mwr_check_magickwand_error(wand->magickwand);
+
+    return obj;
+}
+
+
+
+
+/*
+ *  wand.animate(:delay => ticks, :iterations => 0)
+ *  wand.animate(:delay => [ticks, ticks-per-second])
+ */
+static VALUE wand_animate(int argc, VALUE *argv, VALUE obj)
+{
+    Wand *wand;
+    volatile VALUE v;
+    VALUE options;
+    unsigned long delay = ULONG_MAX, iterations = ULONG_MAX;
+    long ticks_per_second = LONG_MAX;
+    int xyzzy = 1;
+
+    Data_Get_Struct(obj, Wand, wand);
+    if (MagickGetNumberImages(wand->magickwand) == 0UL)
+    {
+        return obj;
+    }
+
+    (void) rb_scan_args(argc, argv, "01", &options);
+    if (options != Qnil)
+    {
+        v = rb_hash_aref(options, ID2SYM(rb_intern("delay")));
+        if (v != Qnil)
+        {
+            if (TYPE(v) == T_ARRAY)
+            {
+                delay = NUM2ULONG(rb_ary_entry(v, 0));
+                // For simplicity, allow the array to have only 1 entry
+                if (NUM2INT(rb_funcall(v, rb_intern("length"), 0)) > 1)
+                {
+                    ticks_per_second = NUM2ULONG(rb_ary_entry(v, 1));
+                }
+            }
+            else
+            {
+                delay = NUM2ULONG(v);
+            }
+        }
+        v = rb_hash_aref(options, ID2SYM(rb_intern("iterations")));
+        if (v != Qnil)
+        {
+            iterations = NUM2ULONG(v);
+        }
+        v = rb_hash_aref(options, ID2SYM(rb_intern("xyzzy")));
+        if (v != Qnil)
+        {
+            xyzzy = RTEST(v);
+        }
+    }
+
+    if (delay != ULONG_MAX || iterations != ULONG_MAX)
+    {
+        MagickResetIterator(wand->magickwand);
+        while (MagickNextImage(wand->magickwand) != MagickFalse)
+        {
+            if (iterations != ULONG_MAX)
+            {
+                MagickSetImageIterations(wand->magickwand, iterations);
+                mwr_check_magickwand_error(wand->magickwand);
+            }
+            if (delay != ULONG_MAX)
+            {
+                MagickSetImageDelay(wand->magickwand, delay);
+                mwr_check_magickwand_error(wand->magickwand);
+            }
+            if (ticks_per_second != LONG_MAX)
+            {
+                MagickSetImageTicksPerSecond(wand->magickwand, ticks_per_second);
+                mwr_check_magickwand_error(wand->magickwand);
+            }
+        }
+    }
+
+    // :xyzzy => false suppresses the actual animation (for testing)
+    if (xyzzy)
+    {
+        MagickAnimateImages(wand->magickwand, NULL);
+        mwr_check_magickwand_error(wand->magickwand);
+    }
+
+    return obj;
+}
+
+
+
+
+static VALUE subsequence(VALUE obj, long offset, long length)
+{
+    Wand *wand;
+    MagickWand *new_magickwand = NULL;
+    MagickWand *temp;
+    long nimages, n;
+
+    Data_Get_Struct(obj, Wand, wand);
+    nimages = (long) MagickGetNumberImages(wand->magickwand);
+
+    if (length < 0 || offset >= nimages)
+    {
+        goto leave;     // return a new, empty Wand object
+    }
+    if (offset < 0)
+    {
+        if (offset + nimages < 0)
+        {
+            goto leave; // return a new, empty Wand object
+        }
+        offset += nimages;
+    }
+    if (offset + length >= nimages)
+    {
+        length = nimages - offset;
+    }
+    if (length < 0)
+    {
+        goto leave;     // return a new, empty Wand object
+    }
+
+    /*
+     *  Add the specified images from the wand to the new wand.
+     */
+
+    MagickSetIteratorIndex(wand->magickwand, offset);
+    mwr_check_magickwand_error(wand->magickwand);
+    new_magickwand = MagickGetImage(wand->magickwand);  // get image at 'offset'
+    mwr_check_magickwand_error(wand->magickwand);
+
+    for (n = 1; n < length && offset + n < nimages; n++)
+    {
+        MagickNextImage(wand->magickwand);
+        mwr_check_magickwand_error(wand->magickwand);
+        /*
+         *  Tim, remember that temp is allocated from Ruby memory, so
+         *  MagickGetImage either succeeds or Ruby raises an exception.
+         */
+        MagickSetLastIterator(new_magickwand);
+        temp = MagickGetImage(wand->magickwand);
+        MagickAddImage(new_magickwand, temp);
+        /*
+         *  Destroy the temp magickwand before possibly raising an exception.
+         */
+        temp = DestroyMagickWand(temp);
+        mwr_check_magickwand_error(new_magickwand);
+    }
+
+leave:
+    return wand_new(new_magickwand);
+}
+
+
+
+
+/*
+ *  wand.annotate(text, :x=>0.0, :y=>0.0, :angle=>0.0 [, drawing_wand options])
+ */
+static VALUE wand_annotate(int argc, VALUE *argv, VALUE obj)
+{
+    Wand *wand;
+    GC *gc;
+    double x, y, angle;
+    volatile VALUE graphics_context;
+    VALUE v, text, options;
+    char *text_string;
+
+    rb_check_frozen(obj);
+
+    (void)rb_scan_args(argc, argv, "11", &text, &options);
+    text_string = StringValuePtr(text);
+    if (RSTRING_LEN(text) == 0)
+    {
+        rb_raise(rb_eArgError, "no text specified");
+    }
+    x = mwr_get_option(options, "x", &v) ? NUM2DBL(v) : 0.0;
+    y = mwr_get_option(options, "y", &v) ? NUM2DBL(v) : 0.0;
+    angle = mwr_get_option(options, "angle", &v) ? NUM2DBL(v) : 0.0;
+
+    graphics_context = mwr_gc_new();
+    Data_Get_Struct(graphics_context, GC, gc);
+
+    // Override default NorthWest gravity. It's useless.
+    DrawSetGravity(gc->drawingwand, CenterGravity);
+    mwr_process_options(graphics_context, options);
+
+    Data_Get_Struct(obj, Wand, wand);
+
+    MagickResetIterator(wand->magickwand);
+    while (MagickNextImage(wand->magickwand) != MagickFalse)
+    {
+        MagickAnnotateImage(wand->magickwand, gc->drawingwand, x, y, angle, text_string);
+    }
+
+    return obj;
+}
+
+
+
+
+/*
+ *  wand[fixnum]
+ *  wand[fixnum, fixnum]
+ *  wand[range]
+ *
+ *  All return a new wand. Raises RangeError if subscript is out-of-range
+ */
+static VALUE wand_aref(int argc, VALUE *argv, VALUE obj)
+{
+    long nimages, begin, length;
+    volatile VALUE range_code;
+
+    if (argc == 2)
+    {
+        return subsequence(obj, FIX2LONG(argv[0]), FIX2LONG(argv[1]));
+    }
+    else if (TYPE(argv[0]) == T_FIXNUM)
+    {
+        return subsequence(obj, FIX2LONG(argv[0]), 1L);
+    }
+    else
+    {
+        nimages = FIX2LONG(wand_length(obj));
+
+        // Returns Qfalse if argv[0] isn't a Range object.
+        // Returns Qnil if out-of-range
+        range_code = rb_range_beg_len(argv[0], &begin, &length, nimages, 0);
+        if (range_code == Qnil)
+        {
+            return wand_new(NULL);
+        }
+        else if (range_code == Qfalse)
+        {
+            rb_raise(rb_eTypeError, "expecting Fixnum or Range, got %s", rb_obj_classname(argv[0]));
+        }
+
+        return subsequence(obj, begin, length);
+    }
+}
+
+
+
+
+/*
+ *  Replace 'length' images starting at offset 'begin' with the images in obj2
+ */
+static VALUE splice(VALUE obj, long begin, long length, VALUE obj2)
+{
+    Wand *wand, *wand2;
+    long n, nimages;
+
+    if (length < 0)
+    {
+        rb_raise(rb_eIndexError, "negative length %ld", length);
+    }
+
+    Data_Get_Struct(obj, Wand, wand);
+    nimages = (long) MagickGetNumberImages(wand->magickwand);
+    if (nimages < begin || (begin < 0 && -begin > nimages))
+    {
+        rb_raise(rb_eIndexError, "index %ld out of wand", begin);
+    }
+
+    if (begin < 0)
+    {
+        begin += nimages;
+    }
+    if (nimages < length || nimages < (begin + length))
+    {
+        length = nimages - begin;
+    }
+    if (length > nimages)
+    {
+        rb_raise(rb_eIndexError, "length %ld exceeds wand length", length);
+    }
+
+    Data_Get_Struct(obj2, Wand, wand2);
+
+    // delete length images starting at begin
+    MagickSetIteratorIndex(wand->magickwand, begin);
+    mwr_check_magickwand_error(wand->magickwand);
+    for (n = 0; n < length; n++)
+    {
+        MagickRemoveImage(wand->magickwand);
+        mwr_check_magickwand_error(wand->magickwand);
+    }
+
+    // If there are no images in the rhs wand, we're done.
+    // Otherwise position the lhs to just prior the first image to be replaced
+    // because MagickAddImage adds images *after* the current image.
+    if (MagickGetNumberImages(wand2->magickwand) > 0UL)
+    {
+        if (begin == 0L)
+        {
+            MagickResetIterator(wand->magickwand);
+        }
+        else
+        {
+            MagickSetIteratorIndex(wand->magickwand, begin-1L);
+        }
+        mwr_check_magickwand_error(wand->magickwand);
+
+        MagickResetIterator(wand2->magickwand);
+        MagickAddImage(wand->magickwand, wand2->magickwand);
+        mwr_check_magickwand_error(wand->magickwand);
+    }
+
+
+    return obj;
+}
+
+
+
+
+/*
+ *  wand[fixnum] = wand
+ *  wand[fixnum, fixnum] = wand
+ *  wand[range] = wand
+ */
+static VALUE wand_aset(int argc, VALUE *argv, VALUE obj)
+{
+    Wand *wand;
+    volatile VALUE range_code;
+    long nimages, begin, length;
+
+    rb_check_frozen(obj);
+
+    if (argc == 3)
+    {
+        return splice(obj, FIX2LONG(argv[0]), FIX2LONG(argv[1]), argv[2]);
+    }
+    else if (argc == 2)
+    {
+        if (rb_obj_is_kind_of(argv[0], rb_cRange))
+        {
+            Data_Get_Struct(obj, Wand, wand);
+            nimages = (long) MagickGetNumberImages(wand->magickwand);
+            range_code = rb_range_beg_len(argv[0], &begin, &length, nimages, 2);
+            return splice(obj, begin, length, argv[1]);
+        }
+        else
+        {
+            return splice(obj, FIX2LONG(argv[0]), 1UL, argv[1]);
+        }
+    }
+    else
+    {
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc);
+    }
+
+    return (VALUE)0;    // not reachable
+}
+
+
+
+
+/*
+ *  returns the background color property for the 0th image
+ */
+static VALUE wand_background(VALUE obj)
+{
+    Wand *wand;
+    Image *image;
+
+    if (FIX2LONG(wand_length(obj)) == 0)
+    {
+        return Qnil;
+    }
+
+    Data_Get_Struct(obj, Wand, wand);
+    MagickResetIterator(wand->magickwand);
+    image = GetImageFromMagickWand(wand->magickwand);
+    mwr_check_magickwand_error(wand->magickwand);
+    return mwr_pixelpacket_to_hex(image, &image->background_color);
+}
+
+
+
+
+static VALUE convolve(int argc, VALUE *argv, VALUE obj,
+    MagickBooleanType (*convolve)(MagickWand *, const ChannelType, const double, const double))
+{
+    Wand *wand;
+    VALUE r, s, v, options;
+    double radius, sigma;
+    ChannelType channels;
+
+    rb_check_frozen(obj);
+
+    (void) rb_scan_args(argc, argv, "21", &r, &s, &options);
+    radius = NUM2DBL(r);
+    sigma = NUM2DBL(s);
+    (void) mwr_get_option(options, "channel", &v);
+    channels = mwr_string_to_channeltype(v, DefaultChannels, RaiseUndefinedOption);
+
+    Data_Get_Struct(obj, Wand, wand);
+    MagickResetIterator(wand->magickwand);
+    while (MagickNextImage(wand->magickwand) != MagickFalse)
+    {
+        (*convolve)(wand->magickwand, channels, radius, sigma);
+        mwr_check_magickwand_error(wand->magickwand);
+    }
+
+    return obj;
+}
+
+
+
+
+/*
+ *  wand.blur(radius, sigma, :channel=>"default")
+ */
+static VALUE wand_blur(int argc, VALUE *argv, VALUE obj)
+{
+    return convolve(argc, argv, obj, MagickBlurImageChannel);
+}
+
+
+
+
+/*
+ *  wand.border(color, width=1, height=width)
+ */
+static VALUE wand_border(int argc, VALUE *argv, VALUE obj)
+{
+    Wand *wand;
+    PixelWand *pixelwand;
+    VALUE color, wt, ht;
+    char *border_color;
+    unsigned long width, height;
+
+    rb_check_frozen(obj);
+    (void) rb_scan_args(argc, argv, "12", &color, &wt, &ht);
+    border_color = StringValuePtr(color);
+    width = wt != Qnil ? NUM2ULONG(wt) : 1UL;
+    height = ht != Qnil ? NUM2ULONG(ht) : width;
+
+    pixelwand = NewPixelWand();
+    PixelSetColor(pixelwand, border_color);
+    mwr_check_pixelwand_error(pixelwand);
+
+    Data_Get_Struct(obj, Wand, wand);
+
+    MagickResetIterator(wand->magickwand);
+    while (MagickNextImage(wand->magickwand) != MagickFalse)
+    {
+        MagickBorderImage(wand->magickwand, pixelwand, width, height);
+        mwr_check_magickwand_error(wand->magickwand);
+    }
+
+    DestroyPixelWand(pixelwand);
+    return obj;
+}
+
+
+
+
+/*
+ *  wanda <=> wandb
+ *  Comparison is similar to how arrays are compared.
+ *  Each image in each wand is compared by their signatures.
+ *  If all images are equal then the longer wand is > than the shorter wand.
+ */
+static VALUE wand_cmp(VALUE obj, VALUE other)
+{
+    Wand *wand, *other_wand;
+    int cmp;
+    char *signature, *other_signature;
+
+    if (obj == other)
+    {
+        return INT2FIX(0);
+    }
+
+    Data_Get_Struct(obj, Wand, wand);
+    Data_Get_Struct(other, Wand, other_wand);
+
+    MagickResetIterator(wand->magickwand);
+    MagickResetIterator(other_wand->magickwand);
+
+    cmp = 0;
+    while (cmp == 0 && MagickNextImage(wand->magickwand) && MagickNextImage(other_wand->magickwand))
+    {
+        signature = MagickGetImageSignature(wand->magickwand);
+        other_signature = MagickGetImageSignature(other_wand->magickwand);
+        cmp = strcmp(signature, other_signature);
+        RelinquishMagickMemory(signature);
+        RelinquishMagickMemory(other_signature);
+    }
+
+    if (cmp != 0)
+    {
+        return INT2FIX(cmp);
+    }
+    if (MagickHasNextImage(wand->magickwand))
+    {
+        return INT2FIX(1);
+    }
+    if (MagickHasNextImage(other_wand->magickwand))
+    {
+        return INT2FIX(-1);
+    }
+
+    return INT2FIX(0);
+}
+
+
+
+
+/*
+ *  colors = wand.colors
+ */
+static VALUE wand_colors(VALUE obj)
+{
+    Wand *wand;
+    unsigned long colors;
+
+    Data_Get_Struct(obj, Wand, wand);
+    if (MagickGetNumberImages(wand->magickwand) == 0UL)
+    {
+        return Qnil;
+    }
+
+    MagickResetIterator(wand->magickwand);
+    colors = MagickGetImageColors(wand->magickwand);
+    mwr_check_magickwand_error(wand->magickwand);
+    return ULONG2NUM(colors);
+}
+
+
+
+
+/*
+ *  string = img.comment
+ *  Gets the comment from the first image
+ *  There is no official "MagickGetComment" API for this operation.
+ */
+static VALUE wand_comment(VALUE obj)
+{
+    Image *magick_image;
+    Wand *wand;
+    const ImageAttribute *comment;
+
+    Data_Get_Struct(obj, Wand, wand);
+    MagickSetFirstIterator(wand->magickwand);
+    magick_image = GetImageFromMagickWand(wand->magickwand);
+    mwr_check_magickwand_error(wand->magickwand);
+    if (magick_image)
+    {
+        comment = GetImageAttribute(magick_image, "comment");
+        if (comment && comment->value)
+        {
+            return rb_str_new2(comment->value);
+        }
+    }
+
+    return Qnil;
+}
+
+
+
+
+/*
+ *  img.comment = string # set comment to string
+ *  img.comment = nil    # removes comment
+ */
+static VALUE wand_comment_set(VALUE obj, VALUE comment)
+{
+    const char *comment_str = NULL;
+    Wand *wand;
+
+    rb_check_frozen(obj);
+
+    Data_Get_Struct(obj, Wand, wand);
+    if (comment != Qnil)
+    {
+        comment_str = StringValuePtr(comment);
+    }
+
+    MagickResetIterator(wand->magickwand);
+    while (MagickNextImage(wand->magickwand) != MagickFalse)
+    {
+        (void) MagickCommentImage(wand->magickwand, comment_str);
+        mwr_check_magickwand_error(wand->magickwand);
+    }
+
+    return comment;
+}
+
+
+
+
+/*
+ *  diff, distortion = wand.compare(wand2[, :metric=>"ae", :channel=>"default", :fuzz=>"0%")
+ *  Compares the first image in wand to the first image in wand2.
+ *  'wand' is the reconstructed image, 'wand2' is the reference image.
+ *  Returns a difference image and distortion metric.
+ */
+static VALUE wand_compare(int argc, VALUE *argv, VALUE obj)
+{
+    Wand *wand;
+    Wand *wand2;
+    MagickWand *result;
+    VALUE other, options, v;
+    MetricType metric;
+    ChannelType channels;
+    double distortion = 0.0;
+    double fuzz = 0.0;
+
+    (void) rb_scan_args(argc, argv, "11", &other, &options);
+    (void) mwr_get_option(options, "metric", &v);
+    metric = mwr_string_to_metrictype(v, AbsoluteErrorMetric, RaiseUndefinedOption);
+    (void) mwr_get_option(options, "channel", &v);
+    channels = mwr_string_to_channeltype(v, DefaultChannels, RaiseUndefinedOption);
+
+    Data_Get_Struct(obj, Wand, wand);
+    Data_Get_Struct(other, Wand, wand2);
+
+    MagickResetIterator(wand->magickwand);
+    MagickResetIterator(wand2->magickwand);
+
+    (void) mwr_get_option(options, "fuzz", &v);
+#if defined(HAVE_MAGICKSETIMAGEFUZZ)
+    if (v != Qnil)
+    {
+        if (rb_obj_is_kind_of(v, rb_cNumeric))
+        {
+            fuzz = NUM2DBL(v);
+        }
+        else
+        {
+            v = rb_String(v);
+            // StringToDouble is defined in magick/string.c
+            fuzz = StringToDouble(StringValuePtr(v), QuantumRange+1.0);
+        }
+    }
+
+    MagickSetImageFuzz(wand->magickwand, fuzz);
+#else
+    if (v != Qnil)
+    {
+        rb_warning("MagickWand: The :fuzz option is not supported with this release of ImageMagick.");
+        fuzz = fuzz;
+    }
+#endif
+    result = MagickCompareImageChannels(wand->magickwand, wand2->magickwand, channels, metric, &distortion);
+
+    mwr_check_magickwand_error(wand->magickwand);
+    mwr_check_magickwand_error(wand2->magickwand);
+
+    return rb_ary_new3(2, wand_new(result), rb_float_new(distortion));
+}
+
+
+
+
+/*
+ *  wand.composite(composite_wand, :compose=>"over", :x=>0, :y=>0, :gravity=>"center")
+ *
+ *  Composites each image in composite_wand over the image in the corresponding position
+ *  in wand. If the composite_wand has fewer images than wand, then its images
+ *  are reused.
+ *
+ *  The position of the upper-left corner of the composite image is x,y, as adjusted
+ *  by gravity, relative to the current image and current composite image.
+ */
+static VALUE wand_composite(int argc, VALUE *argv, VALUE obj)
+{
+    volatile VALUE obj2;
+    VALUE v, options;
+    Wand *wand, *composite_wand;
+    CompositeOperator compose;
+    GravityType gravity;
+    unsigned long columns, rows;
+    long x, y;
+    RectangleInfo rect;
+
+    rb_check_frozen(obj);
+
+    (void) rb_scan_args(argc, argv, "11", &obj2, &options);
+
+    Data_Get_Struct(obj, Wand, wand);
+    Data_Get_Struct(obj2, Wand, composite_wand);
+    if (MagickGetNumberImages(wand->magickwand) == 0UL || MagickGetNumberImages(composite_wand->magickwand) == 0)
+    {
+        return obj;
+    }
+
+    memset(&rect, 0, sizeof(rect));
+
+    (void) mwr_get_option(options, "compose", &v);
+    compose = mwr_string_to_composetype(v, OverCompositeOp, RaiseUndefinedOption);
+    (void) mwr_get_option(options, "gravity", &v);
+    gravity = mwr_string_to_gravitytype(v, CenterGravity, RaiseUndefinedOption);
+    x = mwr_get_option(options, "x", &v) ? FIX2LONG(v) : 0L;
+    y = mwr_get_option(options, "y", &v) ? FIX2LONG(v) : 0L;
+
+    MagickResetIterator(wand->magickwand);
+    MagickResetIterator(composite_wand->magickwand);
+    while (MagickNextImage(wand->magickwand) != MagickFalse)
+    {
+        if (MagickNextImage(composite_wand->magickwand) == MagickFalse)
+        {
+            MagickResetIterator(composite_wand->magickwand);
+            MagickNextImage(composite_wand->magickwand);
+        }
+        // Position is based on the size of the current image
+        columns = MagickGetImageWidth(wand->magickwand);
+        rows = MagickGetImageHeight(wand->magickwand);
+        rect.width = MagickGetImageWidth(composite_wand->magickwand);
+        rect.height = MagickGetImageHeight(composite_wand->magickwand);
+        rect.x = x;
+        rect.y = y;
+        (void) GravityAdjustGeometry(columns, rows, gravity, &rect);
+        (void) MagickCompositeImage(wand->magickwand, composite_wand->magickwand, compose, rect.x, rect.y);
+        mwr_check_magickwand_error(wand->magickwand);
+    }
+
+    return obj;
+}
+
+
+
+
+/*
+ *  wand1 << wand2
+ *  concats images in wand2 to wand1
+ */
+static VALUE wand_concat(VALUE obj, VALUE obj2)
+{
+    Wand *wand, *wand2;
+
+    rb_check_frozen(obj);
+
+    Data_Get_Struct(obj, Wand, wand);
+    Data_Get_Struct(obj2, Wand, wand2);
+
+    MagickSetLastIterator(wand->magickwand);
+    MagickAddImage(wand->magickwand, wand2->magickwand);
+    mwr_check_magickwand_error(wand->magickwand);
+    return obj;
+}
+
+
+
+
+/*
+ *  wand.crop(width, height=width, :x=>x, :y=y, :gravity=gravity, :repage=boolean)
+ *  x and y default to 0
+ *  gravity defaults to NorthWestGravity
+ *  repage defaults to true
+ */
+static VALUE wand_crop(int argc, VALUE *argv, VALUE obj)
+{
+    Wand *wand;
+    Image *image;
+    volatile VALUE width, height, options;
+    VALUE v;
+    unsigned long columns, rows;
+    long x, y;
+    GravityType gravity;
+    GravityType keep_gravity;
+    int repage;
+    RectangleInfo rect;
+    char geometry[200];
+    ExceptionInfo exception;
+
+    rb_check_frozen(obj);
+
+    (void) rb_scan_args(argc, argv, "12", &width, &height, &options);
+    columns = NUM2ULONG(width);
+    if (height != Qnil)
+    {
+        rows = NUM2ULONG(height);
+    }
+    else
+    {
+        rows = columns;
+    }
+    (void) mwr_get_option(options, "gravity", &v);
+    gravity = mwr_string_to_gravitytype(v, NorthWestGravity, RaiseUndefinedOption);
+    x = mwr_get_option(options, "x", &v) ? FIX2LONG(v) : 0L;
+    y = mwr_get_option(options, "y", &v) ? FIX2LONG(v) : 0L;
+    repage = mwr_get_option(options, "repage", &v) ? RTEST(v) : 1;
+
+    (void) sprintf(geometry, "%lux%lu%+ld%+ld", columns, rows, x, y);
+
+    Data_Get_Struct(obj, Wand, wand);
+    GetExceptionInfo(&exception);
+
+    MagickResetIterator(wand->magickwand);
+
+    // Crop each image individually. If they're different sizes then the
+    // crop rectangle could be different.
+    while (MagickNextImage(wand->magickwand) != MagickFalse)
+    {
+        image = GetImageFromMagickWand(wand->magickwand);
+        mwr_check_magickwand_error(wand->magickwand);
+        keep_gravity = image->gravity;
+        image->gravity = gravity;
+        memset(&rect, 0, sizeof(rect));
+        (void) ParseGravityGeometry(image, geometry, &rect, &exception);
+        MagickCropImage(wand->magickwand, rect.width, rect.height, rect.x, rect.y);
+        image->gravity = keep_gravity;
+        mwr_check_magickwand_error(wand->magickwand);
+        if (repage)
+        {
+            MagickResetImagePage(wand->magickwand, "0x0+0+0");
+            mwr_check_magickwand_error(wand->magickwand);
+        }
+    }
+
+    DestroyExceptionInfo(&exception);
+
+    return obj;
+}
+
+
+
+
+/*
+ *  depth = wand.depth
+ */
+static VALUE wand_depth(VALUE obj)
+{
+    Wand *wand;
+
+    Data_Get_Struct(obj, Wand, wand);
+    if (MagickGetNumberImages(wand->magickwand) == 0UL)
+    {
+        return Qnil;
+    }
+
+    MagickResetIterator(wand->magickwand);
+    return ULONG2NUM(MagickGetImageDepth(wand->magickwand));
+}
+
+
+
+
+/*
+ *  [width, height] = wand.dimensions
+ *  returns width, height of 1st/only image
+ */
+static VALUE wand_dimensions(VALUE obj)
+{
+    Wand *wand;
+    volatile VALUE dimensions;
+    unsigned long width, height;
+
+    Data_Get_Struct(obj, Wand, wand);
+    if (MagickGetNumberImages(wand->magickwand) == 0UL)
+    {
+        return Qnil;
+    }
+
+    MagickResetIterator(wand->magickwand);
+
+    dimensions = rb_ary_new2(2);
+
+    width = MagickGetImageWidth(wand->magickwand);
+    mwr_check_magickwand_error(wand->magickwand);
+    rb_ary_push(dimensions, ULONG2NUM(width));
+
+    height = MagickGetImageHeight(wand->magickwand);
+    mwr_check_magickwand_error(wand->magickwand);
+    rb_ary_push(dimensions, ULONG2NUM(height));
+
+    return dimensions;
+}
+
+
+
+
+static VALUE wand_display(VALUE obj)
+{
+    Wand *wand;
+
+    Data_Get_Struct(obj, Wand, wand);
+    MagickDisplayImages(wand->magickwand, NULL);
+    mwr_check_magickwand_error(wand->magickwand);
+    return obj;
+}
+
+
+
+
+/*
+ *  (>= 1.8.7) if no block return enumerator
+ */
+static VALUE wand_each(VALUE obj)
+{
+    Wand *wand;
+    unsigned long n, nimages;
+
+#if defined(HAVE_RB_ENUMERATORIZE)
+    if (!rb_block_given_p())
+    {
+        return rb_enumeratorize(obj, ID2SYM(rb_frame_this_func()), 0, 0);
+    }
+#endif
+
+    Data_Get_Struct(obj, Wand, wand);
+
+    // Can't use the typical Reset/GetNext loop here. The block
+    // may change the wand's iterator.
+    nimages = MagickGetNumberImages(wand->magickwand);
+    for (n = 0; n < nimages; n++)
+    {
+        MagickSetIteratorIndex(wand->magickwand, n);
+        rb_yield(wand_new(MagickGetImage(wand->magickwand)));
+    }
+
+    return obj;
+}
+
+
+
+
+/*
+ *  returns true if wand.length == 0
+ */
+static VALUE wand_empty(VALUE obj)
+{
+    Wand *wand;
+
+    Data_Get_Struct(obj, Wand, wand);
+    return MagickGetNumberImages(wand->magickwand) == 0UL ? Qtrue : Qfalse;
+}
+
+
+
+
+/*
+ *  wand.eql?(wand2)
+ *  returns true if wand <=> wand2 returns 0
+ */
+static VALUE wand_eql(VALUE obj, VALUE obj2)
+{
+    volatile VALUE eql;
+
+    eql = wand_cmp(obj, obj2);
+    return FIX2INT(eql) == 0 ? Qtrue : Qfalse;
+}
+
+
+
+
+static size_t get_stg_type_size(StorageType stg_type)
+{
+    size_t size;
+
+    switch (stg_type)
+    {
+        case CharPixel:
+            size = 1;
+            break;
+        case ShortPixel:
+            size = sizeof(short);
+            break;
+        case IntegerPixel:
+            size = sizeof(int);
+            break;
+        case LongPixel:
+            size = sizeof(long);
+            break;
+        case QuantumPixel:
+            size = sizeof(Quantum);
+            break;
+        case FloatPixel:
+            size = sizeof(float);
+            break;
+        case DoublePixel:
+            size = sizeof(double);
+            break;
+        default:
+            rb_bug("undefined storage type");
+            break;
+    }
+
+    return size;
+}
+
+
+
+/*
+ *  str = wand.export_pixels(x, y, width, height, :storage_type=>"char", :map=>"rgb")
+ */
+static VALUE wand_export_pixels(int argc, VALUE *argv, VALUE obj)
+{
+    Wand *wand;
+    VALUE x_off, y_off, width, height, options, v, pixels;
+    long x, y, length;
+    unsigned long columns, rows;
+    StorageType stg_type;
+    char *map;
+    size_t stg_type_size;
+
+    (void) rb_scan_args(argc, argv, "41", &x_off, &y_off, &width, &height, &options);
+    x = FIX2LONG(x_off);
+    y = FIX2LONG(y_off);
+    columns = NUM2ULONG(width);
+    rows = NUM2ULONG(height);
+    (void) mwr_get_option(options, "map", &v);
+    map = v != Qnil ? StringValuePtr(v) : "RGB";
+    (void) mwr_get_option(options, "storage_type", &v);
+    stg_type = mwr_string_to_storagetype(v, CharPixel, RaiseUndefinedOption);
+    stg_type_size = get_stg_type_size(stg_type);
+
+    if (strlen(map) == 0)
+    {
+        rb_raise(rb_eArgError, "no map specified");
+    }
+    length = (long) (columns * rows * strlen(map) * stg_type_size);
+
+
+    // Allocate a string long enough to hold the exported pixel data.
+    pixels = rb_str_new2("");
+    (void) rb_str_resize(pixels, length);
+
+    Data_Get_Struct(obj, Wand, wand);
+    MagickResetIterator(wand->magickwand);
+    MagickExportImagePixels(wand->magickwand, x, y, columns, rows, map, stg_type, RSTRING_PTR(pixels));
+    mwr_check_magickwand_error(wand->magickwand);
+
+    return pixels;
+}
+
+
+
+
+static VALUE wand_filename(VALUE obj)
+{
+    Wand *wand;
+    char *f;
+    volatile VALUE filename;
+
+    Data_Get_Struct(obj, Wand, wand);
+    if (MagickGetNumberImages(wand->magickwand) == 0UL)
+    {
+        return Qnil;
+    }
+
+    MagickResetIterator(wand->magickwand);
+    f = MagickGetImageFilename(wand->magickwand);
+    mwr_check_magickwand_error(wand->magickwand);
+    filename = rb_str_new2(f);
+    MagickRelinquishMemory(f);
+
+    return filename;
+
+}
+
+
+
+
+/*
+ *  format = wand.format
+ */
+static VALUE wand_format(VALUE obj)
+{
+    Wand *wand;
+    char *f;
+    volatile VALUE format;
+
+    Data_Get_Struct(obj, Wand, wand);
+    if (MagickGetNumberImages(wand->magickwand) == 0UL)
+    {
+        return Qnil;
+    }
+
+    MagickResetIterator(wand->magickwand);
+    f = MagickGetImageFormat(wand->magickwand);
+    mwr_check_magickwand_error(wand->magickwand);
+    format = rb_str_new2(f);
+    MagickRelinquishMemory(f);
+
+    return format;
+}
+
+
+
+
+/*
+ *  private method
+ *  [new_width, new_height] = wand.get_resize_geometry(geometry_string)
+ */
+static VALUE wand_get_resize_geometry(VALUE obj, VALUE geometry)
+{
+    Wand *wand;
+    Image *image;
+    volatile VALUE resize_geometry;
+    RectangleInfo rect;
+    unsigned int flags;
+
+    Data_Get_Struct(obj, Wand, wand);
+    MagickResetIterator(wand->magickwand);
+    image = GetImageFromMagickWand(wand->magickwand);
+    mwr_check_magickwand_error(wand->magickwand);
+
+    memset(&rect, 0, sizeof(rect));
+    SetGeometry(image, &rect);
+    flags = ParseMetaGeometry(StringValuePtr(geometry), &rect.x, &rect.y, &rect.width, &rect.height);
+    if (flags == NoValue)
+    {
+        rb_raise(rb_eArgError, "invalid geometry `%s'", StringValuePtr(geometry));
+    }
+
+    resize_geometry = rb_ary_new2(2);
+    rb_ary_store(resize_geometry, 0L, ULONG2NUM(rect.width));
+    rb_ary_store(resize_geometry, 1L, ULONG2NUM(rect.height));
+
+    return resize_geometry;
+}
+
+
+
+
+/*
+ *  wand.import_pixels(x, y, columns, rows, pixels, :map=>"rgb", :storage_type=>"char")
+ *  imports into the first image in the wand
+ */
+static VALUE wand_import_pixels(int argc, VALUE *argv, VALUE obj)
+{
+    Wand *wand;
+    VALUE columns, rows, pixels, options, x_off, y_off, v;
+    unsigned long width, height, length;
+    long x, y;
+    void *data;
+    StorageType stg_type;
+    char *map;
+    size_t stg_type_size;
+
+    rb_check_frozen(obj);
+
+    (void) rb_scan_args(argc, argv, "51", &x_off, &y_off, &columns, &rows, &pixels, &options);
+    x = NUM2LONG(x_off);
+    y = NUM2LONG(y_off);
+    width = NUM2ULONG(columns);
+    height = NUM2ULONG(rows);
+    StringValue(pixels);
+    data = (void *) RSTRING_PTR(pixels);
+    length = (unsigned long) RSTRING_LEN(pixels);
+
+    (void) mwr_get_option(options, "map", &v);
+    map = v != Qnil ? StringValuePtr(v) : "RGB";
+    (void) mwr_get_option(options, "storage_type", &v);
+    stg_type = mwr_string_to_storagetype(v, CharPixel, RaiseUndefinedOption);
+    stg_type_size = get_stg_type_size(stg_type);
+
+    if (length < width*height*stg_type_size*strlen(map))
+    {
+        rb_raise(rb_eArgError, "pixel buffer too small (expecting %lu got %lu)",
+            width*height*stg_type_size*strlen(map), length);
+    }
+
+    Data_Get_Struct(obj, Wand, wand);
+    MagickResetIterator(wand->magickwand);
+    MagickImportImagePixels(wand->magickwand, x, y, width, height, map, stg_type, data);
+    mwr_check_magickwand_error(wand->magickwand);
+
+    return obj;
+}
+
+
+
+
+/*
+ *  wand.hash is the same as wand.signature.hash
+ */
+static VALUE wand_hash(VALUE obj)
+{
+    volatile VALUE signature;
+    Wand *wand;
+
+    Data_Get_Struct(obj, Wand, wand);
+    if (MagickGetNumberImages(wand->magickwand) == 0UL)
+    {
+        return INT2FIX(0);
+    }
+
+    signature = wand_signature(obj);
+    return INT2FIX(rb_str_hash(signature));
+}
+
+
+
+
+/*
+ *  wand.insert(index, wand2)
+ *  Inserts images from wand2 before the image at the given index, modifying
+ *  wand.
+ */
+static VALUE wand_insert(VALUE obj, VALUE index, VALUE obj2)
+{
+    Wand *wand, *wand2;
+    long pos;
+
+    Data_Get_Struct(obj, Wand, wand);
+    Data_Get_Struct(obj2, Wand, wand2);
+
+    rb_check_frozen(obj);
+
+    pos = FIX2LONG(index);
+    if (pos == -1)
+    {
+        pos = (long) MagickGetNumberImages(wand->magickwand);
+    }
+    else if (pos < 0)
+    {
+        pos += 1;
+    }
+
+    return splice(obj, pos, 0, obj2);
+}
+
+
+
+
+/*
+ *  The inspect string is intended to be quite similar to the output
+ *  of the identify command, without the -verbose option.
+ *  Largely lifted from ImageMagick's IdentifyImage function.
+ */
+static VALUE wand_inspect(VALUE obj)
+{
+    Wand *wand;
+    volatile VALUE inspect = rb_str_new2("(");
+    Image *image;
+    double elapsed_time;
+    double user_time;
+    unsigned long index = 0UL;
+    unsigned long columns, rows;
+    unsigned long width, height;
+    long x, y;
+    char *filename, *format;
+    char buff[MaxTextExtent];
+    ImageType image_type;
+
+    Data_Get_Struct(obj, Wand, wand);
+
+    if (MagickGetNumberImages(wand->magickwand) == 0UL)
+    {
+        return rb_str_new2("()");
+    }
+
+    MagickResetIterator(wand->magickwand);
+
+    while (MagickNextImage(wand->magickwand) != MagickFalse)
+    {
+        if (index > 0UL)
+        {
+            (void) rb_str_cat(inspect, "\n", 1);
+        }
+
+        image = GetImageFromMagickWand(wand->magickwand);
+        mwr_check_magickwand_error(wand->magickwand);
+
+        // magick_filename, filename
+        if (*image->magick_filename != '\0')
+        {
+            filename = MagickGetImageFilename(wand->magickwand);
+            if (strcmp(image->magick_filename, filename) != 0)
+            {
+                (void) rb_str_cat2(inspect, image->magick_filename);
+                (void) rb_str_cat(inspect, "=>", 2);
+            }
+            if (index == 0)
+            {
+                (void) rb_str_cat2(inspect, filename);
+            }
+            else
+            {
+                (void) rb_str_cat2(inspect, filename);
+                (void) sprintf(buff, "[%lu]", index);
+                (void) rb_str_cat2(inspect, buff);
+            }
+            MagickRelinquishMemory(filename);
+        }
+
+        // format
+        format = MagickGetImageFormat(wand->magickwand);
+        if (*format != '\0')
+        {
+            (void) sprintf(buff, " %s", format);
+            (void) rb_str_cat2(inspect, buff);
+        }
+        MagickRelinquishMemory(format);
+        (void) rb_str_cat(inspect, " ", 1);
+
+        // dimensions
+        columns = MagickGetImageWidth(wand->magickwand);
+        rows = MagickGetImageHeight(wand->magickwand);
+        if (image->magick_columns != 0 || image->magick_rows != 0)
+        {
+            if (image->magick_columns != columns || image->magick_rows != rows)
+            {
+                (void) sprintf(buff, "%lux%lu=>", image->magick_columns, image->magick_rows);
+                (void) rb_str_cat2(inspect, buff);
+            }
+        }
+        (void) sprintf(buff, "%lux%lu ", columns, rows);
+        (void) rb_str_cat2(inspect, buff);
+
+        // page
+        MagickGetImagePage(wand->magickwand, &width, &height, &x, &y);
+        if (width != 0 || height != 0 || x != 0 || y != 0)
+        {
+            (void) sprintf(buff,"%lux%lu%+ld%+ld ", width, height, x, y);
+            (void) rb_str_cat2(inspect, buff);
+        }
+
+        (void) sprintf(buff, "%lu-bit ", MagickGetImageDepth(wand->magickwand));
+        (void) rb_str_cat2(inspect, buff);
+
+        image_type = MagickGetImageType(wand->magickwand);
+        if (image_type != UndefinedType)
+        {
+            (void) rb_str_cat2(inspect, mwr_imagetype_to_s(image_type));
+            (void) rb_str_cat(inspect, " ", 1);
+        }
+
+        if (image->storage_class == DirectClass)
+        {
+            (void) rb_str_cat2(inspect, "DirectClass ");
+            if (image->total_colors != 0)
+            {
+                (void) rb_str_cat2(inspect, mwr_format_size(image->total_colors, buff));
+            }
+        }
+        else
+        {
+            (void) rb_str_cat2(inspect, "PseudoClass ");
+            if (image->total_colors <= image->colors)
+            {
+                (void) sprintf(buff, "%luc", image->colors);
+            }
+            else
+            {
+                (void) sprintf(buff, "%lu=>%luc", image->total_colors, image->colors);
+            }
+            (void) rb_str_cat2(inspect, buff);
+        }
+
+        if (image->error.mean_error_per_pixel != 0.0)
+        {
+            (void) sprintf(buff, ".%ld/%f/%fdb",(long) (image->error.mean_error_per_pixel+0.5),
+                    image->error.normalized_mean_error, image->error.normalized_maximum_error);
+            (void) rb_str_cat2(inspect, buff);
+        }
+
+
+        if (GetBlobSize(image) != 0)
+        {
+            (void) rb_str_cat(inspect, " ", 1);
+            (void) rb_str_cat2(inspect, mwr_format_size(GetBlobSize(image), buff));
+        }
+
+        if (elapsed_time > 0.06)
+        {
+            elapsed_time = GetElapsedTime(&image->timer);
+            user_time = GetUserTime(&image->timer);
+            (void) sprintf(buff, " %0.3fu %ld:%02ld", user_time,
+                (long) (elapsed_time/60.0+0.5),(long) ceil(fmod(elapsed_time, 60.0)));
+            (void) rb_str_cat2(inspect, buff);
+        }
+
+        index += 1UL;
+    }
+
+    rb_str_cat(inspect, ")", 1);
+    return inspect;
+}
+
+
+
+
+/*
+ *  wand = MagickWand::Wand.new
+ *  accepts no arguments
+ *  wand_allocate just creates an empty Wand structure. Here we add a new, empty
+ *  MagickWand.
+ */
+static VALUE wand_initialize(VALUE obj)
+{
+    Wand *wand;
+
+    Data_Get_Struct(obj, Wand, wand);
+    wand->magickwand = NewMagickWand();
+
+    return obj;
+}
+
+
+
+
+/*
+ *  wand2 = wand.dup
+ *  wand2 = wand.clone
+ */
+static VALUE wand_initialize_copy(VALUE obj, VALUE obj2)
+{
+    Wand *wand, *wand2;
+
+    if (obj == obj2)
+    {
+        return obj;
+    }
+
+    Data_Get_Struct(obj, Wand, wand);
+    Data_Get_Struct(obj2, Wand, wand2);
+
+    wand->magickwand = CloneMagickWand(wand2->magickwand);
+    return obj;
+}
+
+
+
+
+/*
+ *  Wand#length - the number of images in the wand
+ */
+static VALUE wand_length(VALUE obj)
+{
+    Wand *wand;
+
+    Data_Get_Struct(obj, Wand, wand);
+    return LONG2FIX((long)MagickGetNumberImages(wand->magickwand));
+}
+
+
+
+
+/*
+ *  Brightness is required. Saturation and hue default to 100% (no change).
+ *  Same defaults as the -modulate option. See magick/enhance.c.
+ */
+static VALUE wand_modulate(int argc, VALUE *argv, VALUE obj)
+{
+    Wand *wand;
+    volatile VALUE brightness, saturation, hue;
+    double h, s, l;
+
+    rb_check_frozen(obj);
+
+    (void) rb_scan_args(argc, argv, "12", &brightness, &saturation, &hue);
+    l = NUM2DBL(brightness);
+    s = saturation != Qnil ? NUM2DBL(saturation) : 100.0;
+    h = hue != Qnil ? NUM2DBL(hue) : 100.0;
+
+    Data_Get_Struct(obj, Wand, wand);
+    MagickResetIterator(wand->magickwand);
+    while (MagickNextImage(wand->magickwand) != MagickFalse)
+    {
+        MagickModulateImage(wand->magickwand, l, s, h);
+        mwr_check_magickwand_error(wand->magickwand);
+    }
+
+    return obj;
+}
+
+
+
+
+/*
+ *  Construct a new Wand object from a MagickWand.
+ */
+static VALUE wand_new(MagickWand *magickwand)
+{
+    VALUE obj;
+    Wand *wand;
+
+    obj = Data_Make_Struct(mwr_cWand, Wand, NULL, wand_destroy, wand);
+    if (magickwand)
+    {
+        if (IsMagickWand(magickwand) == MagickTrue)
+        {
+            wand->magickwand = magickwand;
+        }
+        else
+        {
+            rb_bug("invalid MagickWand used for object allocation");
+        }
+    }
+    else
+    {
+        wand->magickwand = NewMagickWand();
+    }
+
+    return obj;
+}
+
+
+
+
+/*
+ *  [width, height, x, y] = wand.page
+ */
+static VALUE wand_page(VALUE obj)
+{
+    Wand *wand;
+    volatile VALUE page;
+    unsigned long width, height;
+    long x, y;
+
+    Data_Get_Struct(obj, Wand, wand);
+    if (MagickGetNumberImages(wand->magickwand) == 0UL)
+    {
+        return Qnil;
+    }
+
+    MagickResetIterator(wand->magickwand);
+    MagickGetImagePage(wand->magickwand, &width, &height, &x, &y);
+    mwr_check_magickwand_error(wand->magickwand);
+
+    page = rb_ary_new2(4);
+    rb_ary_push(page, ULONG2NUM(width));
+    rb_ary_push(page, ULONG2NUM(height));
+    rb_ary_push(page, LONG2NUM(x));
+    rb_ary_push(page, LONG2NUM(y));
+
+    return page;
+}
+
+
+
+
+/*
+ *  objc = obja + objb
+ *  creates a new wand from the images in obja and objb
+ */
+static VALUE wand_plus(VALUE obj, VALUE obj2)
+{
+    Wand *wand, *wand2;
+    MagickWand *temp, *new_magickwand;
+
+    Data_Get_Struct(obj, Wand, wand);
+    Data_Get_Struct(obj2, Wand, wand2);
+
+    new_magickwand = CloneMagickWand(wand->magickwand);
+    MagickResetIterator(wand2->magickwand);
+    while (MagickNextImage(wand2->magickwand) != MagickFalse)
+    {
+        MagickSetLastIterator(new_magickwand);
+        temp = MagickGetImage(wand2->magickwand);
+        mwr_check_magickwand_error(wand2->magickwand);
+        MagickAddImage(new_magickwand, temp);
+        temp = DestroyMagickWand(temp);
+        mwr_check_magickwand_error(new_magickwand);
+    }
+
+    return wand_new(new_magickwand);
+}
+
+
+
+
+/*
+ *  shared between MagickReadImage and MagickPingImage
+ */
+static VALUE read(int argc, VALUE *argv, VALUE obj, MagickBooleanType (*reader)(MagickWand *, const char *))
+{
+    volatile VALUE fname, options;
+    Wand *wand;
+    const char *filename;
+
+    rb_check_frozen(obj);
+
+    (void) rb_scan_args(argc, argv, "11", &fname, &options);
+    filename = StringValuePtr(fname);
+    mwr_process_options(obj, options);
+
+    Data_Get_Struct(obj, Wand, wand);
+
+    // Add to the end.
+    MagickSetLastIterator(wand->magickwand);
+    (void) (*reader)(wand->magickwand, filename);
+    mwr_check_magickwand_error(wand->magickwand);
+
+    return obj;
+}
+
+
+
+
+/*
+ *  Does not read pixel data. Gets only the image dimensions, type, and length.                                                                                                                                                                                                                      .
+ *  An image filename is mandantory, optionally followed by an options hash.
+ *  Multiple reads are possible. Each call adds the new images to the wand .                                                                       .
+ */
+static VALUE wand_ping(int argc, VALUE *argv, VALUE obj)
+{
+    return read(argc, argv, obj, MagickPingImage);
+}
+
+
+
+
+/*
+ *  An image filename is mandantory, optionally followed by an options hash.
+ *  Multiple reads are possible. Each call adds the new images to the wand.
+ */
+static VALUE wand_read(int argc, VALUE *argv, VALUE obj)
+{
+    return read(argc, argv, obj, MagickReadImage);
+}
+
+
+
+
+/*
+ *  shared with wand_read_string and wand_ping_string
+ */
+static VALUE read_string(int argc, VALUE *argv, VALUE obj,
+    MagickBooleanType(*reader)(MagickWand *, const void *, size_t))
+{
+    VALUE string, options;
+    const void *blob;
+    size_t length;
+    Wand *wand;
+
+    rb_check_frozen(obj);
+    (void)rb_scan_args(argc, argv, "11", &string, &options);
+
+    StringValue(string);
+    blob = (void *) RSTRING_PTR(string);
+    length = (size_t) RSTRING_LEN(string);
+
+    mwr_process_options(obj, options);
+
+    Data_Get_Struct(obj, Wand, wand);
+
+    // Add to the end.
+    MagickSetLastIterator(wand->magickwand);
+    (void) (*reader)(wand->magickwand, blob, length);
+    mwr_check_magickwand_error(wand->magickwand);
+
+    return obj;
+}
+
+
+
+
+/*
+ *  Does not read pixel data. Gets only the image dimensions, type, and length.                                                                                                                                                                                                                      .
+ *  wand.ping_string(string,...)
+ *  Reads one or more images from the string into the wand and adds them
+ *  to the *end* of the image list.
+ */
+static VALUE wand_ping_string(int argc, VALUE *argv, VALUE obj)
+{
+    return read_string(argc, argv, obj, MagickPingImageBlob);
+}
+
+
+
+/*
+ *  wand.read_string(string,...)
+ *  Reads one or more images from the string into the wand and adds them
+ *  to the *end* of the image list.
+ */
+static VALUE wand_read_string(int argc, VALUE *argv, VALUE obj)
+{
+    return read_string(argc, argv, obj, MagickReadImageBlob);
+}
+
+
+
+
+/*
+ *  resizes all the images in the wand to the specified dimensions
+ *  wand.resize(width, height=width, options)
+ *  valid options are :filter, :blur
+ */
+static VALUE wand_resize(int argc, VALUE *argv, VALUE obj)
+{
+    Wand *wand;
+    volatile VALUE width, height, options;
+    VALUE v;
+    double blur = 1.0;
+    unsigned long columns, rows;
+    FilterTypes filter = UndefinedFilter;
+
+    rb_check_frozen(obj);
+
+    (void) rb_scan_args(argc, argv, "12", &width, &height, &options);
+    columns = NUM2ULONG(width);
+    rows = (height != Qnil) ? NUM2ULONG(height) : columns;
+    (void) mwr_get_option(options, "filter", &v);
+    filter = mwr_string_to_filtertypes(v, UndefinedFilter, RaiseUndefinedOption);
+    if (mwr_get_option(options, "blur", &v) && v != Qnil)
+    {
+        blur = NUM2DBL(v);
+    }
+
+    Data_Get_Struct(obj, Wand, wand);
+
+    MagickResetIterator(wand->magickwand);
+    while (MagickNextImage(wand->magickwand) != MagickFalse)
+    {
+        MagickResizeImage(wand->magickwand, columns, rows, filter, blur);
+        mwr_check_magickwand_error(wand->magickwand);
+    }
+
+    return obj;
+}
+
+
+
+/*
+ *  x-res, y-res = wand.resolution
+ *  Retreives the resolution from the first image
+ */
+static VALUE wand_resolution(VALUE obj)
+{
+    Wand *wand;
+    double x_res, y_res;
+
+    Data_Get_Struct(obj, Wand, wand);
+    MagickResetIterator(wand->magickwand);
+    (void) MagickGetImageResolution(wand->magickwand, &x_res, &y_res);
+    mwr_check_magickwand_error(wand->magickwand);
+    return rb_ary_new3(2, rb_float_new(x_res), rb_float_new(y_res));
+}
+
+
+
+
+/*
+ *  wand.rotate(degrees, background = "white")
+ */
+static VALUE wand_rotate(int argc, VALUE *argv, VALUE obj)
+{
+    Wand *wand;
+    VALUE amount, background;
+    double degrees;
+    char *background_color = "white";
+    PixelWand *pixelwand;
+
+    rb_check_frozen(obj);
+
+    (void) rb_scan_args(argc, argv, "11", &amount, &background);
+    degrees = NUM2DBL(amount);
+    if (background != Qnil)
+    {
+        background_color = StringValuePtr(background);
+    }
+
+    pixelwand = NewPixelWand();
+    PixelSetColor(pixelwand, background_color);
+    mwr_check_pixelwand_error(pixelwand);
+
+    Data_Get_Struct(obj, Wand, wand);
+
+    MagickResetIterator(wand->magickwand);
+    while (MagickNextImage(wand->magickwand) != MagickFalse)
+    {
+        MagickRotateImage(wand->magickwand, pixelwand, degrees);
+        mwr_check_magickwand_error(wand->magickwand);
+    }
+
+    DestroyPixelWand(pixelwand);
+
+    return obj;
+}
+
+
+
+
+/*
+ *  :colorspace => "colorspace"
+ */
+#if defined(HAVE_MAGICKSETCOLORSPACE)
+static VALUE wand_set_colorspace(VALUE obj, VALUE colorspace)
+{
+    Wand *wand;
+    ColorspaceType type;
+
+    rb_check_frozen(obj);
+
+    type = mwr_string_to_colorspacetype(colorspace, UndefinedColorspace, RaiseUndefinedOption);
+    Data_Get_Struct(obj, Wand, wand);
+    MagickSetColorspace(wand->magickwand, type);
+    mwr_check_magickwand_error(wand->magickwand);
+    return obj;
+}
+#endif
+
+
+
+
+/*
+ *  :compress => "compression"
+ */
+static VALUE wand_set_compress(VALUE obj, VALUE compression)
+{
+    Wand *wand;
+    CompressionType type;
+
+    type = mwr_string_to_compressiontype(compression, UndefinedCompression, RaiseUndefinedOption);
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Wand, wand);
+    MagickSetCompression(wand->magickwand, type);
+    mwr_check_magickwand_error(wand->magickwand);
+    return obj;
+}
+
+
+
+
+/*
+ *  :depth => depth
+ */
+static VALUE wand_set_depth(VALUE obj, VALUE depth)
+{
+    Wand *wand;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Wand, wand);
+    MagickSetDepth(wand->magickwand, NUM2ULONG(depth));
+    mwr_check_magickwand_error(wand->magickwand);
+    return obj;
+}
+
+
+
+
+/*
+ *  :format => "format"
+ */
+static VALUE wand_set_format(VALUE obj, VALUE format)
+{
+    Wand *wand;
+    const MagickInfo *magick;
+    char *fmt;
+    ExceptionInfo exception;
+
+    rb_check_frozen(obj);
+
+    fmt = StringValuePtr(format);
+    GetExceptionInfo(&exception);
+    magick = GetMagickInfo(fmt, &exception);
+    DestroyExceptionInfo(&exception);
+    if (!magick)
+    {
+        rb_raise(rb_eArgError, "unknown format %s", fmt);
+    }
+
+    Data_Get_Struct(obj, Wand, wand);
+    MagickSetFormat(wand->magickwand, fmt);
+    mwr_check_magickwand_error(wand->magickwand);
+    return obj;
+}
+
+
+
+
+/*
+ *  :quality => quality
+ */
+static VALUE wand_set_quality(VALUE obj, VALUE quality)
+{
+    Wand *wand;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Wand, wand);
+    MagickSetCompressionQuality(wand->magickwand, NUM2ULONG(quality));
+    mwr_check_magickwand_error(wand->magickwand);
+    return obj;
+}
+
+
+
+/*
+ *  :size => "WxH"
+ */
+static VALUE wand_set_size(VALUE obj, VALUE size)
+{
+    Wand *wand;
+    GeometryInfo geometry;
+    MagickStatusType flags;
+    unsigned long columns = 0, rows = 0;
+
+    memset(&geometry, 0, sizeof(geometry));
+    flags = ParseGeometry(StringValuePtr(size), &geometry);
+    if (flags == NoValue)
+    {
+        mwr_option_value_error(":size", StringValuePtr(size));
+    }
+
+    columns = geometry.rho;
+    rows = geometry.sigma;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Wand, wand);
+    MagickSetSize(wand->magickwand, columns, rows);
+    mwr_check_magickwand_error(wand->magickwand);
+    return obj;
+}
+
+
+
+
+/*
+ *  :type = "type"
+ */
+static VALUE wand_set_type(VALUE obj, VALUE type)
+{
+    Wand *wand;
+    ImageType image_type = UndefinedType;
+
+    image_type = mwr_string_to_imagetype(type, UndefinedType, RaiseUndefinedOption);
+    Data_Get_Struct(obj, Wand, wand);
+    MagickSetType(wand->magickwand, image_type);
+    mwr_check_magickwand_error(wand->magickwand);
+    return obj;
+}
+
+
+
+
+/*
+ *  wand.sharpen(radius, sigma, :channel="default")
+ */
+static VALUE wand_sharpen(int argc, VALUE *argv, VALUE obj)
+{
+    return convolve(argc, argv, obj, MagickSharpenImageChannel);
+}
+
+
+
+
+/*
+ *  return 64-hex digit signature of the first image.
+ *  used to "compare" two wands for equality.
+ *  returns nil if no images in wand.
+ *  note: this is relatively slow operation the first time it's called
+ */
+static VALUE wand_signature(VALUE obj)
+{
+    Wand *wand;
+    char *sig;
+    volatile VALUE signature;
+
+    Data_Get_Struct(obj, Wand, wand);
+    if (MagickGetNumberImages(wand->magickwand) == 0UL)
+    {
+        return Qnil;
+    }
+
+    MagickSetFirstIterator(wand->magickwand);
+    sig = MagickGetImageSignature(wand->magickwand);
+    mwr_check_magickwand_error(wand->magickwand);
+    signature = rb_str_new2(sig);
+    RelinquishMagickMemory(sig);
+    return signature;
+}
+
+
+
+
+/*
+ *  wand.slice!(2) => deletes and returns a wand containing the 3rd image
+ *  wand.slice!(3..6) => deletes and returns a wand containing images 4, 5, 6
+ *
+ *  This code is essentially identical to rb_str_slice_bang in string.c.
+ */
+static VALUE wand_slice_bang(int argc, VALUE *argv, VALUE obj)
+{
+    volatile VALUE result;
+    VALUE buf[3];
+    int i;
+
+    if (argc < 1 || 2 < argc)
+    {
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
+    }
+
+    rb_check_frozen(obj);
+
+    for (i = 0; i < argc; i++)
+    {
+        buf[i] = argv[i];
+    }
+    buf[i] = wand_new(NULL);
+    result = wand_aref(argc, buf, obj);
+    if (!NIL_P(result))
+    {
+        wand_aset(argc+1, buf, obj);
+    }
+
+    return result;
+}
+
+
+
+
+/*
+ *  wand.strip()
+ */
+static VALUE wand_strip(VALUE obj)
+{
+    Wand *wand;
+
+    rb_check_frozen(obj);
+    Data_Get_Struct(obj, Wand, wand);
+    MagickResetIterator(wand->magickwand);
+    while (MagickNextImage(wand->magickwand) != MagickFalse)
+    {
+        MagickStripImage(wand->magickwand);
+        mwr_check_magickwand_error(wand->magickwand);
+    }
+
+    return obj;
+}
+
+
+
+
+/*
+ *  type = wand.type
+ */
+static VALUE wand_type(VALUE obj)
+{
+    Wand *wand;
+    ImageType image_type;
+
+    Data_Get_Struct(obj, Wand, wand);
+    if (MagickGetNumberImages(wand->magickwand) == 0UL)
+    {
+        return Qnil;
+    }
+
+    MagickResetIterator(wand->magickwand);
+    image_type = MagickGetImageType(wand->magickwand);
+    mwr_check_magickwand_error(wand->magickwand);
+
+    return rb_str_new2(mwr_imagetype_to_s(image_type));
+}
+
+
+
+
+/*
+ *  string = wand.write_string
+ *  returns the images as a string
+ */
+static VALUE wand_write_string(int argc, VALUE *argv, VALUE obj)
+{
+    Wand *wand;
+    VALUE options;
+    volatile VALUE str;
+    unsigned char *blob;
+    size_t length;
+    unsigned long nimages;
+
+    Data_Get_Struct(obj, Wand, wand);
+    nimages = MagickGetNumberImages(wand->magickwand);
+    if (nimages == 0UL)
+    {
+        return Qnil;
+    }
+
+    (void) rb_scan_args(argc, argv, "01", &options);
+    mwr_process_options(obj, options);
+
+    MagickResetIterator(wand->magickwand);
+    if (nimages == 1UL)
+    {
+        blob = MagickGetImageBlob(wand->magickwand, &length);
+    }
+    else
+    {
+        blob = MagickGetImagesBlob(wand->magickwand, &length);
+    }
+
+    str = rb_str_new((char *)blob, (long)length);
+    RelinquishMagickMemory(blob);
+
+    return str;
+}
+
+
+
+
+/*
+ *  wand.write(filename, :adjoin=>true)
+ */
+static VALUE wand_write(int argc, VALUE *argv, VALUE obj)
+{
+    Wand *wand;
+    volatile VALUE name, options;
+    VALUE v;
+    MagickBooleanType adjoin = MagickTrue;
+
+    (void) rb_scan_args(argc, argv, "11", &name, &options);
+    if (mwr_get_option(options, "adjoin", &v))
+    {
+        adjoin = RTEST(v) ? MagickTrue : MagickFalse;
+    }
+    mwr_process_options(obj, options);
+
+    Data_Get_Struct(obj, Wand, wand);
+    MagickResetIterator(wand->magickwand);
+    MagickWriteImages(wand->magickwand, StringValuePtr(name), adjoin);
+    mwr_check_magickwand_error(wand->magickwand);
+
+    return obj;
+}
+
+
+
+
+/*
+ *  MagickWand::Wand class
+ *  includes Comparable and Enumerable
+ */
+void mwr_init_Wand(void)
+{
+    mwr_cWand = rb_define_class_under(mwr_mMagickWand, "Wand", rb_cObject);
+    rb_include_module(mwr_cWand, rb_mComparable);
+    rb_include_module(mwr_cWand, rb_mEnumerable);
+    rb_define_alloc_func(mwr_cWand, wand_allocate);
+
+    // Support for Enumerable, Comparable, etc.
+    // Methods in Object that must be overridden per class
+    rb_define_method(mwr_cWand, "[]", wand_aref, -1);
+    rb_define_method(mwr_cWand, "[]=", wand_aset, -1);
+    rb_define_method(mwr_cWand, "<=>", wand_cmp, 1);
+    rb_define_method(mwr_cWand, "<<", wand_concat, 1);
+    rb_define_method(mwr_cWand, "each", wand_each, 0);
+    rb_define_method(mwr_cWand, "empty?", wand_empty, 0);
+    rb_define_method(mwr_cWand, "eql?", wand_eql, 1);
+    rb_define_method(mwr_cWand, "hash", wand_hash, 0);
+    rb_define_method(mwr_cWand, "initialize", wand_initialize, 0);
+    rb_define_method(mwr_cWand, "initialize_copy", wand_initialize_copy, 1);
+    rb_define_method(mwr_cWand, "insert", wand_insert, 2);
+    rb_define_method(mwr_cWand, "inspect", wand_inspect, 0);
+    rb_define_method(mwr_cWand, "length", wand_length, 0);
+    rb_define_method(mwr_cWand, "+", wand_plus, 1);
+    rb_define_method(mwr_cWand, "slice!", wand_slice_bang, -1);
+    rb_define_alias(mwr_cWand, "concat", "<<");
+    // Make an alias for Object#display
+    rb_define_alias(mwr_cWand, "__display__", "display");
+    rb_define_alias(mwr_cWand, "size", "length");
+    rb_define_alias(mwr_cWand, "slice", "[]");
+    // Object#type is not defined in 1.9.1
+#if defined(HAVE_RB_OBJ_TYPE)
+    rb_define_alias(mwr_cWand, "__type__", "type");
+#endif
+
+    // Private property setters are called during option processing
+#if defined(HAVE_MAGICKSETCOLORSPACE)
+    rb_define_private_method(mwr_cWand, "set_colorspace", wand_set_colorspace, 1);
+#endif
+    rb_define_private_method(mwr_cWand, "set_compress", wand_set_compress, 1);
+    rb_define_private_method(mwr_cWand, "set_depth", wand_set_depth, 1);
+    rb_define_private_method(mwr_cWand, "set_format", wand_set_format, 1);
+    rb_define_private_method(mwr_cWand, "set_quality", wand_set_quality, 1);
+    rb_define_private_method(mwr_cWand, "set_size", wand_set_size, 1);
+    rb_define_private_method(mwr_cWand, "set_type", wand_set_type, 1);
+
+    // Other private methods
+    rb_define_private_method(mwr_cWand, "get_resize_geometry", wand_get_resize_geometry, 1);
+
+    // Methods that bind to ImageMagick's MagickWand API
+    rb_define_method(mwr_cWand, "add_canvas", wand_add_canvas, -1);
+    rb_define_method(mwr_cWand, "animate", wand_animate, -1);
+    rb_define_method(mwr_cWand, "annotate", wand_annotate, -1);
+    rb_define_method(mwr_cWand, "background", wand_background, 0);
+    rb_define_method(mwr_cWand, "blur", wand_blur, -1);
+    rb_define_method(mwr_cWand, "border", wand_border, -1);
+    rb_define_method(mwr_cWand, "colors", wand_colors, 0);
+    rb_define_method(mwr_cWand, "comment", wand_comment, 0);
+    rb_define_method(mwr_cWand, "comment=", wand_comment_set, 1);
+    rb_define_method(mwr_cWand, "compare", wand_compare, -1);
+    rb_define_method(mwr_cWand, "composite", wand_composite, -1);
+    rb_define_method(mwr_cWand, "crop", wand_crop, -1);
+    rb_define_method(mwr_cWand, "depth", wand_depth, 0);
+    rb_define_method(mwr_cWand, "dimensions", wand_dimensions, 0);
+    rb_define_method(mwr_cWand, "display", wand_display, 0);
+    rb_define_method(mwr_cWand, "export_pixels", wand_export_pixels, -1);
+    rb_define_method(mwr_cWand, "filename", wand_filename, 0);
+    rb_define_method(mwr_cWand, "format", wand_format, 0);
+    rb_define_method(mwr_cWand, "import_pixels", wand_import_pixels, -1);
+    rb_define_method(mwr_cWand, "modulate", wand_modulate, -1);
+    rb_define_method(mwr_cWand, "page", wand_page, 0);
+    rb_define_method(mwr_cWand, "ping", wand_ping, -1);
+    rb_define_method(mwr_cWand, "ping_string", wand_ping_string, -1);
+    rb_define_method(mwr_cWand, "read", wand_read, -1);
+    rb_define_method(mwr_cWand, "read_string", wand_read_string, -1);
+    rb_define_method(mwr_cWand, "resize", wand_resize, -1);
+    rb_define_method(mwr_cWand, "resolution", wand_resolution, 0);
+    rb_define_method(mwr_cWand, "rotate", wand_rotate, -1);
+    rb_define_method(mwr_cWand, "sharpen", wand_sharpen, -1);
+    rb_define_method(mwr_cWand, "signature", wand_signature, 0);
+    rb_define_method(mwr_cWand, "strip", wand_strip, 0);
+    rb_define_method(mwr_cWand, "type", wand_type, 0);
+    rb_define_method(mwr_cWand, "write_string", wand_write_string, -1);
+    rb_define_method(mwr_cWand, "write", wand_write, -1);
+
+}