magickwand 0.1.0

data/ext/magickwand/magickwand.c

@@ -0,0 +1,152 @@
+/*
+ *  magickwand.c
+ *  $Id: magickwand.c 146 2009-05-31 22:00:57Z rmagick $
+ *  Copyright (C) 2009 Timothy Paul Hunter
+ */
+
+
+
+#define MAIN 1
+#include "magickwand.h"
+
+
+
+
+/*
+ *  Handle transferring ImageMagick memory allocations/frees to Ruby.
+ *  These functions have the same signature as the equivalent C functions.
+ */
+static void *mwr_malloc(size_t size)
+{
+    return xmalloc((long)size);
+}
+
+
+
+
+static void *mwr_realloc(void *ptr, size_t size)
+{
+    return xrealloc(ptr, (long)size);
+}
+
+
+
+
+static void mwr_free(void *ptr)
+{
+    xfree(ptr);
+}
+
+
+
+
+/*
+ *  Copy MagickWand configure options to a constant hash
+ */
+static void ImageMagick_config(void)
+{
+    volatile VALUE key, value;
+    volatile VALUE config_hash;
+    char **config;
+    char *option;
+    unsigned long n, n_config;
+    unsigned long qdepth, qrange;
+
+    config_hash = rb_hash_new();
+
+    config = MagickQueryConfigureOptions("*", &n_config);
+    for (n = 0; n < n_config; n++)
+    {
+        key = rb_str_new2(config[n]);
+        rb_obj_freeze(key);
+        option = MagickQueryConfigureOption(config[n]);
+        value = rb_str_new2(option);
+        rb_obj_freeze(value);
+        rb_hash_aset(config_hash, key, value);
+    }
+
+    rb_obj_freeze(config_hash);
+    rb_define_const(mwr_mMagickWand, "IMAGEMAGICK_CONFIG", config_hash);
+
+    (void) GetMagickQuantumDepth(&qdepth);
+    rb_define_const(mwr_mMagickWand, "QUANTUM_DEPTH", LONG2FIX((long)qdepth));
+
+    (void) GetMagickQuantumRange(&qrange);
+    rb_define_const(mwr_mMagickWand, "QUANTUM_RANGE", LONG2FIX((long)qrange));
+
+    rb_define_const(mwr_mMagickWand, "QUANTUM_SIZE", INT2FIX((int)sizeof(Quantum)));
+
+}
+
+
+
+
+static VALUE magickwand_list_fonts(VALUE mod)
+{
+    unsigned long n, nfonts;
+    char **fonts;
+    volatile VALUE font_ary;
+
+    font_ary = rb_ary_new();
+    fonts = MagickQueryFonts("*", &nfonts);
+    for (n = 0; n < nfonts; n++)
+    {
+        rb_ary_push(font_ary, rb_str_new2(fonts[n]));
+    }
+    return font_ary;
+    mod = mod;
+}
+
+
+
+
+/*
+ *  MagickWand.option_values(option-name)
+ *  returns the valid values of the specified option, or all options
+ *  if option-name is omitted. Values returned in a hash. The key
+ *  is the option name and the value is an array of option values.
+ */
+static VALUE magickwand_option_values(int argc, VALUE *argv, VALUE mod)
+{
+    volatile VALUE option;
+    char *name = NULL;
+
+    (void) rb_scan_args(argc, argv, "01", &option);
+    if (option != Qnil)
+    {
+        option = rb_String(option);
+        name = StringValuePtr(option);
+    }
+    return mwr_option_values_to_hash(name);
+    mod = mod;
+}
+
+
+
+
+/*
+ *  Initialize the MagickWand environment. Create the MagickWand module.
+ */
+void Init_magickwand(void)
+{
+    volatile VALUE version;
+
+    MagickWandGenesis();
+    SetMagickMemoryMethods(mwr_malloc, mwr_realloc, mwr_free);
+
+    mwr_mMagickWand = rb_define_module("MagickWand");
+
+    version = rb_str_new2(MAGICKWAND_VERSION);
+    rb_obj_freeze(version);
+    rb_define_const(mwr_mMagickWand, "VERSION", version);
+    rb_define_module_function(mwr_mMagickWand, "list_fonts", magickwand_list_fonts, 0);
+    rb_define_module_function(mwr_mMagickWand, "option_values", magickwand_option_values, -1);
+
+    ImageMagick_config();
+
+    mwr_init_Wand();
+    mwr_init_GC();
+    mwr_init_ImageMagickError();
+    mwr_init_FatalImageMagickError();
+
+}

data/ext/magickwand/magickwand.h

@@ -0,0 +1,91 @@
+/*
+ *  magickwand.h
+ *  $Id: magickwand.h 25 2009-04-28 23:11:33Z rmagick $
+ *  Copyright (C) 2009 Timothy Paul Hunter
+ */
+
+#if !defined(MAGICKWAND_H)
+#define MAGICKWAND_H 1
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "wand/MagickWand.h"
+#include "ruby.h"
+
+#undef EXTERN
+#if defined(MAIN)
+#define EXTERN
+#else
+#define EXTERN extern
+#endif
+
+
+
+/*
+ *  Types
+ */
+typedef struct
+{
+    MagickWand *magickwand;
+} Wand;
+
+
+typedef struct
+{
+    DrawingWand *drawingwand;
+} GC;
+
+
+// What to do when an option value is not in the list of defined option values
+typedef enum {
+    IgnoreUndefinedOption,
+    RaiseUndefinedOption
+} OnUndefinedOption;
+
+
+/*
+ *  Extern variables
+ */
+VALUE mwr_mMagickWand;
+VALUE mwr_cWand;
+VALUE mwr_cGC;
+VALUE mwr_eImageMagickError;
+VALUE mwr_eFatalImageMagickError;
+
+
+/*
+ *  Extern functions
+ */
+extern void mwr_init_GC(void);
+extern void mwr_init_Wand(void);
+extern void mwr_init_ImageMagickError(void);
+extern void mwr_init_FatalImageMagickError(void);
+extern void mwr_check_magickwand_error(MagickWand *);
+extern void mwr_check_pixelwand_error(PixelWand *);
+extern void mwr_check_drawingwand_error(DrawingWand *);
+extern void mwr_check_error(ExceptionInfo *);
+extern MagickBooleanType mwr_get_option(VALUE, const char *, VALUE *);
+extern char *mwr_imagetype_to_s(ImageType);
+extern VALUE mwr_pixelpacket_to_hex(Image *, PixelPacket *);
+extern void mwr_option_value_error(const char *, const char *);
+extern VALUE mwr_option_values_to_hash(char *);
+extern AlignType mwr_string_to_aligntype(VALUE, AlignType, OnUndefinedOption);
+extern ChannelType mwr_string_to_channeltype(VALUE, ChannelType, OnUndefinedOption);
+extern ColorspaceType mwr_string_to_colorspacetype(VALUE, ColorspaceType, OnUndefinedOption);
+extern CompositeOperator mwr_string_to_composetype(VALUE, CompositeOperator, OnUndefinedOption);
+extern CompressionType mwr_string_to_compressiontype(VALUE, CompressionType, OnUndefinedOption);
+extern DecorationType mwr_string_to_decorationtype(VALUE, DecorationType, OnUndefinedOption);
+extern FilterTypes mwr_string_to_filtertypes(VALUE, FilterTypes, OnUndefinedOption);
+extern GravityType mwr_string_to_gravitytype(VALUE, GravityType, OnUndefinedOption);
+extern ImageType mwr_string_to_imagetype(VALUE, ImageType, OnUndefinedOption);
+extern MetricType mwr_string_to_metrictype(VALUE, MetricType, OnUndefinedOption);
+extern StorageType mwr_string_to_storagetype(VALUE, StorageType, OnUndefinedOption);
+extern StretchType mwr_string_to_stretchtype(VALUE, StretchType, OnUndefinedOption);
+extern StyleType mwr_string_to_styletype(VALUE, StyleType, OnUndefinedOption);
+extern unsigned long mwr_string_to_weight(VALUE, unsigned long, OnUndefinedOption);
+extern char *mwr_format_size(const MagickSizeType, char *);
+extern void mwr_get_pixelpacket_from_pixelwand(PixelPacket *, PixelWand *);
+extern void mwr_get_pixelwand_from_pixelpacket(PixelWand *, PixelPacket *);
+extern void mwr_process_options(VALUE, VALUE);
+extern VALUE mwr_gc_new(void);
+#endif

data/ext/magickwand/utility.c

@@ -0,0 +1,819 @@
+
+/*
+ *  utility.c
+ *  $Id: utility.c 144 2009-05-31 20:51:53Z rmagick $
+ *  Copyright (C) 2009 Timothy Paul Hunter
+ */
+
+#include <math.h>
+#include <ctype.h>
+#include "magickwand.h"
+
+
+
+
+#define ENUMERATOR_STR(type) case type: str = #type; break
+
+
+
+
+typedef struct
+{
+    const char *name;
+    long type;
+} ValueList;
+
+
+typedef struct {
+    char *name;
+    ValueList *value;
+} OptionList;
+
+
+static ValueList align_types[] = {
+    { "center", (long) CenterAlign },
+    { "end",    (long) RightAlign  },
+    { "left",   (long) LeftAlign   },
+    { "middle", (long) CenterAlign },
+    { "right",  (long) RightAlign  },
+    { "start",  (long) LeftAlign   },
+    { NULL,     (long) UndefinedAlign } };
+static ValueList channel_types[] = {
+    { "all",        (long) AllChannels    },
+    { "alpha",      (long) OpacityChannel },
+    { "black",      (long) BlackChannel   },
+    { "blue",       (long) BlueChannel    },
+    { "cyan",       (long) CyanChannel    },
+    { "default",    (long) DefaultChannels},
+    { "gray",       (long) GrayChannel    },
+    { "green",      (long) GreenChannel   },
+    { "hue",        (long) RedChannel     },
+    { "index",      (long) IndexChannel   },
+    { "lightness",  (long) BlueChannel    },
+    { "luminance",  (long) BlueChannel    },
+    { "luminosity", (long) BlueChannel    },  /* deprecated */
+    { "magenta",    (long) MagentaChannel },
+    { "matte",      (long) OpacityChannel },
+    { "opacity",    (long) OpacityChannel },
+    { "red",        (long) RedChannel     },
+    { "saturation", (long) GreenChannel   },
+    { "yellow",     (long) YellowChannel  },
+    { NULL,         (long) UndefinedChannel} };
+static ValueList colorspace_types[] = {
+    { "cmy",         (long) CMYColorspace         },
+    { "cmyk",        (long) CMYKColorspace        },
+    { "gray",        (long) GRAYColorspace        },
+    { "hsb",         (long) HSBColorspace         },
+    { "hsl",         (long) HSLColorspace         },
+    { "hwb",         (long) HWBColorspace         },
+    { "lab",         (long) LabColorspace         },
+    { "log",         (long) LogColorspace         },
+    { "ohta",        (long) OHTAColorspace        },
+    { "rec601luma",  (long) Rec601LumaColorspace  },
+    { "rec601ycbcr", (long) Rec601YCbCrColorspace },
+    { "rec709luma",  (long) Rec709LumaColorspace  },
+    { "rec709ycbcr", (long) Rec709YCbCrColorspace },
+    { "rgb",         (long) RGBColorspace         },
+    { "srgb",        (long) sRGBColorspace        },
+    { "transparent", (long) TransparentColorspace },
+    { "xyz",         (long) XYZColorspace         },
+    { "ycbcr",       (long) YCbCrColorspace       },
+    { "ycc",         (long) YCCColorspace         },
+    { "yiq",         (long) YIQColorspace         },
+    { "ypbpr",       (long) YPbPrColorspace       },
+    { "yuv",         (long) YUVColorspace         },
+    { NULL,          (long) UndefinedColorspace   } };
+static ValueList compose_types[] = {
+    {  "add",         (long) AddCompositeOp         },
+    {  "atop",        (long) AtopCompositeOp        },
+    {  "blend",       (long) BlendCompositeOp       },
+    {  "bumpmap",     (long) BumpmapCompositeOp     },
+    {  "changemask",  (long) ChangeMaskCompositeOp  },
+    {  "clear",       (long) ClearCompositeOp       },
+    {  "colorburn",   (long) ColorBurnCompositeOp   },
+    {  "colordodge",  (long) ColorDodgeCompositeOp  },
+    {  "colorize",    (long) ColorizeCompositeOp    },
+    {  "copyblack",   (long) CopyBlackCompositeOp   },
+    {  "copyblue",    (long) CopyBlueCompositeOp    },
+    {  "copycyan",    (long) CopyCyanCompositeOp    },
+    {  "copygreen",   (long) CopyGreenCompositeOp   },
+    {  "copy",        (long) CopyCompositeOp        },
+    {  "copymagenta", (long) CopyMagentaCompositeOp },
+    {  "copyopacity", (long) CopyOpacityCompositeOp },
+    {  "copyred",     (long) CopyRedCompositeOp     },
+    {  "copyyellow",  (long) CopyYellowCompositeOp  },
+    {  "darken",      (long) DarkenCompositeOp      },
+    {  "divide",      (long) DivideCompositeOp      },
+    {  "dst",         (long) DstCompositeOp         },
+    {  "difference",  (long) DifferenceCompositeOp  },
+    {  "displace",    (long) DisplaceCompositeOp    },
+    {  "dissolve",    (long) DissolveCompositeOp    },
+    {  "dstatop",     (long) DstAtopCompositeOp     },
+    {  "dstin",       (long) DstInCompositeOp       },
+    {  "dstout",      (long) DstOutCompositeOp      },
+    {  "dstover",     (long) DstOverCompositeOp     },
+    {  "dst",         (long) DstCompositeOp         },
+    {  "exclusion",   (long) ExclusionCompositeOp   },
+    {  "hardlight",   (long) HardLightCompositeOp   },
+    {  "hue",         (long) HueCompositeOp         },
+    {  "in",          (long) InCompositeOp          },
+    {  "lighten",     (long) LightenCompositeOp     },
+    {  "linearlight", (long) LinearLightCompositeOp },
+    {  "luminize",    (long) LuminizeCompositeOp    },
+    {  "minus",       (long) MinusCompositeOp       },
+    {  "modulate",    (long) ModulateCompositeOp    },
+    {  "multiply",    (long) MultiplyCompositeOp    },
+    {  "none",        (long) NoCompositeOp          },
+    {  "out",         (long) OutCompositeOp         },
+    {  "overlay",     (long) OverlayCompositeOp     },
+    {  "over",        (long) OverCompositeOp        },
+    {  "plus",        (long) PlusCompositeOp        },
+    {  "replace",     (long) ReplaceCompositeOp     },
+    {  "saturate",    (long) SaturateCompositeOp    },
+    {  "screen",      (long) ScreenCompositeOp      },
+    {  "softlight",   (long) SoftLightCompositeOp   },
+    {  "src",         (long) SrcCompositeOp         },
+    {  "srcatop",     (long) SrcAtopCompositeOp     },
+    {  "srcin",       (long) SrcInCompositeOp       },
+    {  "srcout",      (long) SrcOutCompositeOp      },
+    {  "srcover",     (long) SrcOverCompositeOp     },
+    {  "src",         (long) SrcCompositeOp         },
+    {  "subtract",    (long) SubtractCompositeOp    },
+    {  "threshold",   (long) ThresholdCompositeOp   },
+    {  "xor",         (long) XorCompositeOp         },
+    {  NULL,          (long) UndefinedCompositeOp   } };
+static ValueList compression_types[] = {
+    { "bzip",             (long) BZipCompression         },
+    { "dxt1",             (long) DXT1Compression         },
+    { "dxt3",             (long) DXT3Compression         },
+    { "dxt5",             (long) DXT5Compression         },
+    { "fax",              (long) FaxCompression          },
+    { "group4",           (long) Group4Compression       },
+    { "jpeg",             (long) JPEGCompression         },
+    { "jpeg2000",         (long) JPEG2000Compression     },
+    { "lossless",         (long) LosslessJPEGCompression },
+    { "losslessjpeg",     (long) LosslessJPEGCompression },
+    { "lzw",              (long) LZWCompression          },
+    { "none",             (long) NoCompression           },
+    { "rle",              (long) RLECompression          },
+    { "zip",              (long) ZipCompression          },
+    { "runlengthencoded", (long) RLECompression          },
+    { NULL,               (long) UndefinedCompression    } };
+static ValueList decoration_types[] = {
+    { "linethrough", (long) LineThroughDecoration },
+    { "none",        (long) NoDecoration          },
+    { "overline",    (long) OverlineDecoration    },
+    { "underline",   (long) UnderlineDecoration   },
+    { NULL,          (long) UndefinedDecoration   } };
+static ValueList filter_types[] = {
+    {"bartlett",  (long) BartlettFilter},
+    {"bessel",    (long) BesselFilter},
+    {"blackman",  (long) BlackmanFilter},
+    {"bohman",    (long) BohmanFilter},
+    {"box",       (long) BoxFilter},
+    {"catrom",    (long) CatromFilter},
+    {"cubic",     (long) CubicFilter},
+    {"gaussian",  (long) GaussianFilter},
+    {"hamming",   (long) HammingFilter},
+    {"hanning",   (long) HanningFilter},
+    {"hermite",   (long) HermiteFilter},
+    {"kaiser",    (long) KaiserFilter},
+    {"lagrange",  (long) LagrangeFilter},
+    {"lanczos",   (long) LanczosFilter},
+    {"mitchell",  (long) MitchellFilter},
+    {"parzen",    (long) ParzenFilter},
+    {"point",     (long) PointFilter},
+    {"quadratic", (long) QuadraticFilter},
+    {"sinc",      (long) SincFilter},
+    {"triangle",  (long) TriangleFilter},
+    {"welsh",     (long) WelshFilter},
+    {NULL,        (long) UndefinedFilter} };
+
+static ValueList image_types[] = {
+    { "bilevel",              (long) BilevelType              },
+    { "colorseparation",      (long) ColorSeparationType      },
+    { "colorseparationmatte", (long) ColorSeparationMatteType },
+    { "grayscale",            (long) GrayscaleType            },
+    { "grayscalematte",       (long) GrayscaleMatteType       },
+    { "optimize",             (long) OptimizeType             },
+    { "palette",              (long) PaletteType              },
+    { "palettebilevelmatte",  (long) PaletteBilevelMatteType  },
+    { "palettematte",         (long) PaletteMatteType         },
+    { "truecolormatte",       (long) TrueColorMatteType       },
+    { "truecolor",            (long) TrueColorType            },
+    { NULL,                   (long) UndefinedType            } };
+
+static ValueList gravity_types[] = {
+    { "none",      (long) UndefinedGravity },
+    { "center",    (long) CenterGravity    },
+    { "east",      (long) EastGravity      },
+    { "forget",    (long) ForgetGravity    },
+    { "northeast", (long) NorthEastGravity },
+    { "north",     (long) NorthGravity     },
+    { "northwest", (long) NorthWestGravity },
+    { "southeast", (long) SouthEastGravity },
+    { "south",     (long) SouthGravity     },
+    { "southwest", (long) SouthWestGravity },
+    { "west",      (long) WestGravity      },
+    { "static",    (long) StaticGravity    },
+    { NULL,        (long) UndefinedGravity } };
+static ValueList metric_types[] = {
+    { "ae",   (long) AbsoluteErrorMetric          },
+    { "mae",  (long) MeanAbsoluteErrorMetric      },
+    { "mepp", (long) MeanErrorPerPixelMetric      },
+    { "mse",  (long) MeanSquaredErrorMetric       },
+    { "pae",  (long) PeakAbsoluteErrorMetric      },
+    { "psnr", (long) PeakSignalToNoiseRatioMetric },
+    { "rmse", (long) RootMeanSquaredErrorMetric   },
+    { NULL,   (long) UndefinedMetric              }  };
+static ValueList storage_types[] = {
+    { "char",    (long) CharPixel      },
+    { "double",  (long) DoublePixel    },
+    { "float",   (long) FloatPixel     },
+    { "integer", (long) IntegerPixel   },
+    { "long",    (long) LongPixel      },
+    { "quantum", (long) QuantumPixel   },
+    { "short",   (long) ShortPixel     },
+    { NULL,      (long) UndefinedPixel }  };
+static ValueList stretch_types[] = {
+    { "any",            (long) AnyStretch },
+    { "condensed",      (long) CondensedStretch },
+    { "expanded",       (long) ExpandedStretch },
+    { "extracondensed", (long) ExtraCondensedStretch },
+    { "extraexpanded",  (long) ExtraExpandedStretch },
+    { "normal",         (long) NormalStretch },
+    { "semicondensed",  (long) SemiCondensedStretch },
+    { "semiexpanded",   (long) SemiExpandedStretch },
+    { "ultracondensed", (long) UltraCondensedStretch },
+    { "ultraexpanded",  (long) UltraExpandedStretch },
+    { NULL,             (long) UndefinedStretch } };
+static ValueList style_types[] = {
+    { "any",      (long) AnyStyle },
+    { "italic",  (long) ItalicStyle  },
+    { "normal",  (long) NormalStyle  },
+    { "oblique", (long) ObliqueStyle },
+    { NULL,      (long) UndefinedStyle } };
+static ValueList weight_types[] = {
+    { "any", 0L },
+    { "light", 100L },
+    { "normal", 400L },
+    { "bold", 700L },
+    { NULL, 0L } };
+
+static OptionList option_list[] = {
+    {"align",        align_types},
+    {"channel",      channel_types},
+    {"colorspace",   colorspace_types},
+    {"compose",      compose_types},
+    {"compress",     compression_types},
+    {"decoration",   decoration_types},
+    {"filter",       filter_types},
+    {"gravity",      gravity_types},
+    {"metric",       metric_types},
+    {"type",         image_types},
+    {"storage_type", storage_types},
+    {"stretch",      stretch_types},
+    {"style",        style_types},
+    {"weight",       weight_types},
+    {NULL,           NULL} };
+
+
+
+
+/*
+ *  lowercase up to 'lim' characters in a string
+ */
+static void downcase(char *out, size_t lim, const char *in)
+{
+    char c;
+    size_t n;
+
+    for (n = 0; (n < lim) && (c = *in++); n++)
+    {
+        *out++ = tolower(c);
+    }
+    *out = '\0';
+}
+
+
+
+VALUE mwr_option_values_to_hash(char *option_name)
+{
+    volatile VALUE option_values_hash;
+    volatile VALUE option_sym, values;
+    volatile VALUE value;
+    OptionList *o;
+    ValueList *v;
+    char name[100];
+
+    if (option_name != NULL)
+    {
+        downcase(name, sizeof(name), option_name);
+    }
+
+    option_values_hash = rb_hash_new();
+    for (o = option_list; o->name != NULL; o++)
+    {
+        if (!option_name || strcmp(name, o->name) == 0)
+        {
+            option_sym = ID2SYM(rb_intern(o->name));
+            values = rb_ary_new();
+            for (v = o->value; v->name != NULL; v++)
+            {
+                value = rb_str_new2(v->name);
+                rb_obj_freeze(value);
+                rb_ary_push(values, value);
+            }
+            rb_obj_freeze(values);
+            rb_hash_aset(option_values_hash, option_sym, values);
+        }
+    }
+
+    rb_obj_freeze(option_values_hash);
+    return option_values_hash;
+}
+
+
+
+
+
+/*
+ *  Raise an undefined option value exception
+ */
+void mwr_option_value_error(const char *option, const char *value)
+{
+    rb_raise(rb_eArgError, "invalid value for :%s '%s'", option, value);
+}
+
+
+
+
+/*
+ *  return the enum that matches the name. Return last enum in list if no match.
+ */
+static long string_to_enum(const char *option, ValueList *elist, VALUE s, long defval, OnUndefinedOption undef)
+{
+    char ns[100];
+    ValueList *e;
+
+    if (s == Qnil)
+    {
+        return defval;
+    }
+
+    downcase(ns, sizeof(ns), StringValuePtr(s));
+    for (e = elist; e->name != NULL; e++)
+    {
+        if (strcmp(ns, e->name) == 0)
+        {
+            break;
+        }
+    }
+
+    if (e->name == NULL && undef == RaiseUndefinedOption)
+    {
+        mwr_option_value_error(option, StringValuePtr(s));
+    }
+    return e->type;
+}
+
+
+
+
+AlignType mwr_string_to_aligntype(VALUE s, AlignType defval, OnUndefinedOption undef)
+{
+    return (AlignType) string_to_enum("align", align_types, s, (long)defval, undef);
+}
+
+ChannelType mwr_string_to_channeltype(VALUE s, ChannelType defval, OnUndefinedOption undef)
+{
+    return (ChannelType) string_to_enum("channel", channel_types, s, (long)defval, undef);
+}
+
+ColorspaceType mwr_string_to_colorspacetype(VALUE s, ColorspaceType defval, OnUndefinedOption undef)
+{
+    return (ColorspaceType) string_to_enum("colorspace", colorspace_types, s, (long)defval, undef);
+}
+
+CompositeOperator mwr_string_to_composetype(VALUE s, CompositeOperator defval, OnUndefinedOption undef)
+{
+    return (CompositeOperator) string_to_enum("compose", compose_types, s, (long)defval, undef);
+}
+
+CompressionType mwr_string_to_compressiontype(VALUE s, CompressionType defval, OnUndefinedOption undef)
+{
+    return (CompressionType) string_to_enum("compress", compression_types, s, (long)defval, undef);
+}
+
+DecorationType mwr_string_to_decorationtype(VALUE s, DecorationType defval, OnUndefinedOption undef)
+{
+    return (DecorationType) string_to_enum("decoration", decoration_types, s, (long)defval, undef);
+}
+
+FilterTypes mwr_string_to_filtertypes(VALUE s, FilterTypes defval, OnUndefinedOption undef)
+{
+    return (FilterTypes) string_to_enum("filter", filter_types, s, (long)defval, undef);
+}
+
+GravityType mwr_string_to_gravitytype(VALUE s, GravityType defval, OnUndefinedOption undef)
+{
+    return (GravityType) string_to_enum("gravity", gravity_types, s, (long)defval, undef);
+}
+
+ImageType mwr_string_to_imagetype(VALUE s, ImageType defval, OnUndefinedOption undef)
+{
+    return (ImageType) string_to_enum("type", image_types, s, (long)defval, undef);
+}
+
+MetricType mwr_string_to_metrictype(VALUE s, MetricType defval, OnUndefinedOption undef)
+{
+    return (MetricType) string_to_enum("type", metric_types, s, (long)defval, undef);
+}
+
+StorageType mwr_string_to_storagetype(VALUE s, StorageType defval, OnUndefinedOption undef)
+{
+    return (StretchType) string_to_enum("storage_type", storage_types, s, (long)defval, undef);
+}
+
+StretchType mwr_string_to_stretchtype(VALUE s, StretchType defval, OnUndefinedOption undef)
+{
+    return (StretchType) string_to_enum("stretch", stretch_types, s, (long)defval, undef);
+}
+
+StyleType mwr_string_to_styletype(VALUE s, StyleType defval, OnUndefinedOption undef)
+{
+    return (StyleType) string_to_enum("style", style_types, s, (long)defval, undef);
+}
+
+unsigned long mwr_string_to_weight(VALUE s, unsigned long defval, OnUndefinedOption undef)
+{
+    return (unsigned long) string_to_enum("weight", weight_types, s, (long)defval, undef);
+}
+
+
+
+/*
+ *  return ImageType enum as string (for #inspect)
+ */
+char *mwr_imagetype_to_s(ImageType type)
+{
+    char *str;
+
+    switch (type)
+    {
+        ENUMERATOR_STR(UndefinedType);
+        ENUMERATOR_STR(BilevelType);
+        ENUMERATOR_STR(GrayscaleType);
+        ENUMERATOR_STR(GrayscaleMatteType);
+        ENUMERATOR_STR(PaletteType);
+        ENUMERATOR_STR(PaletteMatteType);
+        ENUMERATOR_STR(TrueColorType);
+        ENUMERATOR_STR(TrueColorMatteType);
+        ENUMERATOR_STR(ColorSeparationType);
+        ENUMERATOR_STR(ColorSeparationMatteType);
+        ENUMERATOR_STR(OptimizeType);
+        ENUMERATOR_STR(PaletteBilevelMatteType);
+        default:
+            str = "UndefinedType";
+            break;
+    }
+
+    return str;
+}
+
+
+
+
+/*
+ *  If the option is present store its value in *value and return
+ *  MagickTrue, otherwise store Qnil and return MagickFalse.
+ *
+ *  Do _not_ delete keys from the options hash. We don't own it!
+ */
+MagickBooleanType mwr_get_option(VALUE options, const char *name, VALUE *value)
+{
+    volatile VALUE key;
+
+    if (options != Qnil)
+    {
+        key = ID2SYM(rb_intern(name));
+        if (rb_funcall(options, rb_intern("has_key?"), 1, key) == Qtrue)
+        {
+            *value = rb_hash_aref(options, key);
+            return MagickTrue;
+        }
+    }
+
+    *value = Qnil;
+    return MagickFalse;
+}
+
+
+
+
+extern void mwr_get_pixelpacket_from_pixelwand(PixelPacket *pixelpacket, PixelWand *pixelwand)
+{
+    pixelpacket->red = PixelGetRedQuantum(pixelwand);
+    pixelpacket->green = PixelGetGreenQuantum(pixelwand);
+    pixelpacket->blue = PixelGetBlueQuantum(pixelwand);
+    pixelpacket->opacity = PixelGetOpacityQuantum(pixelwand);
+}
+
+
+
+
+extern void mwr_get_pixelwand_from_pixelpacket(PixelWand *pixelwand, PixelPacket *pixelpacket)
+{
+    PixelSetRedQuantum(pixelwand, pixelpacket->red);
+    PixelSetGreenQuantum(pixelwand, pixelpacket->green);
+    PixelSetBlueQuantum(pixelwand, pixelpacket->blue);
+    PixelSetOpacityQuantum(pixelwand, pixelpacket->opacity);
+}
+
+
+
+
+/*
+ *  Return the hex representation of the pixel as a Ruby string.
+ *  (The PixelWand method always returns the rgb() representation.)
+ */
+extern VALUE mwr_pixelpacket_to_hex(Image *image, PixelPacket *pixelpacket)
+{
+    char name[MaxTextExtent];
+    MagickPixelPacket mpp;
+
+    memset(&mpp, 0, sizeof(mpp));
+    if (image)
+    {
+        mpp.depth = image->depth;
+        mpp.matte = image->matte;
+        mpp.colorspace = image->colorspace;
+    }
+    else
+    {
+        mpp.depth = QuantumDepth;
+        mpp.matte = MagickFalse;
+        mpp.colorspace = RGBColorspace;
+    }
+    mpp.red = (MagickRealType) pixelpacket->red;
+    mpp.green = (MagickRealType) pixelpacket->green;
+    mpp.blue = (MagickRealType) pixelpacket->blue;
+    mpp.opacity = (MagickRealType) pixelpacket->opacity;
+    mpp.index = 0.0;
+    (void) GetColorTuple(&mpp, MagickTrue, name);
+    return rb_str_new2(name);
+}
+
+
+
+
+
+/*
+ *  Similar but not identical to FormatMagickSize
+ */
+extern char *mwr_format_size(const MagickSizeType size, char *buff)
+{
+    double d;
+
+    if (size >= 1073741824)
+    {
+        d = size / 1073741824.0;
+        sprintf(buff, "%ggb", d);
+    }
+    else if (size >= 1048576)
+    {
+        d = size / 1048576.0;
+        sprintf(buff, "%gmb", d);
+    }
+    else if (size >= 1024)
+    {
+        d = size / 1024.0;
+        sprintf(buff, "%gkb", d);
+    }
+    else
+    {
+        sprintf(buff, "%g", (double)size);
+    }
+
+    return buff;
+}
+
+
+
+
+/*
+ *  Calls the set_<option> private method.
+ */
+static VALUE call_option_setter(VALUE args)
+{
+    volatile VALUE option, value, obj;
+    char setter[100];
+
+    option = rb_ary_entry(args, 0);
+    value = rb_ary_entry(args, 1);
+    obj = rb_ary_entry(args, 2);
+
+    (void) sprintf(setter, "set_%.90s", rb_id2name(SYM2ID(option)));
+
+    return rb_funcall(obj, rb_intern(setter), 1, value);
+}
+
+
+
+
+/*
+ *  Called if an exception was raised by call_option_setter (above).
+ */
+static VALUE rescue_option(VALUE args, VALUE errinfo)
+{
+    volatile VALUE option;
+    volatile VALUE err_class;
+    volatile VALUE msg;
+
+    option = rb_ary_entry(args, 0);
+    err_class = CLASS_OF(errinfo);
+    if (err_class == rb_eNoMethodError)
+    {
+        /* Do not diagnose undefined options. */
+#if 0
+        rb_raise(rb_eArgError, "undefined option :%s", rb_id2name(SYM2ID(option)));
+#else
+        return Qnil;
+#endif
+    }
+
+    msg = rb_funcall(errinfo, rb_intern("message"), 0, 0);
+    rb_raise(err_class, "%s", StringValuePtr(msg));
+    return Qnil;        // dummy
+}
+
+
+
+
+/*
+ *  Called with each key, value pair in the options hash.
+ *  The key is the option to be set. The value is the option value.
+ *  If the option setter needs > 1 argument, the value s/b an array.
+ *  begin
+ *      __send__(set_option, value)
+ *  rescue NoMethodError
+ *      raise(ArgumentError, "undefined option :#{option}")
+ *  end
+ */
+static int begin_option(VALUE option, VALUE value, VALUE obj)
+{
+    VALUE args;
+
+    args = rb_ary_new2(3);
+    rb_ary_push(args, option);
+    rb_ary_push(args, value);
+    rb_ary_push(args, obj);
+    (void) rb_rescue(call_option_setter, args, rescue_option, args);
+    return 0;
+}
+
+
+
+
+/*
+ *  Iterate over the options hash.
+ */
+void mwr_process_options(VALUE obj, VALUE options)
+{
+    if (options != Qnil)
+    {
+        rb_hash_foreach(options, begin_option, obj);
+    }
+}
+
+
+
+
+/*
+ *  issue warning or raise appropriate exception
+ */
+static void raise_wand_error(ExceptionType severity, char *exception)
+{
+    if (severity < ErrorException)
+    {
+        rb_warning("MagickWand: %s", exception);
+    }
+    else if (severity < FatalErrorException)
+    {
+
+        rb_raise(mwr_eImageMagickError, "%s", exception);
+    }
+    else
+    {
+        rb_raise(mwr_eFatalImageMagickError, "%s", exception);
+    }
+}
+
+
+
+
+/*
+ *  The exception strings are allocated out of Ruby managed memory and will
+ *  be GC'd normally.
+ */
+void mwr_check_magickwand_error(MagickWand *magickwand)
+{
+    ExceptionType severity;
+    char *exception;
+
+    severity = MagickGetExceptionType(magickwand);
+
+    if (severity > UndefinedException)
+    {
+        exception = MagickGetException(magickwand, &severity);
+        MagickClearException(magickwand);
+        raise_wand_error(severity, exception);
+    }
+}
+
+
+
+
+void mwr_check_pixelwand_error(PixelWand *pixelwand)
+{
+    ExceptionType severity;
+    char *exception;
+
+    severity = PixelGetExceptionType(pixelwand);
+
+    if (severity > UndefinedException)
+    {
+        exception = PixelGetException(pixelwand, &severity);
+        PixelClearException(pixelwand);
+        raise_wand_error(severity, exception);
+    }
+}
+
+
+
+
+void mwr_check_drawingwand_error(DrawingWand *drawingwand)
+{
+    ExceptionType severity;
+    char *exception;
+
+    severity = DrawGetExceptionType(drawingwand);
+
+    if (severity > UndefinedException)
+    {
+        exception = DrawGetException(drawingwand, &severity);
+        DrawClearException(drawingwand);
+        raise_wand_error(severity, exception);
+    }
+}
+
+
+
+
+void mwr_check_error(ExceptionInfo *exception)
+{
+    char buffer[2010];
+
+    if (exception->severity > UndefinedException)
+    {
+        buffer[0] = '\0';
+        if (exception->reason)
+        {
+            strncpy(buffer, GetLocaleExceptionMessage(exception->severity, exception->reason), 1000);
+        }
+        if (exception->description)
+        {
+            sprintf(buffer+strlen(buffer), " (%.1000s)", GetLocaleExceptionMessage(exception->severity, exception->description));
+        }
+
+        if (exception->severity < ErrorException)
+        {
+            rb_warning("MagickWand: %s", buffer);
+        }
+        else if (exception->severity < FatalErrorException)
+        {
+
+            rb_raise(mwr_eImageMagickError, "%s", buffer);
+        }
+        else
+        {
+            rb_raise(mwr_eFatalImageMagickError, "%s", buffer);
+        }
+    }
+}
+
+
+
+
+void mwr_init_ImageMagickError(void)
+{
+    mwr_eImageMagickError = rb_define_class_under(mwr_mMagickWand, "ImageMagickError", rb_eStandardError);
+}
+
+
+
+
+void mwr_init_FatalImageMagickError(void)
+{
+    mwr_eFatalImageMagickError = rb_define_class_under(mwr_mMagickWand, "FatalImageMagickError", rb_eStandardError);
+}