rmagick 2.13.2 → 4.2.2

data/ext/RMagick/rmmain.c

@@ -13,7 +13,18 @@
 
 #define MAIN                        // Define external variables
 #include "rmagick.h"
-#include "magick/version.h"
+
+#if defined(HAVE_SETMAGICKALIGNEDMEMORYMETHODS) && defined(HAVE_RB_GC_ADJUST_MEMORY_USAGE)
+    #if defined(HAVE_POSIX_MEMALIGN) || defined(HAVE__ALIGNED_MSIZE)
+        #define USE_RM_ALIGNED_MALLOC 1
+
+        #if defined(HAVE_MALLOC_H)
+            #include <malloc.h>
+        #elif defined(HAVE_MALLOC_MALLOC_H)
+            #include <malloc/malloc.h>
+        #endif
+    #endif
+#endif
 
 /*----------------------------------------------------------------------------\
 | External declarations
@@ -22,15 +33,37 @@ void Init_RMagick(void);
 
 static void test_Magick_version(void);
 static void version_constants(void);
+static void features_constant(void);
+
+
+/*
+ *  Enum constants - define a subclass of Enum for the specified enumeration.
+ *  Define an instance of the subclass for each member in the enumeration.
+ *  Initialize each instance with its name and value.
+ */
+//! define Ruby enum
+#define DEF_ENUM(tag) {\
+   VALUE _cls, _enum;\
+   _cls =  Class_##tag = rm_define_enum_type(#tag);
 
+//! define Ruby enumerator elements
+#define ENUMERATOR(val)\
+   _enum = rm_enum_new(_cls, ID2SYM(rb_intern(#val)), INT2NUM(val));\
+   rb_define_const(Module_Magick, #val, _enum);
 
+//! define Ruby enumerator elements when name is different from the value
+#define ENUMERATORV(name, val)\
+   _enum = rm_enum_new(_cls, ID2SYM(rb_intern(#name)), INT2NUM(val));\
+   rb_define_const(Module_Magick, #name, _enum);
 
+//! end of an enumerator
+#define END_ENUM }
 
 /*
  *  Handle transferring ImageMagick memory allocations/frees to Ruby.
  *  These functions have the same signature as the equivalent C functions.
  */
-#if defined(HAVE_SETMAGICKMEMORYMETHODS)
+
 /**
  * Allocate memory.
  *
@@ -41,17 +74,7 @@ static void version_constants(void);
  */
 static void *rm_malloc(size_t size)
 {
-    void *p;
-//    int old_state;
-
-//    old_state = rb_gc_disable();
-    p = xmalloc((long)size);
-//    if (!RTEST(old_state))
-//    {
-//        rb_gc_enable();
-//    }
-
-    return p;
+    return xmalloc((long)size);
 }
 
 
@@ -68,17 +91,7 @@ static void *rm_malloc(size_t size)
  */
 static void *rm_realloc(void *ptr, size_t size)
 {
-    void *p;
-//    int old_state;
-
-//    old_state = rb_gc_disable();
-    p = xrealloc(ptr, (long)size);
-//    if (!RTEST(old_state))
-//    {
-//        rb_gc_enable();
-//    }
-
-    return p;
+    return xrealloc(ptr, (long)size);
 }
 
 
@@ -97,27 +110,118 @@ static void rm_free(void *ptr)
 }
 
 
+
+#if USE_RM_ALIGNED_MALLOC
+
+static size_t
+rm_aligned_malloc_size(void *ptr)
+{
+#if defined(HAVE_MALLOC_USABLE_SIZE)
+    return malloc_usable_size(ptr);
+#elif defined(HAVE_MALLOC_SIZE)
+    return malloc_size(ptr);
+#elif defined(HAVE__ALIGNED_MSIZE)
+// Refered to https://github.com/ImageMagick/ImageMagick/blob/master/MagickCore/memory-private.h
+#define MAGICKCORE_SIZEOF_VOID_P 8
+#define CACHE_LINE_SIZE  (8 * MAGICKCORE_SIZEOF_VOID_P)
+    size_t _aligned_msize(void *memblock, size_t alignment, size_t offset);
+    return _aligned_msize(ptr, CACHE_LINE_SIZE, 0);
+#endif
+}
+
+
 /**
- * Use managed memory.
+ * Allocate aligned memory.
  *
  * No Ruby usage (internal function)
+ *
+ * @param size the size of memory to allocate
+ * @return pointer to a block of memory
  */
-static void set_managed_memory(void)
+static void *rm_aligned_malloc(size_t size, size_t alignment)
+{
+    void *res;
+    size_t allocated_size;
+
+#if defined(HAVE_POSIX_MEMALIGN)
+    if (posix_memalign(&res, alignment, size) != 0) {
+        return NULL;
+    }
+#elif defined(HAVE__ALIGNED_MSIZE)
+    res = _aligned_malloc(size, alignment);
+#endif
+
+    allocated_size = rm_aligned_malloc_size(res);
+    rb_gc_adjust_memory_usage(allocated_size);
+    return res;
+}
+
+
+
+
+/**
+ * Free aligned memory.
+ *
+ * No Ruby usage (internal function)
+ *
+ * @param ptr pointer to the existing block of memory
+ */
+static void rm_aligned_free(void *ptr)
 {
-    ID enable_mm = rb_intern("RMAGICK_ENABLE_MANAGED_MEMORY");
+    size_t allocated_size = rm_aligned_malloc_size(ptr);
+    rb_gc_adjust_memory_usage(-allocated_size);
+
+#if defined(HAVE_POSIX_MEMALIGN)
+    free(ptr);
+#elif defined(HAVE__ALIGNED_MSIZE)
+    _aligned_free(ptr);
+#endif
+}
+
+#endif
+
 
-    if (RTEST(rb_const_defined(rb_cObject, enable_mm)) && RTEST(rb_const_get(rb_cObject, enable_mm)))
+
+/**
+ * Use managed memory.
+ *
+ * No Ruby usage (internal function)
+ */
+static inline void managed_memory_enable(VALUE enable)
+{
+    if (enable)
     {
-        rb_warning("RMagick: %s", "managed memory enabled. This is an experimental feature.");
         SetMagickMemoryMethods(rm_malloc, rm_realloc, rm_free);
-        rb_define_const(Module_Magick, "MANAGED_MEMORY", Qtrue);
+#if USE_RM_ALIGNED_MALLOC
+        SetMagickAlignedMemoryMethods(rm_aligned_malloc, rm_aligned_free);
+#endif
     }
-    else
+    rb_define_const(Module_Magick, "MANAGED_MEMORY", enable);
+}
+
+static void set_managed_memory(void)
+{
+    char *disable = getenv("RMAGICK_DISABLE_MANAGED_MEMORY");
+
+    if (disable)
     {
-        rb_define_const(Module_Magick, "MANAGED_MEMORY", Qfalse);
+        managed_memory_enable(Qfalse);
+        return;
     }
-}
+
+#if defined(_WIN32)
+#if defined(IMAGEMAGICK_GREATER_THAN_EQUAL_6_9_0)
+    managed_memory_enable(Qtrue);
+#else
+    // Disable managed memory feature with ImageMagick 6.8.x or below because causes crash.
+    // Refer https://ci.appveyor.com/project/mockdeep/rmagick/builds/24706171
+    managed_memory_enable(Qfalse);
+#endif
+#else
+    // Not Windows
+    managed_memory_enable(Qtrue);
 #endif
+}
 
 
 
@@ -130,19 +234,15 @@ static void set_managed_memory(void)
 void
 Init_RMagick2(void)
 {
-    volatile VALUE observable;
+    Module_Magick = rb_define_module("Magick");
+
+    set_managed_memory();
 
     MagickCoreGenesis("RMagick", MagickFalse);
 
     test_Magick_version();
 
-    Module_Magick = rb_define_module("Magick");
-
-#if defined(HAVE_SETMAGICKMEMORYMETHODS)
-    set_managed_memory();
-#else
-    rb_define_const(Module_Magick, "MANAGED_MEMORY", Qfalse);
-#endif
+    rm_main_thread_id = rm_current_thread_id();
 
     /*-----------------------------------------------------------------------*/
     /* Create IDs for frequently used methods, etc.                          */
@@ -154,24 +254,14 @@ Init_RMagick2(void)
     rm_ID_cur_image        = rb_intern("cur_image");
     rm_ID_dup              = rb_intern("dup");
     rm_ID_fill             = rb_intern("fill");
-    rm_ID_flag             = rb_intern("flag");
-    rm_ID_from_s           = rb_intern("from_s");
     rm_ID_Geometry         = rb_intern("Geometry");
-    rm_ID_GeometryValue    = rb_intern("GeometryValue");
-    rm_ID_has_key_q        = rb_intern("has_key?");
     rm_ID_height           = rb_intern("height");
     rm_ID_initialize_copy  = rb_intern("initialize_copy");
-    rm_ID_length           = rb_intern("length");
     rm_ID_notify_observers = rb_intern("notify_observers");
     rm_ID_new              = rb_intern("new");
     rm_ID_push             = rb_intern("push");
-    rm_ID_spaceship        = rb_intern("<=>");
-    rm_ID_to_i             = rb_intern("to_i");
-    rm_ID_to_s             = rb_intern("to_s");
     rm_ID_values           = rb_intern("values");
     rm_ID_width            = rb_intern("width");
-    rm_ID_x                = rb_intern("x");
-    rm_ID_y                = rb_intern("y");
 
     /*-----------------------------------------------------------------------*/
     /* Module Magick methods                                                 */
@@ -197,7 +287,6 @@ Init_RMagick2(void)
     rb_define_alloc_func(Class_Image, Image_alloc);
     rb_define_method(Class_Image, "initialize", Image_initialize, -1);
 
-    rb_define_singleton_method(Class_Image, "combine", Image_combine, -1);
     rb_define_singleton_method(Class_Image, "constitute", Image_constitute, 4);
     rb_define_singleton_method(Class_Image, "_load", Image__load, 1);
     rb_define_singleton_method(Class_Image, "capture", Image_capture, -1);
@@ -206,72 +295,106 @@ Init_RMagick2(void)
     rb_define_singleton_method(Class_Image, "read_inline", Image_read_inline, 1);
     rb_define_singleton_method(Class_Image, "from_blob", Image_from_blob, 1);
 
-    DCL_ATTR_WRITER(Image, alpha)
-    DCL_ATTR_ACCESSOR(Image, background_color)
-    DCL_ATTR_READER(Image, base_columns)
-    DCL_ATTR_READER(Image, base_filename)
-    DCL_ATTR_READER(Image, base_rows)
-    DCL_ATTR_ACCESSOR(Image, bias)
-    DCL_ATTR_ACCESSOR(Image, black_point_compensation)
-    DCL_ATTR_ACCESSOR(Image, blur)
-    DCL_ATTR_ACCESSOR(Image, border_color)
-    DCL_ATTR_READER(Image, bounding_box)
-    DCL_ATTR_ACCESSOR(Image, chromaticity)
-    DCL_ATTR_ACCESSOR(Image, color_profile)
-    DCL_ATTR_READER(Image, colors)
-    DCL_ATTR_ACCESSOR(Image, colorspace)
-    DCL_ATTR_READER(Image, columns)
-    DCL_ATTR_ACCESSOR(Image, compose)
-    DCL_ATTR_ACCESSOR(Image, compression)
-    DCL_ATTR_ACCESSOR(Image, delay)
-    DCL_ATTR_ACCESSOR(Image, density)
-    DCL_ATTR_READER(Image, depth)
-    DCL_ATTR_READER(Image, directory)
-    DCL_ATTR_ACCESSOR(Image, dispose)
-    DCL_ATTR_ACCESSOR(Image, endian)
-    DCL_ATTR_ACCESSOR(Image, extract_info)
-    DCL_ATTR_READER(Image, filename)
-    DCL_ATTR_READER(Image, filesize)
-    DCL_ATTR_ACCESSOR(Image, filter)
-    DCL_ATTR_ACCESSOR(Image, format)
-    DCL_ATTR_ACCESSOR(Image, fuzz)
-    DCL_ATTR_ACCESSOR(Image, gamma)
-    DCL_ATTR_ACCESSOR(Image, geometry)
-    DCL_ATTR_ACCESSOR(Image, gravity)
-    DCL_ATTR_ACCESSOR(Image, image_type)
-    DCL_ATTR_ACCESSOR(Image, interlace)
-    DCL_ATTR_ACCESSOR(Image, iptc_profile)
-    DCL_ATTR_ACCESSOR(Image, iterations)        // do not document! Only used by Image#iterations=
-    DCL_ATTR_WRITER(Image, mask)
-    DCL_ATTR_ACCESSOR(Image, matte)
-    DCL_ATTR_ACCESSOR(Image, matte_color)
-    DCL_ATTR_READER(Image, mean_error_per_pixel)
-    DCL_ATTR_READER(Image, mime_type)
-    DCL_ATTR_WRITER(Image, monitor)
-    DCL_ATTR_READER(Image, montage)
-    DCL_ATTR_READER(Image, normalized_mean_error)
-    DCL_ATTR_READER(Image, normalized_maximum_error)
-    DCL_ATTR_READER(Image, number_colors)
-    DCL_ATTR_ACCESSOR(Image, offset)
-    DCL_ATTR_WRITER(Image, opacity)
-    DCL_ATTR_ACCESSOR(Image, orientation)
-    DCL_ATTR_ACCESSOR(Image, page)
-    DCL_ATTR_ACCESSOR(Image, pixel_interpolation_method)
-    DCL_ATTR_READER(Image, quality)
-    DCL_ATTR_READER(Image, quantum_depth)
-    DCL_ATTR_ACCESSOR(Image, rendering_intent)
-    DCL_ATTR_READER(Image, rows)
-    DCL_ATTR_READER(Image, scene)
-    DCL_ATTR_ACCESSOR(Image, start_loop)
-    DCL_ATTR_ACCESSOR(Image, class_type)
-    DCL_ATTR_ACCESSOR(Image, ticks_per_second)
-    DCL_ATTR_READER(Image, total_colors)
-    DCL_ATTR_READER(Image, total_ink_density)
-    DCL_ATTR_ACCESSOR(Image, transparent_color)
-    DCL_ATTR_ACCESSOR(Image, units)
-    DCL_ATTR_ACCESSOR(Image, virtual_pixel_method)
-    DCL_ATTR_ACCESSOR(Image, x_resolution)
-    DCL_ATTR_ACCESSOR(Image, y_resolution)
+    // Define the attributes
+    rb_define_method(Class_Image, "background_color", Image_background_color, 0);
+    rb_define_method(Class_Image, "background_color=", Image_background_color_eq, 1);
+    rb_define_method(Class_Image, "base_columns", Image_base_columns, 0);
+    rb_define_method(Class_Image, "base_filename", Image_base_filename, 0);
+    rb_define_method(Class_Image, "base_rows", Image_base_rows, 0);
+    rb_define_method(Class_Image, "bias", Image_bias, 0);
+    rb_define_method(Class_Image, "bias=", Image_bias_eq, 1);
+    rb_define_method(Class_Image, "black_point_compensation", Image_black_point_compensation, 0);
+    rb_define_method(Class_Image, "black_point_compensation=", Image_black_point_compensation_eq, 1);
+    rb_define_method(Class_Image, "border_color", Image_border_color, 0);
+    rb_define_method(Class_Image, "border_color=", Image_border_color_eq, 1);
+    rb_define_method(Class_Image, "bounding_box", Image_bounding_box, 0);
+    rb_define_method(Class_Image, "chromaticity", Image_chromaticity, 0);
+    rb_define_method(Class_Image, "chromaticity=", Image_chromaticity_eq, 1);
+    rb_define_method(Class_Image, "color_profile", Image_color_profile, 0);
+    rb_define_method(Class_Image, "color_profile=", Image_color_profile_eq, 1);
+    rb_define_method(Class_Image, "colors", Image_colors, 0);
+    rb_define_method(Class_Image, "colorspace", Image_colorspace, 0);
+    rb_define_method(Class_Image, "colorspace=", Image_colorspace_eq, 1);
+    rb_define_method(Class_Image, "columns", Image_columns, 0);
+    rb_define_method(Class_Image, "compose", Image_compose, 0);
+    rb_define_method(Class_Image, "compose=", Image_compose_eq, 1);
+    rb_define_method(Class_Image, "compression", Image_compression, 0);
+    rb_define_method(Class_Image, "compression=", Image_compression_eq, 1);
+    rb_define_method(Class_Image, "delay", Image_delay, 0);
+    rb_define_method(Class_Image, "delay=", Image_delay_eq, 1);
+    rb_define_method(Class_Image, "density", Image_density, 0);
+    rb_define_method(Class_Image, "density=", Image_density_eq, 1);
+    rb_define_method(Class_Image, "depth", Image_depth, 0);
+    rb_define_method(Class_Image, "directory", Image_directory, 0);
+    rb_define_method(Class_Image, "dispose", Image_dispose, 0);
+    rb_define_method(Class_Image, "dispose=", Image_dispose_eq, 1);
+    rb_define_method(Class_Image, "endian", Image_endian, 0);
+    rb_define_method(Class_Image, "endian=", Image_endian_eq, 1);
+    rb_define_method(Class_Image, "extract_info", Image_extract_info, 0);
+    rb_define_method(Class_Image, "extract_info=", Image_extract_info_eq, 1);
+    rb_define_method(Class_Image, "filename", Image_filename, 0);
+    rb_define_method(Class_Image, "filesize", Image_filesize, 0);
+    rb_define_method(Class_Image, "filter", Image_filter, 0);
+    rb_define_method(Class_Image, "filter=", Image_filter_eq, 1);
+    rb_define_method(Class_Image, "format", Image_format, 0);
+    rb_define_method(Class_Image, "format=", Image_format_eq, 1);
+    rb_define_method(Class_Image, "fuzz", Image_fuzz, 0);
+    rb_define_method(Class_Image, "fuzz=", Image_fuzz_eq, 1);
+    rb_define_method(Class_Image, "gamma", Image_gamma, 0);
+    rb_define_method(Class_Image, "gamma=", Image_gamma_eq, 1);
+    rb_define_method(Class_Image, "geometry", Image_geometry, 0);
+    rb_define_method(Class_Image, "geometry=", Image_geometry_eq, 1);
+    rb_define_method(Class_Image, "gravity", Image_gravity, 0);
+    rb_define_method(Class_Image, "gravity=", Image_gravity_eq, 1);
+    rb_define_method(Class_Image, "image_type", Image_image_type, 0);
+    rb_define_method(Class_Image, "image_type=", Image_image_type_eq, 1);
+    rb_define_method(Class_Image, "interlace", Image_interlace, 0);
+    rb_define_method(Class_Image, "interlace=", Image_interlace_eq, 1);
+    rb_define_method(Class_Image, "iptc_profile", Image_iptc_profile, 0);
+    rb_define_method(Class_Image, "iptc_profile=", Image_iptc_profile_eq, 1);
+    rb_define_method(Class_Image, "iterations", Image_iterations, 0);        // do not document! Only used by Image#iterations=
+    rb_define_method(Class_Image, "iterations=", Image_iterations_eq, 1);        // do not document! Only used by Image#iterations=
+    rb_define_method(Class_Image, "matte_color", Image_matte_color, 0);
+    rb_define_method(Class_Image, "matte_color=", Image_matte_color_eq, 1);
+    rb_define_method(Class_Image, "mean_error_per_pixel", Image_mean_error_per_pixel, 0);
+    rb_define_method(Class_Image, "mime_type", Image_mime_type, 0);
+    rb_define_method(Class_Image, "monitor=", Image_monitor_eq, 1);
+    rb_define_method(Class_Image, "montage", Image_montage, 0);
+    rb_define_method(Class_Image, "normalized_mean_error", Image_normalized_mean_error, 0);
+    rb_define_method(Class_Image, "normalized_maximum_error", Image_normalized_maximum_error, 0);
+    rb_define_method(Class_Image, "number_colors", Image_number_colors, 0);
+    rb_define_method(Class_Image, "offset", Image_offset, 0);
+    rb_define_method(Class_Image, "offset=", Image_offset_eq, 1);
+    rb_define_method(Class_Image, "orientation", Image_orientation, 0);
+    rb_define_method(Class_Image, "orientation=", Image_orientation_eq, 1);
+    rb_define_method(Class_Image, "page", Image_page, 0);
+    rb_define_method(Class_Image, "page=", Image_page_eq, 1);
+    rb_define_method(Class_Image, "pixel_interpolation_method", Image_pixel_interpolation_method, 0);
+    rb_define_method(Class_Image, "pixel_interpolation_method=", Image_pixel_interpolation_method_eq, 1);
+    rb_define_method(Class_Image, "quality", Image_quality, 0);
+    rb_define_method(Class_Image, "quantum_depth", Image_quantum_depth, 0);
+    rb_define_method(Class_Image, "rendering_intent", Image_rendering_intent, 0);
+    rb_define_method(Class_Image, "rendering_intent=", Image_rendering_intent_eq, 1);
+    rb_define_method(Class_Image, "rows", Image_rows, 0);
+    rb_define_method(Class_Image, "scene", Image_scene, 0);
+    rb_define_method(Class_Image, "start_loop", Image_start_loop, 0);
+    rb_define_method(Class_Image, "start_loop=", Image_start_loop_eq, 1);
+    rb_define_method(Class_Image, "class_type", Image_class_type, 0);
+    rb_define_method(Class_Image, "class_type=", Image_class_type_eq, 1);
+    rb_define_method(Class_Image, "ticks_per_second", Image_ticks_per_second, 0);
+    rb_define_method(Class_Image, "ticks_per_second=", Image_ticks_per_second_eq, 1);
+    rb_define_method(Class_Image, "total_colors", Image_total_colors, 0);
+    rb_define_method(Class_Image, "total_ink_density", Image_total_ink_density, 0);
+    rb_define_method(Class_Image, "transparent_color", Image_transparent_color, 0);
+    rb_define_method(Class_Image, "transparent_color=", Image_transparent_color_eq, 1);
+    rb_define_method(Class_Image, "units", Image_units, 0);
+    rb_define_method(Class_Image, "units=", Image_units_eq, 1);
+    rb_define_method(Class_Image, "virtual_pixel_method", Image_virtual_pixel_method, 0);
+    rb_define_method(Class_Image, "virtual_pixel_method=", Image_virtual_pixel_method_eq, 1);
+    rb_define_method(Class_Image, "x_resolution", Image_x_resolution, 0);
+    rb_define_method(Class_Image, "x_resolution=", Image_x_resolution_eq, 1);
+    rb_define_method(Class_Image, "y_resolution", Image_y_resolution, 0);
+    rb_define_method(Class_Image, "y_resolution=", Image_y_resolution_eq, 1);
 
     rb_define_method(Class_Image, "adaptive_blur", Image_adaptive_blur, -1);
     rb_define_method(Class_Image, "adaptive_blur_channel", Image_adaptive_blur_channel, -1);
@@ -313,6 +436,7 @@ Init_RMagick2(void)
     rb_define_method(Class_Image, "channel_depth", Image_channel_depth, -1);
     rb_define_method(Class_Image, "channel_extrema", Image_channel_extrema, -1);
     rb_define_method(Class_Image, "channel_mean", Image_channel_mean, -1);
+    rb_define_method(Class_Image, "channel_entropy", Image_channel_entropy, -1);
     rb_define_method(Class_Image, "charcoal", Image_charcoal, -1);
     rb_define_method(Class_Image, "chop", Image_chop, 4);
     rb_define_method(Class_Image, "clut_channel", Image_clut_channel, -1);
@@ -334,6 +458,8 @@ Init_RMagick2(void)
     rb_define_method(Class_Image, "contrast_stretch_channel", Image_contrast_stretch_channel, -1);
     rb_define_method(Class_Image, "convolve", Image_convolve, 2);
     rb_define_method(Class_Image, "convolve_channel", Image_convolve_channel, -1);
+    rb_define_method(Class_Image, "morphology", Image_morphology, 3);
+    rb_define_method(Class_Image, "morphology_channel", Image_morphology_channel, 4);
     rb_define_method(Class_Image, "copy", Image_copy, 0);
     rb_define_method(Class_Image, "crop", Image_crop, -1);
     rb_define_method(Class_Image, "crop!", Image_crop_bang, -1);
@@ -375,6 +501,7 @@ Init_RMagick2(void)
     rb_define_method(Class_Image, "flop!", Image_flop_bang, 0);
     rb_define_method(Class_Image, "frame", Image_frame, -1);
     rb_define_method(Class_Image, "function_channel", Image_function_channel, -1);
+    rb_define_method(Class_Image, "fx", Image_fx, -1);
     rb_define_method(Class_Image, "gamma_channel", Image_gamma_channel, -1);
     rb_define_method(Class_Image, "gamma_correct", Image_gamma_correct, -1);
     rb_define_method(Class_Image, "gaussian_blur", Image_gaussian_blur, -1);
@@ -395,11 +522,10 @@ Init_RMagick2(void)
     rb_define_method(Class_Image, "liquid_rescale", Image_liquid_rescale, -1);
     rb_define_method(Class_Image, "magnify", Image_magnify, 0);
     rb_define_method(Class_Image, "magnify!", Image_magnify_bang, 0);
-    rb_define_method(Class_Image, "map", Image_map, -1);
     rb_define_method(Class_Image, "marshal_dump", Image_marshal_dump, 0);
     rb_define_method(Class_Image, "marshal_load", Image_marshal_load, 1);
     rb_define_method(Class_Image, "mask", Image_mask, -1);
-    rb_define_method(Class_Image, "matte_flood_fill", Image_matte_flood_fill, 5);
+    rb_define_method(Class_Image, "matte_flood_fill", Image_matte_flood_fill, -1);
     rb_define_method(Class_Image, "median_filter", Image_median_filter, -1);
     rb_define_method(Class_Image, "minify", Image_minify, 0);
     rb_define_method(Class_Image, "minify!", Image_minify_bang, 0);
@@ -431,6 +557,8 @@ Init_RMagick2(void)
     rb_define_method(Class_Image, "random_threshold_channel", Image_random_threshold_channel, -1);
     rb_define_method(Class_Image, "recolor", Image_recolor, 1);
     rb_define_method(Class_Image, "reduce_noise", Image_reduce_noise, 1);
+    rb_define_method(Class_Image, "resample", Image_resample, -1);
+    rb_define_method(Class_Image, "resample!", Image_resample_bang, -1);
     rb_define_method(Class_Image, "resize", Image_resize, -1);
     rb_define_method(Class_Image, "resize!", Image_resize_bang, -1);
     rb_define_method(Class_Image, "roll", Image_roll, 2);
@@ -465,7 +593,6 @@ Init_RMagick2(void)
     rb_define_method(Class_Image, "strip!", Image_strip_bang, 0);
     rb_define_method(Class_Image, "store_pixels", Image_store_pixels, 5);
     rb_define_method(Class_Image, "swirl", Image_swirl, 1);
-    rb_define_method(Class_Image, "sync_profiles", Image_sync_profiles, 0);
     rb_define_method(Class_Image, "texture_flood_fill", Image_texture_flood_fill, 5);
     rb_define_method(Class_Image, "threshold", Image_threshold, 1);
     rb_define_method(Class_Image, "thumbnail", Image_thumbnail, -1);
@@ -505,12 +632,11 @@ Init_RMagick2(void)
     rb_define_method(Class_ImageList, "append", ImageList_append, 1);
     rb_define_method(Class_ImageList, "average", ImageList_average, 0);
     rb_define_method(Class_ImageList, "coalesce", ImageList_coalesce, 0);
+    rb_define_method(Class_ImageList, "combine", ImageList_combine, -1);
     rb_define_method(Class_ImageList, "composite_layers", ImageList_composite_layers, -1);
     rb_define_method(Class_ImageList, "deconstruct", ImageList_deconstruct, 0);
     rb_define_method(Class_ImageList, "display", ImageList_display, 0);
     rb_define_method(Class_ImageList, "flatten_images", ImageList_flatten_images, 0);
-    rb_define_method(Class_ImageList, "fx", ImageList_fx, -1);
-    rb_define_method(Class_ImageList, "map", ImageList_map, -1);
     rb_define_method(Class_ImageList, "montage", ImageList_montage, 0);
     rb_define_method(Class_ImageList, "morph", ImageList_morph, 1);
     rb_define_method(Class_ImageList, "mosaic", ImageList_mosaic, 0);
@@ -526,30 +652,31 @@ Init_RMagick2(void)
     Class_Draw = rb_define_class_under(Module_Magick, "Draw", rb_cObject);
     rb_define_alloc_func(Class_Draw, Draw_alloc);
 
-    DCL_ATTR_WRITER(Draw, affine)
-    DCL_ATTR_WRITER(Draw, align)
-    DCL_ATTR_WRITER(Draw, decorate)
-    DCL_ATTR_WRITER(Draw, density)
-    DCL_ATTR_WRITER(Draw, encoding)
-    DCL_ATTR_WRITER(Draw, fill)
-    DCL_ATTR_WRITER(Draw, fill_pattern)
-    DCL_ATTR_WRITER(Draw, font)
-    DCL_ATTR_WRITER(Draw, font_family)
-    DCL_ATTR_WRITER(Draw, font_stretch)
-    DCL_ATTR_WRITER(Draw, font_style)
-    DCL_ATTR_WRITER(Draw, font_weight)
-    DCL_ATTR_WRITER(Draw, gravity)
-    DCL_ATTR_WRITER(Draw, interline_spacing)
-    DCL_ATTR_WRITER(Draw, interword_spacing)
-    DCL_ATTR_WRITER(Draw, kerning)
-    DCL_ATTR_WRITER(Draw, pointsize)
-    DCL_ATTR_WRITER(Draw, rotation)
-    DCL_ATTR_WRITER(Draw, stroke)
-    DCL_ATTR_WRITER(Draw, stroke_pattern)
-    DCL_ATTR_WRITER(Draw, stroke_width)
-    DCL_ATTR_WRITER(Draw, text_antialias)
-    DCL_ATTR_WRITER(Draw, tile)
-    DCL_ATTR_WRITER(Draw, undercolor)
+    // Define the attributes
+    rb_define_method(Class_Draw, "affine=", Draw_affine_eq, 1);
+    rb_define_method(Class_Draw, "align=", Draw_align_eq, 1);
+    rb_define_method(Class_Draw, "decorate=", Draw_decorate_eq, 1);
+    rb_define_method(Class_Draw, "density=", Draw_density_eq, 1);
+    rb_define_method(Class_Draw, "encoding=", Draw_encoding_eq, 1);
+    rb_define_method(Class_Draw, "fill=", Draw_fill_eq, 1);
+    rb_define_method(Class_Draw, "fill_pattern=", Draw_fill_pattern_eq, 1);
+    rb_define_method(Class_Draw, "font=", Draw_font_eq, 1);
+    rb_define_method(Class_Draw, "font_family=", Draw_font_family_eq, 1);
+    rb_define_method(Class_Draw, "font_stretch=", Draw_font_stretch_eq, 1);
+    rb_define_method(Class_Draw, "font_style=", Draw_font_style_eq, 1);
+    rb_define_method(Class_Draw, "font_weight=", Draw_font_weight_eq, 1);
+    rb_define_method(Class_Draw, "gravity=", Draw_gravity_eq, 1);
+    rb_define_method(Class_Draw, "interline_spacing=", Draw_interline_spacing_eq, 1);
+    rb_define_method(Class_Draw, "interword_spacing=", Draw_interword_spacing_eq, 1);
+    rb_define_method(Class_Draw, "kerning=", Draw_kerning_eq, 1);
+    rb_define_method(Class_Draw, "pointsize=", Draw_pointsize_eq, 1);
+    rb_define_method(Class_Draw, "rotation=", Draw_rotation_eq, 1);
+    rb_define_method(Class_Draw, "stroke=", Draw_stroke_eq, 1);
+    rb_define_method(Class_Draw, "stroke_pattern=", Draw_stroke_pattern_eq, 1);
+    rb_define_method(Class_Draw, "stroke_width=", Draw_stroke_width_eq, 1);
+    rb_define_method(Class_Draw, "text_antialias=", Draw_text_antialias_eq, 1);
+    rb_define_method(Class_Draw, "tile=", Draw_tile_eq, 1);
+    rb_define_method(Class_Draw, "undercolor=", Draw_undercolor_eq, 1);
 
     rb_define_method(Class_Draw, "annotate", Draw_annotate, 6);
     rb_define_method(Class_Draw, "clone", Draw_clone, 0);
@@ -577,27 +704,27 @@ Init_RMagick2(void)
 
     rb_define_method(Class_DrawOptions, "initialize", DrawOptions_initialize, 0);
 
-    SHARE_ATTR_WRITER(DrawOptions, Draw, affine)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, align)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, decorate)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, density)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, encoding)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, fill)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, fill_pattern)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, font)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, font_family)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, font_stretch)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, font_style)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, font_weight)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, gravity)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, pointsize)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, rotation)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, stroke)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, stroke_pattern)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, stroke_width)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, text_antialias)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, tile)
-    SHARE_ATTR_WRITER(DrawOptions, Draw, undercolor)
+    rb_define_method(Class_DrawOptions, "affine=", Draw_affine_eq, 1);
+    rb_define_method(Class_DrawOptions, "align=", Draw_align_eq, 1);
+    rb_define_method(Class_DrawOptions, "decorate=", Draw_decorate_eq, 1);
+    rb_define_method(Class_DrawOptions, "density=", Draw_density_eq, 1);
+    rb_define_method(Class_DrawOptions, "encoding=", Draw_encoding_eq, 1);
+    rb_define_method(Class_DrawOptions, "fill=", Draw_fill_eq, 1);
+    rb_define_method(Class_DrawOptions, "fill_pattern=", Draw_fill_pattern_eq, 1);
+    rb_define_method(Class_DrawOptions, "font=", Draw_font_eq, 1);
+    rb_define_method(Class_DrawOptions, "font_family=", Draw_font_family_eq, 1);
+    rb_define_method(Class_DrawOptions, "font_stretch=", Draw_font_stretch_eq, 1);
+    rb_define_method(Class_DrawOptions, "font_style=", Draw_font_style_eq, 1);
+    rb_define_method(Class_DrawOptions, "font_weight=", Draw_font_weight_eq, 1);
+    rb_define_method(Class_DrawOptions, "gravity=", Draw_gravity_eq, 1);
+    rb_define_method(Class_DrawOptions, "pointsize=", Draw_pointsize_eq, 1);
+    rb_define_method(Class_DrawOptions, "rotation=", Draw_rotation_eq, 1);
+    rb_define_method(Class_DrawOptions, "stroke=", Draw_stroke_eq, 1);
+    rb_define_method(Class_DrawOptions, "stroke_pattern=", Draw_stroke_pattern_eq, 1);
+    rb_define_method(Class_DrawOptions, "stroke_width=", Draw_stroke_width_eq, 1);
+    rb_define_method(Class_DrawOptions, "text_antialias=", Draw_text_antialias_eq, 1);
+    rb_define_method(Class_DrawOptions, "tile=", Draw_tile_eq, 1);
+    rb_define_method(Class_DrawOptions, "undercolor=", Draw_undercolor_eq, 1);
 
     /*-----------------------------------------------------------------------*/
     /* Class Magick::Pixel                                                   */
@@ -605,11 +732,6 @@ Init_RMagick2(void)
 
     Class_Pixel = rb_define_class_under(Module_Magick, "Pixel", rb_cObject);
 
-    // include Observable in Pixel for Image::View class
-    (void) rb_require("observer");
-    observable = rb_const_get(rb_cObject, rb_intern("Observable"));
-    rb_include_module(Class_Pixel, observable);
-
     // include Comparable
     rb_include_module(Class_Pixel, rb_mComparable);
 
@@ -617,20 +739,27 @@ Init_RMagick2(void)
     // and the deprecated "from_HSL".
     rb_define_alloc_func(Class_Pixel, Pixel_alloc);
     rb_define_singleton_method(Class_Pixel, "from_color", Pixel_from_color, 1);
-    rb_define_singleton_method(Class_Pixel, "from_HSL", Pixel_from_HSL, 1);
     rb_define_singleton_method(Class_Pixel, "from_hsla", Pixel_from_hsla, -1);
 
     // Define the RGBA attributes
-    DCL_ATTR_ACCESSOR(Pixel, red)
-    DCL_ATTR_ACCESSOR(Pixel, green)
-    DCL_ATTR_ACCESSOR(Pixel, blue)
-    DCL_ATTR_ACCESSOR(Pixel, opacity)
+    rb_define_method(Class_Pixel, "red", Pixel_red, 0);
+    rb_define_method(Class_Pixel, "red=", Pixel_red_eq, 1);
+    rb_define_method(Class_Pixel, "green", Pixel_green, 0);
+    rb_define_method(Class_Pixel, "green=", Pixel_green_eq, 1);
+    rb_define_method(Class_Pixel, "blue", Pixel_blue, 0);
+    rb_define_method(Class_Pixel, "blue=", Pixel_blue_eq, 1);
+    rb_define_method(Class_Pixel, "alpha", Pixel_alpha, 0);
+    rb_define_method(Class_Pixel, "alpha=", Pixel_alpha_eq, 1);
 
     // Define the CMYK attributes
-    DCL_ATTR_ACCESSOR(Pixel, cyan)
-    DCL_ATTR_ACCESSOR(Pixel, magenta)
-    DCL_ATTR_ACCESSOR(Pixel, yellow)
-    DCL_ATTR_ACCESSOR(Pixel, black)
+    rb_define_method(Class_Pixel, "cyan", Pixel_cyan, 0);
+    rb_define_method(Class_Pixel, "cyan=", Pixel_cyan_eq, 1);
+    rb_define_method(Class_Pixel, "magenta", Pixel_magenta, 0);
+    rb_define_method(Class_Pixel, "magenta=", Pixel_magenta_eq, 1);
+    rb_define_method(Class_Pixel, "yellow", Pixel_yellow, 0);
+    rb_define_method(Class_Pixel, "yellow=", Pixel_yellow_eq, 1);
+    rb_define_method(Class_Pixel, "black", Pixel_black, 0);
+    rb_define_method(Class_Pixel, "black=", Pixel_black_eq, 1);
 
 
     // Define the instance methods
@@ -647,7 +776,6 @@ Init_RMagick2(void)
     rb_define_method(Class_Pixel, "marshal_dump", Pixel_marshal_dump, 0);
     rb_define_method(Class_Pixel, "marshal_load", Pixel_marshal_load, 1);
     rb_define_method(Class_Pixel, "to_color", Pixel_to_color, -1);
-    rb_define_method(Class_Pixel, "to_HSL", Pixel_to_HSL, 0);   // deprecated
     rb_define_method(Class_Pixel, "to_hsla", Pixel_to_hsla, 0);
     rb_define_method(Class_Pixel, "to_s", Pixel_to_s, 0);
 
@@ -663,23 +791,23 @@ Init_RMagick2(void)
     rb_define_method(Class_Montage, "freeze", rm_no_freeze, 0);
 
     // These accessors supply optional arguments for Magick::ImageList::Montage.new
-    DCL_ATTR_WRITER(Montage, background_color)
-    DCL_ATTR_WRITER(Montage, border_color)
-    DCL_ATTR_WRITER(Montage, border_width)
-    DCL_ATTR_WRITER(Montage, compose)
-    DCL_ATTR_WRITER(Montage, filename)
-    DCL_ATTR_WRITER(Montage, fill)
-    DCL_ATTR_WRITER(Montage, font)
-    DCL_ATTR_WRITER(Montage, frame)
-    DCL_ATTR_WRITER(Montage, geometry)
-    DCL_ATTR_WRITER(Montage, gravity)
-    DCL_ATTR_WRITER(Montage, matte_color)
-    DCL_ATTR_WRITER(Montage, pointsize)
-    DCL_ATTR_WRITER(Montage, shadow)
-    DCL_ATTR_WRITER(Montage, stroke)
-    DCL_ATTR_WRITER(Montage, texture)
-    DCL_ATTR_WRITER(Montage, tile)
-    DCL_ATTR_WRITER(Montage, title)
+    rb_define_method(Class_Montage, "background_color=", Montage_background_color_eq, 1);
+    rb_define_method(Class_Montage, "border_color=", Montage_border_color_eq, 1);
+    rb_define_method(Class_Montage, "border_width=", Montage_border_width_eq, 1);
+    rb_define_method(Class_Montage, "compose=", Montage_compose_eq, 1);
+    rb_define_method(Class_Montage, "filename=", Montage_filename_eq, 1);
+    rb_define_method(Class_Montage, "fill=", Montage_fill_eq, 1);
+    rb_define_method(Class_Montage, "font=", Montage_font_eq, 1);
+    rb_define_method(Class_Montage, "frame=", Montage_frame_eq, 1);
+    rb_define_method(Class_Montage, "geometry=", Montage_geometry_eq, 1);
+    rb_define_method(Class_Montage, "gravity=", Montage_gravity_eq, 1);
+    rb_define_method(Class_Montage, "matte_color=", Montage_matte_color_eq, 1);
+    rb_define_method(Class_Montage, "pointsize=", Montage_pointsize_eq, 1);
+    rb_define_method(Class_Montage, "shadow=", Montage_shadow_eq, 1);
+    rb_define_method(Class_Montage, "stroke=", Montage_stroke_eq, 1);
+    rb_define_method(Class_Montage, "texture=", Montage_texture_eq, 1);
+    rb_define_method(Class_Montage, "tile=", Montage_tile_eq, 1);
+    rb_define_method(Class_Montage, "title=", Montage_title_eq, 1);
 
     /*-----------------------------------------------------------------------*/
     /* Class Magick::Image::Info                                             */
@@ -697,53 +825,114 @@ Init_RMagick2(void)
     rb_define_method(Class_Info, "[]", Info_aref, -1);
     rb_define_method(Class_Info, "undefine", Info_undefine, 2);
 
-    DCL_ATTR_ACCESSOR(Info, antialias)
-    DCL_ATTR_ACCESSOR(Info, attenuate)
-    DCL_ATTR_ACCESSOR(Info, authenticate)
-    DCL_ATTR_ACCESSOR(Info, background_color)
-    DCL_ATTR_ACCESSOR(Info, border_color)
-    DCL_ATTR_ACCESSOR(Info, caption)
-    DCL_ATTR_ACCESSOR(Info, colorspace)
-    DCL_ATTR_ACCESSOR(Info, comment)
-    DCL_ATTR_ACCESSOR(Info, compression)
-    DCL_ATTR_ACCESSOR(Info, delay)
-    DCL_ATTR_ACCESSOR(Info, density)
-    DCL_ATTR_ACCESSOR(Info, depth)
-    DCL_ATTR_ACCESSOR(Info, dispose)
-    DCL_ATTR_ACCESSOR(Info, dither)
-    DCL_ATTR_ACCESSOR(Info, endian)
-    DCL_ATTR_ACCESSOR(Info, extract)
-    DCL_ATTR_ACCESSOR(Info, filename)
-    DCL_ATTR_ACCESSOR(Info, fill)
-    DCL_ATTR_ACCESSOR(Info, font)
-    DCL_ATTR_ACCESSOR(Info, format)
-    DCL_ATTR_ACCESSOR(Info, fuzz)
-    DCL_ATTR_ACCESSOR(Info, gravity)
-    DCL_ATTR_ACCESSOR(Info, group)
-    DCL_ATTR_ACCESSOR(Info, image_type)
-    DCL_ATTR_ACCESSOR(Info, interlace)
-    DCL_ATTR_ACCESSOR(Info, label)
-    DCL_ATTR_ACCESSOR(Info, matte_color)
-    DCL_ATTR_WRITER(Info, monitor)
-    DCL_ATTR_ACCESSOR(Info, monochrome)
-    DCL_ATTR_ACCESSOR(Info, number_scenes)
-    DCL_ATTR_ACCESSOR(Info, orientation)
-    DCL_ATTR_ACCESSOR(Info, origin)         // new in 6.3.1
-    DCL_ATTR_ACCESSOR(Info, page)
-    DCL_ATTR_ACCESSOR(Info, pointsize)
-    DCL_ATTR_ACCESSOR(Info, quality)
-    DCL_ATTR_ACCESSOR(Info, sampling_factor)
-    DCL_ATTR_ACCESSOR(Info, scene)
-    DCL_ATTR_ACCESSOR(Info, server_name)
-    DCL_ATTR_ACCESSOR(Info, size)
-    DCL_ATTR_ACCESSOR(Info, stroke)
-    DCL_ATTR_ACCESSOR(Info, stroke_width)
-    DCL_ATTR_WRITER(Info, texture)
-    DCL_ATTR_ACCESSOR(Info, tile_offset)
-    DCL_ATTR_ACCESSOR(Info, transparent_color)
-    DCL_ATTR_ACCESSOR(Info, undercolor)
-    DCL_ATTR_ACCESSOR(Info, units)
-    DCL_ATTR_ACCESSOR(Info, view)
+    // Define the attributes
+    rb_define_method(Class_Info, "antialias", Info_antialias, 0);
+    rb_define_method(Class_Info, "antialias=", Info_antialias_eq, 1);
+    rb_define_method(Class_Info, "attenuate", Info_attenuate, 0);
+    rb_define_method(Class_Info, "attenuate=", Info_attenuate_eq, 1);
+    rb_define_method(Class_Info, "authenticate", Info_authenticate, 0);
+    rb_define_method(Class_Info, "authenticate=", Info_authenticate_eq, 1);
+    rb_define_method(Class_Info, "background_color", Info_background_color, 0);
+    rb_define_method(Class_Info, "background_color=", Info_background_color_eq, 1);
+    rb_define_method(Class_Info, "border_color", Info_border_color, 0);
+    rb_define_method(Class_Info, "border_color=", Info_border_color_eq, 1);
+    rb_define_method(Class_Info, "caption", Info_caption, 0);
+    rb_define_method(Class_Info, "caption=", Info_caption_eq, 1);
+    rb_define_method(Class_Info, "colorspace", Info_colorspace, 0);
+    rb_define_method(Class_Info, "colorspace=", Info_colorspace_eq, 1);
+    rb_define_method(Class_Info, "comment", Info_comment, 0);
+    rb_define_method(Class_Info, "comment=", Info_comment_eq, 1);
+    rb_define_method(Class_Info, "compression", Info_compression, 0);
+    rb_define_method(Class_Info, "compression=", Info_compression_eq, 1);
+    rb_define_method(Class_Info, "delay", Info_delay, 0);
+    rb_define_method(Class_Info, "delay=", Info_delay_eq, 1);
+    rb_define_method(Class_Info, "density", Info_density, 0);
+    rb_define_method(Class_Info, "density=", Info_density_eq, 1);
+    rb_define_method(Class_Info, "depth", Info_depth, 0);
+    rb_define_method(Class_Info, "depth=", Info_depth_eq, 1);
+    rb_define_method(Class_Info, "dispose", Info_dispose, 0);
+    rb_define_method(Class_Info, "dispose=", Info_dispose_eq, 1);
+    rb_define_method(Class_Info, "dither", Info_dither, 0);
+    rb_define_method(Class_Info, "dither=", Info_dither_eq, 1);
+    rb_define_method(Class_Info, "endian", Info_endian, 0);
+    rb_define_method(Class_Info, "endian=", Info_endian_eq, 1);
+    rb_define_method(Class_Info, "extract", Info_extract, 0);
+    rb_define_method(Class_Info, "extract=", Info_extract_eq, 1);
+    rb_define_method(Class_Info, "filename", Info_filename, 0);
+    rb_define_method(Class_Info, "filename=", Info_filename_eq, 1);
+    rb_define_method(Class_Info, "fill", Info_fill, 0);
+    rb_define_method(Class_Info, "fill=", Info_fill_eq, 1);
+    rb_define_method(Class_Info, "font", Info_font, 0);
+    rb_define_method(Class_Info, "font=", Info_font_eq, 1);
+    rb_define_method(Class_Info, "format", Info_format, 0);
+    rb_define_method(Class_Info, "format=", Info_format_eq, 1);
+    rb_define_method(Class_Info, "fuzz", Info_fuzz, 0);
+    rb_define_method(Class_Info, "fuzz=", Info_fuzz_eq, 1);
+    rb_define_method(Class_Info, "gravity", Info_gravity, 0);
+    rb_define_method(Class_Info, "gravity=", Info_gravity_eq, 1);
+    rb_define_method(Class_Info, "image_type", Info_image_type, 0);
+    rb_define_method(Class_Info, "image_type=", Info_image_type_eq, 1);
+    rb_define_method(Class_Info, "interlace", Info_interlace, 0);
+    rb_define_method(Class_Info, "interlace=", Info_interlace_eq, 1);
+    rb_define_method(Class_Info, "label", Info_label, 0);
+    rb_define_method(Class_Info, "label=", Info_label_eq, 1);
+    rb_define_method(Class_Info, "matte_color", Info_matte_color, 0);
+    rb_define_method(Class_Info, "matte_color=", Info_matte_color_eq, 1);
+    rb_define_method(Class_Info, "monitor=", Info_monitor_eq, 1);
+    rb_define_method(Class_Info, "monochrome", Info_monochrome, 0);
+    rb_define_method(Class_Info, "monochrome=", Info_monochrome_eq, 1);
+    rb_define_method(Class_Info, "number_scenes", Info_number_scenes, 0);
+    rb_define_method(Class_Info, "number_scenes=", Info_number_scenes_eq, 1);
+    rb_define_method(Class_Info, "orientation", Info_orientation, 0);
+    rb_define_method(Class_Info, "orientation=", Info_orientation_eq, 1);
+    rb_define_method(Class_Info, "origin", Info_origin, 0);         // new in 6.3.1
+    rb_define_method(Class_Info, "origin=", Info_origin_eq, 1);         // new in 6.3.1
+    rb_define_method(Class_Info, "page", Info_page, 0);
+    rb_define_method(Class_Info, "page=", Info_page_eq, 1);
+    rb_define_method(Class_Info, "pointsize", Info_pointsize, 0);
+    rb_define_method(Class_Info, "pointsize=", Info_pointsize_eq, 1);
+    rb_define_method(Class_Info, "quality", Info_quality, 0);
+    rb_define_method(Class_Info, "quality=", Info_quality_eq, 1);
+    rb_define_method(Class_Info, "sampling_factor", Info_sampling_factor, 0);
+    rb_define_method(Class_Info, "sampling_factor=", Info_sampling_factor_eq, 1);
+    rb_define_method(Class_Info, "scene", Info_scene, 0);
+    rb_define_method(Class_Info, "scene=", Info_scene_eq, 1);
+    rb_define_method(Class_Info, "server_name", Info_server_name, 0);
+    rb_define_method(Class_Info, "server_name=", Info_server_name_eq, 1);
+    rb_define_method(Class_Info, "size", Info_size, 0);
+    rb_define_method(Class_Info, "size=", Info_size_eq, 1);
+    rb_define_method(Class_Info, "stroke", Info_stroke, 0);
+    rb_define_method(Class_Info, "stroke=", Info_stroke_eq, 1);
+    rb_define_method(Class_Info, "stroke_width", Info_stroke_width, 0);
+    rb_define_method(Class_Info, "stroke_width=", Info_stroke_width_eq, 1);
+    rb_define_method(Class_Info, "texture=", Info_texture_eq, 1);
+    rb_define_method(Class_Info, "tile_offset", Info_tile_offset, 0);
+    rb_define_method(Class_Info, "tile_offset=", Info_tile_offset_eq, 1);
+    rb_define_method(Class_Info, "transparent_color", Info_transparent_color, 0);
+    rb_define_method(Class_Info, "transparent_color=", Info_transparent_color_eq, 1);
+    rb_define_method(Class_Info, "undercolor", Info_undercolor, 0);
+    rb_define_method(Class_Info, "undercolor=", Info_undercolor_eq, 1);
+    rb_define_method(Class_Info, "units", Info_units, 0);
+    rb_define_method(Class_Info, "units=", Info_units_eq, 1);
+    rb_define_method(Class_Info, "view", Info_view, 0);
+    rb_define_method(Class_Info, "view=", Info_view_eq, 1);
+
+    /*-----------------------------------------------------------------------*/
+    /* Class Magick::KernelInfo                                              */
+    /*-----------------------------------------------------------------------*/
+
+    Class_KernelInfo = rb_define_class_under(Module_Magick, "KernelInfo", rb_cObject);
+
+    rb_define_alloc_func(Class_KernelInfo, KernelInfo_alloc);
+
+    rb_define_method(Class_KernelInfo, "initialize", KernelInfo_initialize, 1);
+    rb_define_method(Class_KernelInfo, "unity_add", KernelInfo_unity_add, 1);
+    rb_define_method(Class_KernelInfo, "scale", KernelInfo_scale, 2);
+    rb_define_method(Class_KernelInfo, "scale_geometry", KernelInfo_scale_geometry, 1);
+    rb_define_method(Class_KernelInfo, "clone", KernelInfo_clone, 0);
+    rb_define_method(Class_KernelInfo, "dup", KernelInfo_clone, 0);
+
+    rb_define_singleton_method(Class_KernelInfo, "builtin", KernelInfo_builtin, 2);
 
 
     /*-----------------------------------------------------------------------*/
@@ -756,27 +945,29 @@ Init_RMagick2(void)
 
     rb_define_method(Class_PolaroidOptions, "initialize", PolaroidOptions_initialize, 0);
 
-    DCL_ATTR_WRITER(PolaroidOptions, shadow_color)
-    DCL_ATTR_WRITER(PolaroidOptions, border_color)
+    // Define the attributes
+    rb_define_method(Class_PolaroidOptions, "shadow_color=", PolaroidOptions_shadow_color_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "border_color=", PolaroidOptions_border_color_eq, 1);
+
     // The other attribute writer methods are implemented by Draw's functions
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, align)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, decorate)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, density)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, encoding)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, fill)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, fill_pattern)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, font)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, font_family)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, font_stretch)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, font_style)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, font_weight)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, gravity)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, pointsize)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, stroke)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, stroke_pattern)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, stroke_width)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, text_antialias)
-    SHARE_ATTR_WRITER(PolaroidOptions, Draw, undercolor)
+    rb_define_method(Class_PolaroidOptions, "align=", Draw_align_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "decorate=", Draw_decorate_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "density=", Draw_density_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "encoding=", Draw_encoding_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "fill=", Draw_fill_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "fill_pattern=", Draw_fill_pattern_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "font=", Draw_font_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "font_family=", Draw_font_family_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "font_stretch=", Draw_font_stretch_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "font_style=", Draw_font_style_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "font_weight=", Draw_font_weight_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "gravity=", Draw_gravity_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "pointsize=", Draw_pointsize_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "stroke=", Draw_stroke_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "stroke_pattern=", Draw_stroke_pattern_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "stroke_width=", Draw_stroke_width_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "text_antialias=", Draw_text_antialias_eq, 1);
+    rb_define_method(Class_PolaroidOptions, "undercolor=", Draw_undercolor_eq, 1);
 
 
     /*-----------------------------------------------------------------------*/
@@ -818,13 +1009,13 @@ Init_RMagick2(void)
 
 
     // Miscellaneous fixed-point constants
-    DEF_CONST(MaxRGB);
     DEF_CONST(QuantumRange);
-    DEF_CONST(QuantumDepth);
-    DEF_CONST(OpaqueOpacity);
-    DEF_CONST(TransparentOpacity);
+    DEF_CONST(MAGICKCORE_QUANTUM_DEPTH);
+    DEF_CONSTV(OpaqueAlpha, QuantumRange);
+    DEF_CONSTV(TransparentAlpha, 0);
 
     version_constants();
+    features_constant();
 
     /*-----------------------------------------------------------------------*/
     /* Class Magick::Enum                                                    */
@@ -841,6 +1032,7 @@ Init_RMagick2(void)
     rb_define_method(Class_Enum, "to_i", Enum_to_i, 0);
     rb_define_method(Class_Enum, "<=>", Enum_spaceship, 1);
     rb_define_method(Class_Enum, "===", Enum_case_eq, 1);
+    rb_define_method(Class_Enum, "|", Enum_bitwise_or, 1);
 
     // AlignType constants
     DEF_ENUM(AlignType)
@@ -850,22 +1042,22 @@ Init_RMagick2(void)
         ENUMERATOR(RightAlign)
     END_ENUM
 
-    // AlphaChannelType constants
-    DEF_ENUM(AlphaChannelType)
+    // AlphaChannelOption constants
+    DEF_ENUM(AlphaChannelOption)
         ENUMERATOR(UndefinedAlphaChannel)
         ENUMERATOR(ActivateAlphaChannel)
         ENUMERATOR(DeactivateAlphaChannel)
-        ENUMERATOR(ResetAlphaChannel)  /* deprecated */
         ENUMERATOR(SetAlphaChannel)
-#if defined(HAVE_ENUM_COPYALPHACHANNEL)
+        ENUMERATOR(RemoveAlphaChannel)
         ENUMERATOR(CopyAlphaChannel)
         ENUMERATOR(ExtractAlphaChannel)
         ENUMERATOR(OpaqueAlphaChannel)
         ENUMERATOR(ShapeAlphaChannel)
         ENUMERATOR(TransparentAlphaChannel)
-#endif
-#if defined(HAVE_ENUM_BACKGROUNDALPHACHANNEL)
         ENUMERATOR(BackgroundAlphaChannel)
+#if defined(IMAGEMAGICK_GREATER_THAN_EQUAL_6_8_9)
+        ENUMERATOR(AssociateAlphaChannel)
+        ENUMERATOR(DisassociateAlphaChannel)
 #endif
     END_ENUM
 
@@ -886,36 +1078,15 @@ Init_RMagick2(void)
         ENUMERATOR(BlueChannel)
         ENUMERATOR(YellowChannel)
         ENUMERATOR(OpacityChannel)
-
-
         ENUMERATOR(BlackChannel)
-        ENUMERATOR(MatteChannel)
         ENUMERATOR(IndexChannel)
         ENUMERATOR(GrayChannel)
         ENUMERATOR(AllChannels)
-
-        // Define alternate names for ChannelType enums for Image::Info#channel=
-        // AlphaChannel == OpacityChannel
-        _enum = rm_enum_new(Class_ChannelType, ID2SYM(rb_intern("AlphaChannel")), INT2FIX(OpacityChannel));
-        rb_define_const(Module_Magick, "AlphaChannel", _enum);
-
-        // DefaultChannels
-        _enum = rm_enum_new(Class_ChannelType, ID2SYM(rb_intern("DefaultChannels")), INT2FIX(0xff & ~OpacityChannel));
-        rb_define_const(Module_Magick, "DefaultChannels", _enum);
-
-        // HueChannel == RedChannel
-        _enum = rm_enum_new(Class_ChannelType, ID2SYM(rb_intern("HueChannel")), INT2FIX(RedChannel));
-        rb_define_const(Module_Magick, "HueChannel", _enum);
-
-        // LuminosityChannel = BlueChannel
-        _enum = rm_enum_new(Class_ChannelType, ID2SYM(rb_intern("LuminosityChannel")), INT2FIX(BlueChannel));
-        rb_define_const(Module_Magick, "LuminosityChannel", _enum);
-
-        // SaturationChannel = GreenChannel
-        _enum = rm_enum_new(Class_ChannelType, ID2SYM(rb_intern("SaturationChannel")), INT2FIX(GreenChannel));
-        rb_define_const(Module_Magick, "SaturationChannel", _enum);
-
-
+        ENUMERATORV(AlphaChannel, OpacityChannel)
+        ENUMERATORV(DefaultChannels, 0xff & ~OpacityChannel)
+        ENUMERATORV(HueChannel, RedChannel)
+        ENUMERATORV(LuminosityChannel, BlueChannel)
+        ENUMERATORV(SaturationChannel, GreenChannel)
     END_ENUM
 
     // ClassType constants
@@ -939,32 +1110,46 @@ Init_RMagick2(void)
         ENUMERATOR(YPbPrColorspace)
         ENUMERATOR(YUVColorspace)
         ENUMERATOR(CMYKColorspace)
-        rb_define_const(Module_Magick, "SRGBColorspace"
-                      , rm_enum_new(Class_ColorspaceType
-                      , ID2SYM(rb_intern("SRGBColorspace"))
-                      , INT2FIX(sRGBColorspace)));
+        ENUMERATORV(SRGBColorspace, sRGBColorspace)
         ENUMERATOR(HSLColorspace)
         ENUMERATOR(HWBColorspace)
         ENUMERATOR(HSBColorspace)
-        ENUMERATOR(LABColorspace)
-        ENUMERATOR(Rec601LumaColorspace)
+        ENUMERATOR(LabColorspace)
         ENUMERATOR(Rec601YCbCrColorspace)
-        ENUMERATOR(Rec709LumaColorspace)
         ENUMERATOR(Rec709YCbCrColorspace)
         ENUMERATOR(LogColorspace)
         ENUMERATOR(CMYColorspace)
+#if defined(IMAGEMAGICK_GREATER_THAN_EQUAL_6_8_9)
+        ENUMERATOR(LuvColorspace)
+        ENUMERATOR(HCLColorspace)
+        ENUMERATOR(LCHColorspace)
+        ENUMERATOR(LMSColorspace)
+        ENUMERATOR(LCHabColorspace)
+        ENUMERATOR(LCHuvColorspace)
+        ENUMERATORV(ScRGBColorspace, scRGBColorspace)
+        ENUMERATOR(HSIColorspace)
+        ENUMERATOR(HSVColorspace)
+        ENUMERATOR(HCLpColorspace)
+        ENUMERATOR(YDbDrColorspace)
+        ENUMERATORV(XyYColorspace, xyYColorspace)
+#endif
+#if defined(IMAGEMAGICK_7)
+#if defined(IMAGEMAGICK_GREATER_THAN_EQUAL_7_0_8)
+        ENUMERATOR(LinearGRAYColorspace)
+#endif
+#if defined(IMAGEMAGICK_GREATER_THAN_EQUAL_7_0_10)
+        ENUMERATOR(JzazbzColorspace)
+#endif
+#elif defined(IMAGEMAGICK_GREATER_THAN_EQUAL_6_9_10)
+        ENUMERATOR(LinearGRAYColorspace)
+#endif
     END_ENUM
 
     // ComplianceType constants are defined as enums but used as bit flags
     DEF_ENUM(ComplianceType)
         ENUMERATOR(UndefinedCompliance)
-
         // AllCompliance is 0xffff, not too useful for us!
-        rb_define_const(Module_Magick, "AllCompliance"
-                  , rm_enum_new(Class_ComplianceType
-                  , ID2SYM(rb_intern("AllCompliance"))
-                  , INT2FIX(SVGCompliance|X11Compliance|XPMCompliance)));
-
+        ENUMERATORV(AllCompliance, SVGCompliance|X11Compliance|XPMCompliance)
         ENUMERATOR(NoCompliance)
         ENUMERATOR(SVGCompliance)
         ENUMERATOR(X11Compliance)
@@ -973,14 +1158,9 @@ Init_RMagick2(void)
 
     // CompositeOperator constants
     DEF_ENUM(CompositeOperator)
-        ENUMERATOR(UndefinedCompositeOp)
-        ENUMERATOR(NoCompositeOp)
-        ENUMERATOR(AddCompositeOp)
         ENUMERATOR(AtopCompositeOp)
         ENUMERATOR(BlendCompositeOp)
-#if defined(HAVE_ENUM_BLURCOMPOSITEOP)
         ENUMERATOR(BlurCompositeOp)
-#endif
         ENUMERATOR(BumpmapCompositeOp)
         ENUMERATOR(ChangeMaskCompositeOp)
         ENUMERATOR(ClearCompositeOp)
@@ -993,14 +1173,13 @@ Init_RMagick2(void)
         ENUMERATOR(CopyCyanCompositeOp)
         ENUMERATOR(CopyGreenCompositeOp)
         ENUMERATOR(CopyMagentaCompositeOp)
-        ENUMERATOR(CopyOpacityCompositeOp)
         ENUMERATOR(CopyRedCompositeOp)
         ENUMERATOR(CopyYellowCompositeOp)
         ENUMERATOR(DarkenCompositeOp)
-#if defined(HAVE_ENUM_DISTORTCOMPOSITEOP)
+        ENUMERATOR(DarkenIntensityCompositeOp)
         ENUMERATOR(DistortCompositeOp)
-#endif
-        ENUMERATOR(DivideCompositeOp)
+        ENUMERATOR(DivideDstCompositeOp)
+        ENUMERATOR(DivideSrcCompositeOp)
         ENUMERATOR(DstAtopCompositeOp)
         ENUMERATOR(DstCompositeOp)
         ENUMERATOR(DstInCompositeOp)
@@ -1014,26 +1193,24 @@ Init_RMagick2(void)
         ENUMERATOR(HueCompositeOp)
         ENUMERATOR(InCompositeOp)
         ENUMERATOR(LightenCompositeOp)
-#if defined(HAVE_ENUM_LINEARBURNCOMPOSITEOP)
+        ENUMERATOR(LightenIntensityCompositeOp)
         ENUMERATOR(LinearBurnCompositeOp)
-#endif
-#if defined(HAVE_ENUM_LINEARDODGECOMPOSITEOP)
         ENUMERATOR(LinearDodgeCompositeOp)
-#endif
         ENUMERATOR(LinearLightCompositeOp)
         ENUMERATOR(LuminizeCompositeOp)
-        ENUMERATOR(MinusCompositeOp)
+        ENUMERATOR(MathematicsCompositeOp)
+        ENUMERATOR(MinusDstCompositeOp)
+        ENUMERATOR(MinusSrcCompositeOp)
         ENUMERATOR(ModulateCompositeOp)
+        ENUMERATOR(ModulusAddCompositeOp)
+        ENUMERATOR(ModulusSubtractCompositeOp)
         ENUMERATOR(MultiplyCompositeOp)
+        ENUMERATOR(NoCompositeOp)
         ENUMERATOR(OutCompositeOp)
         ENUMERATOR(OverCompositeOp)
         ENUMERATOR(OverlayCompositeOp)
-#if defined(HAVE_ENUM_PEGTOPLIGHTCOMPOSITEOP)
         ENUMERATOR(PegtopLightCompositeOp)
-#endif
-#if defined(HAVE_ENUM_PINLIGHTCOMPOSITEOP)
         ENUMERATOR(PinLightCompositeOp)
-#endif
         ENUMERATOR(PlusCompositeOp)
         ENUMERATOR(ReplaceCompositeOp)    // synonym for CopyCompositeOp
         ENUMERATOR(SaturateCompositeOp)
@@ -1044,51 +1221,44 @@ Init_RMagick2(void)
         ENUMERATOR(SrcInCompositeOp)
         ENUMERATOR(SrcOutCompositeOp)
         ENUMERATOR(SrcOverCompositeOp)
-        ENUMERATOR(SubtractCompositeOp)
         ENUMERATOR(ThresholdCompositeOp)
-#if defined(HAVE_ENUM_VIVIDLIGHTCOMPOSITEOP)
+        ENUMERATOR(UndefinedCompositeOp)
         ENUMERATOR(VividLightCompositeOp)
-#endif
         ENUMERATOR(XorCompositeOp)
+#if defined(IMAGEMAGICK_GREATER_THAN_EQUAL_6_8_9)
+        ENUMERATOR(HardMixCompositeOp)
+#endif
+#if defined(IMAGEMAGICK_7)
+        ENUMERATOR(CopyAlphaCompositeOp)
+#else
+        ENUMERATORV(CopyAlphaCompositeOp, CopyOpacityCompositeOp)
+#endif
     END_ENUM
 
     // CompressionType constants
     DEF_ENUM(CompressionType)
         ENUMERATOR(UndefinedCompression)
         ENUMERATOR(NoCompression)
-#if defined(HAVE_ENUM_B44COMPRESSION)
         ENUMERATOR(B44Compression)
-#endif
-#if defined(HAVE_ENUM_B44ACOMPRESSION)
         ENUMERATOR(B44ACompression)
-#endif
         ENUMERATOR(BZipCompression)
-#if defined(HAVE_ENUM_DXT1COMPRESSION)
         ENUMERATOR(DXT1Compression)
-#endif
-#if defined(HAVE_ENUM_DXT3COMPRESSION)
         ENUMERATOR(DXT3Compression)
-#endif
-#if defined(HAVE_ENUM_DXT5COMPRESSION)
         ENUMERATOR(DXT5Compression)
-#endif
         ENUMERATOR(FaxCompression)
         ENUMERATOR(Group4Compression)
         ENUMERATOR(JPEGCompression)
         ENUMERATOR(JPEG2000Compression)
         ENUMERATOR(LosslessJPEGCompression)
         ENUMERATOR(LZWCompression)
-#if defined(HAVE_ENUM_PIZCOMPRESSION)
         ENUMERATOR(PizCompression)
-#endif
-#if defined(HAVE_ENUM_PXR24COMPRESSION)
         ENUMERATOR(Pxr24Compression)
-#endif
         ENUMERATOR(RLECompression)
         ENUMERATOR(ZipCompression)
-#if defined(HAVE_ENUM_ZIPSCOMPRESSION)
         ENUMERATOR(ZipSCompression)
-#endif
+        ENUMERATOR(LZMACompression)
+        ENUMERATOR(JBIG1Compression)
+        ENUMERATOR(JBIG2Compression)
     END_ENUM
 
     // DecorationType constants
@@ -1107,52 +1277,36 @@ Init_RMagick2(void)
         ENUMERATOR(PreviousDispose)
     END_ENUM
 
-    // DistortImage "method" argument values
-    DEF_ENUM(DistortImageMethod)
+    // DistortMethod constants
+    DEF_ENUM(DistortMethod)
         ENUMERATOR(UndefinedDistortion)
         ENUMERATOR(AffineDistortion)
         ENUMERATOR(AffineProjectionDistortion)
         ENUMERATOR(ArcDistortion)
-#if defined(HAVE_ENUM_POLARDISTORTION)
         ENUMERATOR(PolarDistortion)
-#endif
-#if defined(HAVE_ENUM_DEPOLARDISTORTION)
         ENUMERATOR(DePolarDistortion)
-#endif
-#if defined(HAVE_ENUM_BARRELDISTORTION)
         ENUMERATOR(BarrelDistortion)
-#endif
         ENUMERATOR(BilinearDistortion)
-#if defined(HAVE_ENUM_BILINEARFORWARDDISTORTION)
         ENUMERATOR(BilinearForwardDistortion)
-#endif
-#if defined(HAVE_ENUM_BILINEARREVERSEDISTORTION)
         ENUMERATOR(BilinearReverseDistortion)
-#endif
         ENUMERATOR(PerspectiveDistortion)
         ENUMERATOR(PerspectiveProjectionDistortion)
-#if defined(HAVE_ENUM_POLYNOMIALDISTORTION)
         ENUMERATOR(PolynomialDistortion)
-#endif
         ENUMERATOR(ScaleRotateTranslateDistortion)
-#if defined(HAVE_ENUM_SHEPARDSDISTORTION)
         ENUMERATOR(ShepardsDistortion)
-#endif
-#if defined(HAVE_ENUM_BARRELINVERSEDISTORTION)
         ENUMERATOR(BarrelInverseDistortion)
-#endif
+        ENUMERATOR(Cylinder2PlaneDistortion)
+        ENUMERATOR(Plane2CylinderDistortion)
+        ENUMERATOR(ResizeDistortion)
+        ENUMERATOR(SentinelDistortion)
     END_ENUM
 
-#if defined(HAVE_TYPE_DITHERMETHOD)
     DEF_ENUM(DitherMethod)
         ENUMERATOR(UndefinedDitherMethod)
-#if defined(HAVE_ENUM_NODITHERMETHOD)
         ENUMERATOR(NoDitherMethod)
-#endif
         ENUMERATOR(RiemersmaDitherMethod)
         ENUMERATOR(FloydSteinbergDitherMethod)
     END_ENUM
-#endif
 
     DEF_ENUM(EndianType)
         ENUMERATOR(UndefinedEndian)
@@ -1160,8 +1314,8 @@ Init_RMagick2(void)
         ENUMERATOR(MSBEndian)
     END_ENUM
 
-    // FilterTypes constants
-    DEF_ENUM(FilterTypes)
+    // FilterType constants
+    DEF_ENUM(FilterType)
         ENUMERATOR(UndefinedFilter)
         ENUMERATOR(PointFilter)
         ENUMERATOR(BoxFilter)
@@ -1178,23 +1332,23 @@ Init_RMagick2(void)
         ENUMERATOR(LanczosFilter)
         ENUMERATOR(BesselFilter)
         ENUMERATOR(SincFilter)
-#if defined(HAVE_ENUM_KAISERFILTER)
         ENUMERATOR(KaiserFilter)
-#endif
-#if defined(HAVE_ENUM_WELSHFILTER)
         ENUMERATOR(WelshFilter)
-#endif
-#if defined(HAVE_ENUM_PARZENFILTER)
         ENUMERATOR(ParzenFilter)
-#endif
-#if defined(HAVE_ENUM_LAGRANGEFILTER)
         ENUMERATOR(LagrangeFilter)
-#endif
-#if defined(HAVE_ENUM_BOHMANFILTER)
         ENUMERATOR(BohmanFilter)
-#endif
-#if defined(HAVE_ENUM_BARTLETTFILTER)
         ENUMERATOR(BartlettFilter)
+        ENUMERATOR(JincFilter)
+        ENUMERATOR(SincFastFilter)
+        ENUMERATOR(LanczosSharpFilter)
+        ENUMERATOR(Lanczos2Filter)
+        ENUMERATOR(Lanczos2SharpFilter)
+        ENUMERATOR(RobidouxFilter)
+        ENUMERATOR(RobidouxSharpFilter)
+        ENUMERATOR(CosineFilter)
+        ENUMERATOR(SplineFilter)
+#if defined(IMAGEMAGICK_GREATER_THAN_EQUAL_6_8_9)
+        ENUMERATOR(LanczosRadiusFilter)
 #endif
     END_ENUM
 
@@ -1211,7 +1365,6 @@ Init_RMagick2(void)
         ENUMERATOR(SouthWestGravity)
         ENUMERATOR(SouthGravity)
         ENUMERATOR(SouthEastGravity)
-        ENUMERATOR(StaticGravity)
     END_ENUM
 
     // ImageType constants
@@ -1219,15 +1372,23 @@ Init_RMagick2(void)
         ENUMERATOR(UndefinedType)
         ENUMERATOR(BilevelType)
         ENUMERATOR(GrayscaleType)
-        ENUMERATOR(GrayscaleMatteType)
         ENUMERATOR(PaletteType)
-        ENUMERATOR(PaletteMatteType)
         ENUMERATOR(TrueColorType)
-        ENUMERATOR(TrueColorMatteType)
         ENUMERATOR(ColorSeparationType)
-        ENUMERATOR(ColorSeparationMatteType)
         ENUMERATOR(OptimizeType)
-        ENUMERATOR(PaletteBilevelMatteType)
+#if defined(IMAGEMAGICK_7)
+        ENUMERATOR(GrayscaleAlphaType)
+        ENUMERATOR(PaletteAlphaType)
+        ENUMERATOR(TrueColorAlphaType)
+        ENUMERATOR(ColorSeparationAlphaType)
+        ENUMERATOR(PaletteBilevelAlphaType)
+#else
+        ENUMERATORV(GrayscaleAlphaType, GrayscaleMatteType)
+        ENUMERATORV(PaletteAlphaType, PaletteMatteType)
+        ENUMERATORV(TrueColorAlphaType, TrueColorMatteType)
+        ENUMERATORV(ColorSeparationAlphaType, ColorSeparationMatteType)
+        ENUMERATORV(PaletteBilevelAlphaType, PaletteBilevelMatteType)
+#endif
     END_ENUM
 
     // InterlaceType constants
@@ -1242,39 +1403,15 @@ Init_RMagick2(void)
         ENUMERATOR(PNGInterlace)
     END_ENUM
 
-    DEF_ENUM(InterpolatePixelMethod)
-        ENUMERATOR(UndefinedInterpolatePixel)
-        ENUMERATOR(AverageInterpolatePixel)
-        ENUMERATOR(BicubicInterpolatePixel)
-        ENUMERATOR(BilinearInterpolatePixel)
-        ENUMERATOR(FilterInterpolatePixel)
-        ENUMERATOR(IntegerInterpolatePixel)
-        ENUMERATOR(MeshInterpolatePixel)
-        ENUMERATOR(NearestNeighborInterpolatePixel)
-#if defined(HAVE_SPLINEINTERPOLATEPIXEL)
-        ENUMERATOR(SplineInterpolatePixel)
-#endif
-    END_ENUM
-
-#if defined(HAVE_TYPE_MAGICKFUNCTION)
     DEF_ENUM(MagickFunction)
         ENUMERATOR(UndefinedFunction)
         ENUMERATOR(PolynomialFunction)
         ENUMERATOR(SinusoidFunction)
-#if defined(HAVE_ENUM_ARCSINFUNCTION)
         ENUMERATOR(ArcsinFunction)
-#endif
-#if defined(HAVE_ENUM_ARCTANFUNCTION)
         ENUMERATOR(ArctanFunction)
-#endif
     END_ENUM
-#endif
 
-#if defined(HAVE_TYPE_IMAGELAYERMETHOD)
-    DEF_ENUM(ImageLayerMethod)
-#else
-    DEF_ENUM(MagickLayerMethod)
-#endif
+    DEF_ENUM(LayerMethod)
         ENUMERATOR(UndefinedLayer)
         ENUMERATOR(CompareAnyLayer)
         ENUMERATOR(CompareClearLayer)
@@ -1284,35 +1421,36 @@ Init_RMagick2(void)
         ENUMERATOR(CoalesceLayer)
         ENUMERATOR(DisposeLayer)
         ENUMERATOR(OptimizeTransLayer)
-#if defined(HAVE_ENUM_OPTIMIZEIMAGELAYER)
         ENUMERATOR(OptimizeImageLayer)
-#endif
         ENUMERATOR(RemoveDupsLayer)
         ENUMERATOR(RemoveZeroLayer)
         ENUMERATOR(CompositeLayer)
-#if defined(HAVE_ENUM_MERGELAYER)
         ENUMERATOR(MergeLayer)
-#endif
-#if defined(HAVE_ENUM_MOSAICLAYER)
         ENUMERATOR(MosaicLayer)
-#endif
-#if defined(HAVE_ENUM_FLATTENLAYER)
         ENUMERATOR(FlattenLayer)
-#endif
-#if defined(HAVE_ENUM_TRIMBOUNDSLAYER)
         ENUMERATOR(TrimBoundsLayer)
-#endif
     END_ENUM
 
     DEF_ENUM(MetricType)
-        ENUMERATOR(UndefinedMetric)
         ENUMERATOR(AbsoluteErrorMetric)
         ENUMERATOR(MeanAbsoluteErrorMetric)
-        ENUMERATOR(MeanErrorPerPixelMetric)
         ENUMERATOR(MeanSquaredErrorMetric)
         ENUMERATOR(PeakAbsoluteErrorMetric)
-        ENUMERATOR(PeakSignalToNoiseRatioMetric)
         ENUMERATOR(RootMeanSquaredErrorMetric)
+        ENUMERATOR(NormalizedCrossCorrelationErrorMetric)
+        ENUMERATOR(FuzzErrorMetric)
+#if defined(IMAGEMAGICK_GREATER_THAN_EQUAL_6_8_9)
+        ENUMERATOR(PerceptualHashErrorMetric)
+#endif
+#if defined(IMAGEMAGICK_7)
+        ENUMERATOR(UndefinedErrorMetric)
+        ENUMERATOR(MeanErrorPerPixelErrorMetric)
+        ENUMERATOR(PeakSignalToNoiseRatioErrorMetric)
+#else
+        ENUMERATORV(UndefinedErrorMetric, UndefinedMetric)
+        ENUMERATORV(MeanErrorPerPixelErrorMetric, MeanErrorPerPixelMetric)
+        ENUMERATORV(PeakSignalToNoiseRatioErrorMetric, PeakSignalToNoiseRatioMetric)
+#endif
     END_ENUM
 
     // NoiseType constants
@@ -1348,6 +1486,26 @@ Init_RMagick2(void)
         ENUMERATOR(ResetMethod)
     END_ENUM
 
+    // PixelInterpolateMethod constants
+    DEF_ENUM(PixelInterpolateMethod)
+        ENUMERATOR(UndefinedInterpolatePixel)
+        ENUMERATOR(AverageInterpolatePixel)
+        ENUMERATOR(BilinearInterpolatePixel)
+        ENUMERATOR(IntegerInterpolatePixel)
+        ENUMERATOR(MeshInterpolatePixel)
+#if defined(IMAGEMAGICK_7)
+        ENUMERATOR(NearestInterpolatePixel)
+#else
+        ENUMERATORV(NearestInterpolatePixel, NearestNeighborInterpolatePixel)
+#endif
+        ENUMERATOR(SplineInterpolatePixel)
+        ENUMERATOR(Average9InterpolatePixel)
+        ENUMERATOR(Average16InterpolatePixel)
+        ENUMERATOR(BlendInterpolatePixel)
+        ENUMERATOR(BackgroundInterpolatePixel)
+        ENUMERATOR(CatromInterpolatePixel)
+    END_ENUM
+
     // PreviewType
     DEF_ENUM(PreviewType)
         ENUMERATOR(UndefinedPreview)
@@ -1395,47 +1553,28 @@ Init_RMagick2(void)
         ENUMERATOR(RShiftQuantumOperator)
         ENUMERATOR(SubtractQuantumOperator)
         ENUMERATOR(XorQuantumOperator)
-#if defined(HAVE_ENUM_POWEVALUATEOPERATOR)
         ENUMERATOR(PowQuantumOperator)
-#endif
-#if defined(HAVE_ENUM_LOGEVALUATEOPERATOR)
         ENUMERATOR(LogQuantumOperator)
-#endif
-#if defined(HAVE_ENUM_THRESHOLDEVALUATEOPERATOR)
         ENUMERATOR(ThresholdQuantumOperator)
-#endif
-#if defined(HAVE_ENUM_THRESHOLDBLACKEVALUATEOPERATOR)
         ENUMERATOR(ThresholdBlackQuantumOperator)
-#endif
-#if defined(HAVE_ENUM_THRESHOLDWHITEEVALUATEOPERATOR)
         ENUMERATOR(ThresholdWhiteQuantumOperator)
-#endif
-#if defined(HAVE_ENUM_GAUSSIANNOISEEVALUATEOPERATOR)
         ENUMERATOR(GaussianNoiseQuantumOperator)
-#endif
-#if defined(HAVE_ENUM_IMPULSENOISEEVALUATEOPERATOR)
         ENUMERATOR(ImpulseNoiseQuantumOperator)
-#endif
-#if defined(HAVE_ENUM_LAPLACIANNOISEEVALUATEOPERATOR)
         ENUMERATOR(LaplacianNoiseQuantumOperator)
-#endif
-#if defined(HAVE_ENUM_MULTIPLICATIVENOISEEVALUATEOPERATOR)
         ENUMERATOR(MultiplicativeNoiseQuantumOperator)
-#endif
-#if defined(HAVE_ENUM_POISSONNOISEEVALUATEOPERATOR)
         ENUMERATOR(PoissonNoiseQuantumOperator)
-#endif
-#if defined(HAVE_ENUM_UNIFORMNOISEEVALUATEOPERATOR)
         ENUMERATOR(UniformNoiseQuantumOperator)
-#endif
-#if defined(HAVE_ENUM_COSINEEVALUATEOPERATOR)
         ENUMERATOR(CosineQuantumOperator)
-#endif
-#if defined(HAVE_ENUM_SINEEVALUATEOPERATOR)
+        ENUMERATOR(SetQuantumOperator)
         ENUMERATOR(SineQuantumOperator)
-#endif
-#if defined(HAVE_ENUM_ADDMODULUSEVALUATEOPERATOR)
         ENUMERATOR(AddModulusQuantumOperator)
+        ENUMERATOR(MeanQuantumOperator)
+        ENUMERATOR(AbsQuantumOperator)
+        ENUMERATOR(ExponentialQuantumOperator)
+        ENUMERATOR(MedianQuantumOperator)
+        ENUMERATOR(SumQuantumOperator)
+#if defined(IMAGEMAGICK_GREATER_THAN_EQUAL_6_8_9)
+        ENUMERATOR(RootMeanSquareQuantumOperator)
 #endif
     END_ENUM
 
@@ -1455,7 +1594,6 @@ Init_RMagick2(void)
         ENUMERATOR(PixelsPerCentimeterResolution)
     END_ENUM
 
-#if defined(HAVE_SPARSECOLORIMAGE)
     DEF_ENUM(SparseColorMethod)
         ENUMERATOR(UndefinedColorInterpolate)
         ENUMERATOR(BarycentricColorInterpolate)
@@ -1463,8 +1601,8 @@ Init_RMagick2(void)
         //ENUMERATOR(PolynomialColorInterpolate)
         ENUMERATOR(ShepardsColorInterpolate)
         ENUMERATOR(VoronoiColorInterpolate)
+        ENUMERATOR(InverseColorInterpolate)
     END_ENUM
-#endif
 
     // SpreadMethod
     DEF_ENUM(SpreadMethod)
@@ -1480,7 +1618,6 @@ Init_RMagick2(void)
         ENUMERATOR(CharPixel)
         ENUMERATOR(DoublePixel)
         ENUMERATOR(FloatPixel)
-        ENUMERATOR(IntegerPixel)
         ENUMERATOR(LongPixel)
         ENUMERATOR(QuantumPixel)
         ENUMERATOR(ShortPixel)
@@ -1518,26 +1655,15 @@ Init_RMagick2(void)
         ENUMERATOR(BackgroundVirtualPixelMethod)
         ENUMERATOR(DitherVirtualPixelMethod)
         ENUMERATOR(RandomVirtualPixelMethod)
-        ENUMERATOR(ConstantVirtualPixelMethod)
         ENUMERATOR(MaskVirtualPixelMethod)
         ENUMERATOR(BlackVirtualPixelMethod)
         ENUMERATOR(GrayVirtualPixelMethod)
         ENUMERATOR(WhiteVirtualPixelMethod)
-#if defined(HAVE_ENUM_HORIZONTALTILEVIRTUALPIXELMETHOD)
         ENUMERATOR(HorizontalTileVirtualPixelMethod)
-#endif
-#if defined(HAVE_ENUM_VERTICALTILEVIRTUALPIXELMETHOD)
         ENUMERATOR(VerticalTileVirtualPixelMethod)
-#endif
-#if defined(HAVE_ENUM_HORIZONTALTILEEDGEVIRTUALPIXELMETHOD)
         ENUMERATOR(HorizontalTileEdgeVirtualPixelMethod)
-#endif
-#if defined(HAVE_ENUM_VERTICALTILEEDGEVIRTUALPIXELMETHOD)
         ENUMERATOR(VerticalTileEdgeVirtualPixelMethod)
-#endif
-#if defined(HAVE_ENUM_CHECKERTILEVIRTUALPIXELMETHOD)
         ENUMERATOR(CheckerTileVirtualPixelMethod)
-#endif
     END_ENUM
     // WeightType constants
     DEF_ENUM(WeightType)
@@ -1548,6 +1674,108 @@ Init_RMagick2(void)
         ENUMERATOR(LighterWeight)
     END_ENUM
 
+    // For KernelInfo scaling
+    DEF_ENUM(GeometryFlags)
+        ENUMERATOR(NoValue)
+        ENUMERATOR(XValue)
+        ENUMERATOR(XiValue)
+        ENUMERATOR(YValue)
+        ENUMERATOR(PsiValue)
+        ENUMERATOR(WidthValue)
+        ENUMERATOR(RhoValue)
+        ENUMERATOR(HeightValue)
+        ENUMERATOR(SigmaValue)
+        ENUMERATOR(ChiValue)
+        ENUMERATOR(XiNegative)
+        ENUMERATOR(XNegative)
+        ENUMERATOR(PsiNegative)
+        ENUMERATOR(YNegative)
+        ENUMERATOR(ChiNegative)
+        ENUMERATOR(PercentValue)
+        ENUMERATOR(AspectValue)
+        ENUMERATOR(NormalizeValue)
+        ENUMERATOR(LessValue)
+        ENUMERATOR(GreaterValue)
+        ENUMERATOR(MinimumValue)
+        ENUMERATOR(CorrelateNormalizeValue)
+        ENUMERATOR(AreaValue)
+        ENUMERATOR(DecimalValue)
+#if defined(IMAGEMAGICK_GREATER_THAN_EQUAL_6_8_9)
+        ENUMERATOR(SeparatorValue)
+#endif
+        ENUMERATOR(AllValues)
+    END_ENUM
+
+    // Morphology methods
+    DEF_ENUM(MorphologyMethod)
+      ENUMERATOR(UndefinedMorphology)
+      ENUMERATOR(ConvolveMorphology)
+      ENUMERATOR(CorrelateMorphology)
+      ENUMERATOR(ErodeMorphology)
+      ENUMERATOR(DilateMorphology)
+      ENUMERATOR(ErodeIntensityMorphology)
+      ENUMERATOR(DilateIntensityMorphology)
+      ENUMERATOR(DistanceMorphology)
+      ENUMERATOR(OpenMorphology)
+      ENUMERATOR(CloseMorphology)
+      ENUMERATOR(OpenIntensityMorphology)
+      ENUMERATOR(CloseIntensityMorphology)
+      ENUMERATOR(SmoothMorphology)
+      ENUMERATOR(EdgeInMorphology)
+      ENUMERATOR(EdgeOutMorphology)
+      ENUMERATOR(EdgeMorphology)
+      ENUMERATOR(TopHatMorphology)
+      ENUMERATOR(BottomHatMorphology)
+      ENUMERATOR(HitAndMissMorphology)
+      ENUMERATOR(ThinningMorphology)
+      ENUMERATOR(ThickenMorphology)
+      ENUMERATOR(VoronoiMorphology)
+      ENUMERATOR(IterativeDistanceMorphology)
+    END_ENUM
+
+    DEF_ENUM(KernelInfoType)
+      ENUMERATOR(UndefinedKernel)
+      ENUMERATOR(UnityKernel)
+      ENUMERATOR(GaussianKernel)
+      ENUMERATOR(DoGKernel)
+      ENUMERATOR(LoGKernel)
+      ENUMERATOR(BlurKernel)
+      ENUMERATOR(CometKernel)
+      ENUMERATOR(LaplacianKernel)
+      ENUMERATOR(SobelKernel)
+      ENUMERATOR(FreiChenKernel)
+      ENUMERATOR(RobertsKernel)
+      ENUMERATOR(PrewittKernel)
+      ENUMERATOR(CompassKernel)
+      ENUMERATOR(KirschKernel)
+      ENUMERATOR(DiamondKernel)
+      ENUMERATOR(SquareKernel)
+      ENUMERATOR(RectangleKernel)
+      ENUMERATOR(OctagonKernel)
+      ENUMERATOR(DiskKernel)
+      ENUMERATOR(PlusKernel)
+      ENUMERATOR(CrossKernel)
+      ENUMERATOR(RingKernel)
+      ENUMERATOR(PeaksKernel)
+      ENUMERATOR(EdgesKernel)
+      ENUMERATOR(CornersKernel)
+      ENUMERATOR(DiagonalsKernel)
+      ENUMERATOR(LineEndsKernel)
+      ENUMERATOR(LineJunctionsKernel)
+      ENUMERATOR(RidgesKernel)
+      ENUMERATOR(ConvexHullKernel)
+      ENUMERATOR(ThinSEKernel)
+      ENUMERATOR(SkeletonKernel)
+      ENUMERATOR(ChebyshevKernel)
+      ENUMERATOR(ManhattanKernel)
+      ENUMERATOR(OctagonalKernel)
+      ENUMERATOR(EuclideanKernel)
+      ENUMERATOR(UserDefinedKernel)
+#if defined(IMAGEMAGICK_GREATER_THAN_EQUAL_6_8_9)
+      ENUMERATOR(BinomialKernel)
+#endif
+    END_ENUM
+
     /*-----------------------------------------------------------------------*/
     /* Struct classes                                                        */
     /*-----------------------------------------------------------------------*/
@@ -1556,56 +1784,52 @@ Init_RMagick2(void)
     // namespace. The only way to use these classes is via the Magick:: namespace.
 
     // Magick::AffineMatrix
-    Class_AffineMatrix = rb_struct_define(NULL, "sx", "rx", "ry", "sy", "tx", "ty", NULL);
-    rb_define_const(Module_Magick, "AffineMatrix", Class_AffineMatrix);
+    Class_AffineMatrix = rb_struct_define_under(Module_Magick, "AffineMatrix",
+                                                "sx", "rx", "ry", "sy", "tx", "ty", NULL);
 
     // Magick::Primary
-    Class_Primary = rb_struct_define(NULL, "x", "y", "z", NULL);
+    Class_Primary = rb_struct_define_under(Module_Magick, "Primary",
+                                           "x", "y", "z", NULL);
     rb_define_method(Class_Primary, "to_s", PrimaryInfo_to_s, 0);
-    rb_define_const(Module_Magick, "Primary", Class_Primary);
 
     // Magick::Chromaticity
-    Class_Chromaticity = rb_struct_define(NULL
-                                          , "red_primary"
-                                          , "green_primary"
-                                          , "blue_primary"
-                                          , "white_point"
-                                          , NULL);
+    Class_Chromaticity = rb_struct_define_under(Module_Magick, "Chromaticity",
+                                                "red_primary", "green_primary",
+                                                "blue_primary", "white_point", NULL);
     rb_define_method(Class_Chromaticity, "to_s", ChromaticityInfo_to_s, 0);
-    rb_define_const(Module_Magick, "Chromaticity", Class_Chromaticity);
 
     // Magick::Color
-    Class_Color = rb_struct_define(NULL, "name", "compliance", "color", NULL);
+    Class_Color = rb_struct_define_under(Module_Magick, "Color",
+                                         "name", "compliance", "color", NULL);
     rb_define_method(Class_Color, "to_s", Color_to_s, 0);
-    rb_define_const(Module_Magick, "Color", Class_Color);
 
     // Magick::Point
-    Class_Point = rb_struct_define(NULL, "x", "y", NULL);
-    rb_define_const(Module_Magick, "Point", Class_Point);
+    Class_Point = rb_struct_define_under(Module_Magick, "Point",
+                                         "x", "y", NULL);
 
     // Magick::Rectangle
-    Class_Rectangle = rb_struct_define(NULL, "width", "height", "x", "y", NULL);
+    Class_Rectangle = rb_struct_define_under(Module_Magick, "Rectangle",
+                                             "width", "height", "x", "y", NULL);
     rb_define_method(Class_Rectangle, "to_s", RectangleInfo_to_s, 0);
-    rb_define_const(Module_Magick, "Rectangle", Class_Rectangle);
 
     // Magick::Segment
-    Class_Segment = rb_struct_define(NULL, "x1", "y1", "x2", "y2", NULL);
+    Class_Segment = rb_struct_define_under(Module_Magick, "Segment",
+                                           "x1", "y1", "x2", "y2", NULL);
     rb_define_method(Class_Segment, "to_s", SegmentInfo_to_s, 0);
-    rb_define_const(Module_Magick, "Segment", Class_Segment);
 
     // Magick::Font
-    Class_Font = rb_struct_define(NULL, "name", "description",
-                                  "family", "style", "stretch", "weight",
-                                  "encoding", "foundry", "format", NULL);
+    Class_Font = rb_struct_define_under(Module_Magick, "Font",
+                                        "name", "description",
+                                        "family", "style", "stretch", "weight",
+                                        "encoding", "foundry", "format", NULL);
     rb_define_method(Class_Font, "to_s", Font_to_s, 0);
-    rb_define_const(Module_Magick, "Font", Class_Font);
 
     // Magick::TypeMetric
-    Class_TypeMetric = rb_struct_define(NULL, "pixels_per_em", "ascent", "descent",
-                                        "width", "height", "max_advance", "bounds",
-                                        "underline_position", "underline_thickness", NULL);
+    Class_TypeMetric = rb_struct_define_under(Module_Magick, "TypeMetric",
+                                              "pixels_per_em", "ascent", "descent",
+                                              "width", "height", "max_advance", "bounds",
+                                              "underline_position", "underline_thickness", NULL);
     rb_define_method(Class_TypeMetric, "to_s", TypeMetric_to_s, 0);
-    rb_define_const(Module_Magick, "TypeMetric", Class_TypeMetric);
 
 
     /*-----------------------------------------------------------------------*/
@@ -1615,7 +1839,6 @@ Init_RMagick2(void)
     SetFatalErrorHandler(rm_fatal_error_handler);
     SetErrorHandler(rm_error_handler);
     SetWarningHandler(rm_warning_handler);
-
 }
 
 
@@ -1634,9 +1857,8 @@ Init_RMagick2(void)
 static void
 test_Magick_version(void)
 {
-    unsigned long version_number;
+    size_t version_number;
     const char *version_str;
-    int x, n;
     ID bypass = rb_intern("RMAGICK_BYPASS_VERSION_TEST");
 
     if (RTEST(rb_const_defined(rb_cObject, bypass)) && RTEST(rb_const_get(rb_cObject, bypass)))
@@ -1647,6 +1869,8 @@ test_Magick_version(void)
     version_str = GetMagickVersion(&version_number);
     if (version_number != MagickLibVersion)
     {
+        int n, x;
+
         // Extract the string "ImageMagick X.Y.Z"
         n = 0;
         for (x = 0; version_str[x] != '\0'; x++)
@@ -1658,7 +1882,8 @@ test_Magick_version(void)
         }
 
         rb_raise(rb_eRuntimeError,
-                 "This installation of RMagick was configured with %s %s but %.*s is in use.\n" ,
+                 "This installation of RMagick was configured with %s %s but %.*s is in use.\n"
+                 "Please re-install RMagick to correct the issue.\n",
                  MagickPackageName, MagickLibVersionText, x, version_str);
     }
 
@@ -1677,7 +1902,7 @@ static void
 version_constants(void)
 {
     const char *mgk_version;
-    volatile VALUE str;
+    VALUE str;
     char long_version[1000];
 
     mgk_version = GetMagickVersion(NULL);
@@ -1690,7 +1915,7 @@ version_constants(void)
     rb_obj_freeze(str);
     rb_define_const(Module_Magick, "Version", str);
 
-    sprintf(long_version,
+    snprintf(long_version, sizeof(long_version),
             "This is %s ($Date: 2009/12/20 02:33:33 $) Copyright (C) 2009 by Timothy P. Hunter\n"
             "Built with %s\n"
             "Built for %s\n"
@@ -1702,4 +1927,25 @@ version_constants(void)
     rb_obj_freeze(str);
     rb_define_const(Module_Magick, "Long_version", str);
 
+    RB_GC_GUARD(str);
+}
+
+
+/**
+ * Create Features constant.
+ *
+ * No Ruby usage (internal function)
+ */
+static void
+features_constant(void)
+{
+    VALUE features;
+
+    // 6.5.7 - latest (7.0.0)
+    features = rb_str_new2(GetMagickFeatures());
+
+    rb_obj_freeze(features);
+    rb_define_const(Module_Magick, "Magick_features", features);
+
+    RB_GC_GUARD(features);
 }