rmagick 2.13.2 → 4.2.2

data/ext/RMagick/rmpixel.c

@@ -12,12 +12,13 @@
 
 #include "rmagick.h"
 
+#if defined(IMAGEMAGICK_6)
+    #define QueryColorname QueryMagickColorname
+#endif
 
 
-
-static void Color_Name_to_PixelPacket(PixelPacket *, VALUE);
-
-
+static VALUE color_arg_rescue(VALUE, VALUE ATTRIBUTE_UNUSED) ATTRIBUTE_NORETURN;
+static void Color_Name_to_PixelColor(PixelColor *, VALUE);
 
 
 /**
@@ -35,125 +36,309 @@ destroy_Pixel(Pixel *pixel)
 
 
 /**
- * Get Pixel red attribute.
+ * Get Pixel red value.
  *
- * Ruby usage:
- *   - @verbatim Pixel#red @endverbatim
+ * @return [Numeric] the red value
+ */
+VALUE
+Pixel_red(VALUE self)
+{
+    IMPLEMENT_ATTR_READER(Pixel, red, int);
+}
+
+/**
+ * Get Pixel green value.
  *
- * @param self this object
- * @return the red value
+ * @return [Numeric] the green value
  */
-DEF_ATTR_READER(Pixel, red, int)
+VALUE
+Pixel_green(VALUE self)
+{
+    IMPLEMENT_ATTR_READER(Pixel, green, int);
+}
 
 /**
- * Get Pixel green attribute.
+ * Get Pixel blue value.
  *
- * Ruby usage:
- *   - @verbatim Pixel#green @endverbatim
+ * @return [Numeric] the blue value
+ */
+VALUE
+Pixel_blue(VALUE self)
+{
+    IMPLEMENT_ATTR_READER(Pixel, blue, int);
+}
+
+/**
+ * Get Pixel alpha value.
  *
- * @param self this object
- * @return the green value
+ * @return [Numeric] the alpha value
  */
-DEF_ATTR_READER(Pixel, green, int)
+VALUE
+Pixel_alpha(VALUE self)
+{
+    Pixel *pixel;
+    Data_Get_Struct(self, Pixel, pixel);
+#if defined(IMAGEMAGICK_7)
+    return C_int_to_R_int(pixel->alpha);
+#else
+    return C_int_to_R_int(QuantumRange - pixel->opacity);
+#endif
+}
 
 /**
- * Get Pixel blue attribute.
+ * Set Pixel red value.
  *
- * Ruby usage:
- *   - @verbatim Pixel#blue @endverbatim
+ * - Pixel is Observable. Setters call {Magick::Pixel#changed},
+ *   {Magick::Pixel#notify_observers}
+ * - Setters return their argument values for backward compatibility to when
+ *   Pixel was a Struct class.
  *
- * @param self this object
- * @return the blue value
+ * @param v [Numeric] the red value
+ * @return [Numeric] the given red value
  */
-DEF_ATTR_READER(Pixel, blue, int)
+VALUE
+Pixel_red_eq(VALUE self, VALUE v)
+{
+    Pixel *pixel;
+
+    rb_check_frozen(self);
+    Data_Get_Struct(self, Pixel, pixel);
+    pixel->red = APP2QUANTUM(v);
+    rb_funcall(self, rm_ID_changed, 0);
+    rb_funcall(self, rm_ID_notify_observers, 1, self);
+    return QUANTUM2NUM((pixel->red));
+}
 
 /**
- * Get Pixel opacity attribute.
+ * Set Pixel green value.
  *
- * Ruby usage:
- *   - @verbatim Pixel#opacity @endverbatim
+ * - Pixel is Observable. Setters call {Magick::Pixel#changed},
+ *   {Magick::Pixel#notify_observers}
+ * - Setters return their argument values for backward compatibility to when
+ *   Pixel was a Struct class.
  *
- * @param self this object
- * @return the opacity value
+ * @param v [Numeric] the green value
+ * @return [Numeric] the given green value
  */
-DEF_ATTR_READER(Pixel, opacity, int)
+VALUE
+Pixel_green_eq(VALUE self, VALUE v)
+{
+    Pixel *pixel;
+
+    rb_check_frozen(self);
+    Data_Get_Struct(self, Pixel, pixel);
+    pixel->green = APP2QUANTUM(v);
+    rb_funcall(self, rm_ID_changed, 0);
+    rb_funcall(self, rm_ID_notify_observers, 1, self);
+    return QUANTUM2NUM((pixel->green));
+}
 
 /**
- * Set Pixel red attribute.
+ * Set Pixel blue value.
  *
- * Ruby usage:
- *   - @verbatim Pixel#red= @endverbatim
+ * - Pixel is Observable. Setters call {Magick::Pixel#changed},
+ *   {Magick::Pixel#notify_observers}
+ * - Setters return their argument values for backward compatibility to when
+ *   Pixel was a Struct class.
  *
- * Notes:
- *   - Pixel is Observable. Setters call changed, notify_observers
- *   - Setters return their argument values for backward compatibility to when
- *     Pixel was a Struct class.
+ * @param v [Numeric] the blue value
+ * @return [Numeric] the given blue value
+ */
+VALUE
+Pixel_blue_eq(VALUE self, VALUE v)
+{
+    Pixel *pixel;
+
+    rb_check_frozen(self);
+    Data_Get_Struct(self, Pixel, pixel);
+    pixel->blue = APP2QUANTUM(v);
+    rb_funcall(self, rm_ID_changed, 0);
+    rb_funcall(self, rm_ID_notify_observers, 1, self);
+    return QUANTUM2NUM((pixel->blue));
+}
+
+/**
+ * Set Pixel alpha value.
  *
- * @param self this object
- * @param v the red value
- * @return self
+ * - Pixel is Observable. Setters call {Magick::Pixel#changed},
+ *   {Magick::Pixel#notify_observers}
+ * - Setters return their argument values for backward compatibility to when
+ *   Pixel was a Struct class.
+ *
+ * @param v [Numeric] the alpha value
+ * @return [Numeric] the given alpha value
  */
-DEF_PIXEL_CHANNEL_WRITER(red)
+VALUE
+Pixel_alpha_eq(VALUE self, VALUE v)
+{
+    Pixel *pixel;
+ 
+    rb_check_frozen(self);
+    Data_Get_Struct(self, Pixel, pixel);
+#if defined(IMAGEMAGICK_7)
+    pixel->alpha = APP2QUANTUM(v);
+    rb_funcall(self, rm_ID_changed, 0);
+    rb_funcall(self, rm_ID_notify_observers, 1, self);
+    return QUANTUM2NUM(pixel->alpha);
+#else
+    pixel->opacity = QuantumRange - APP2QUANTUM(v);
+    rb_funcall(self, rm_ID_changed, 0);
+    rb_funcall(self, rm_ID_notify_observers, 1, self);
+    return QUANTUM2NUM(QuantumRange - pixel->opacity);
+#endif
+}
 
 /**
- * Set Pixel green attribute.
+ * Get Pixel cyan value.
  *
- * Ruby usage:
- *   - @verbatim Pixel#green= @endverbatim
+ * @return [Numeric] the cyan value
+ */
+VALUE
+Pixel_cyan(VALUE self)
+{
+    Pixel *pixel;
+
+    Data_Get_Struct(self, Pixel, pixel);
+    return INT2NUM(pixel->red);
+}
+
+/**
+ * Set Pixel cyan value.
  *
- * Notes:
- *   - Pixel is Observable. Setters call changed, notify_observers
- *   - Setters return their argument values for backward compatibility to when
- *     Pixel was a Struct class.
+ * - Pixel is Observable. Setters call {Magick::Pixel#changed},
+ *   {Magick::Pixel#notify_observers}
+ * - Setters return their argument values for backward compatibility to when
+ *   Pixel was a Struct class.
  *
- * @param self this object
- * @param v the green value
- * @return self
+ * @param v [Numeric] the cyan value
+ * @return [Numeric] the given cyan value
+ */
+VALUE
+Pixel_cyan_eq(VALUE self, VALUE v)
+{
+    Pixel *pixel;
+
+    rb_check_frozen(self);
+    Data_Get_Struct(self, Pixel, pixel);
+    pixel->red = APP2QUANTUM(v);
+    rb_funcall(self, rm_ID_changed, 0);
+    rb_funcall(self, rm_ID_notify_observers, 1, self);
+    return QUANTUM2NUM(pixel->red);
+}
+
+/**
+ * Get Pixel magenta value.
+ *
+ * @return [Numeric] the magenta value
  */
-DEF_PIXEL_CHANNEL_WRITER(green)
+VALUE
+Pixel_magenta(VALUE self)
+{
+    Pixel *pixel;
+
+    Data_Get_Struct(self, Pixel, pixel);
+    return INT2NUM(pixel->green);
+}
 
 /**
- * Set Pixel blue attribute.
+ * Set Pixel magenta value.
  *
- * Ruby usage:
- *   - @verbatim Pixel#blue= @endverbatim
+ * - Pixel is Observable. Setters call {Magick::Pixel#changed},
+ *   {Magick::Pixel#notify_observers}
+ * - Setters return their argument values for backward compatibility to when
+ *   Pixel was a Struct class.
  *
- * Notes:
- *   - Pixel is Observable. Setters call changed, notify_observers
- *   - Setters return their argument values for backward compatibility to when
- *     Pixel was a Struct class.
+ * @param v [Numeric] the magenta value
+ * @return [Numeric] the given magenta value
+ */
+VALUE
+Pixel_magenta_eq(VALUE self, VALUE v)
+{
+    Pixel *pixel;
+
+    rb_check_frozen(self);
+    Data_Get_Struct(self, Pixel, pixel);
+    pixel->green = APP2QUANTUM(v);
+    rb_funcall(self, rm_ID_changed, 0);
+    rb_funcall(self, rm_ID_notify_observers, 1, self);
+    return QUANTUM2NUM(pixel->green);
+}
+
+/**
+ * Get Pixel yellow value.
  *
- * @param self this object
- * @param v the blue value
- * @return self
+ * @return [Numeric] the yellow value
  */
-DEF_PIXEL_CHANNEL_WRITER(blue)
+VALUE
+Pixel_yellow(VALUE self)
+{
+    Pixel *pixel;
+
+    Data_Get_Struct(self, Pixel, pixel);
+    return INT2NUM(pixel->blue);
+}
 
 /**
- * Set Pixel opacity attribute.
+ * Set Pixel yellow value.
  *
- * Ruby usage:
- *   - @verbatim Pixel#opacity= @endverbatim
+ * - Pixel is Observable. Setters call {Magick::Pixel#changed},
+ *   {Magick::Pixel#notify_observers}
+ * - Setters return their argument values for backward compatibility to when
+ *   Pixel was a Struct class.
  *
- * Notes:
- *   - Pixel is Observable. Setters call changed, notify_observers
- *   - Setters return their argument values for backward compatibility to when
- *     Pixel was a Struct class.
+ * @param v [Numeric] the yellow value
+ * @return [Numeric] the given yellow value
+ */
+VALUE
+Pixel_yellow_eq(VALUE self, VALUE v)
+{
+    Pixel *pixel;
+
+    rb_check_frozen(self);
+    Data_Get_Struct(self, Pixel, pixel);
+    pixel->blue = APP2QUANTUM(v);
+    rb_funcall(self, rm_ID_changed, 0);
+    rb_funcall(self, rm_ID_notify_observers, 1, self);
+    return QUANTUM2NUM(pixel->blue);
+}
+
+/**
+ * Get Pixel black value.
  *
- * @param self this object
- * @param v the opacity value
- * @return self
+ * @return [Numeric] the black value
  */
-DEF_PIXEL_CHANNEL_WRITER(opacity)
+VALUE
+Pixel_black(VALUE self)
+{
+    Pixel *pixel;
 
+    Data_Get_Struct(self, Pixel, pixel);
+    return INT2NUM(pixel->black);
+}
 
-/*
- * Get/set Pixel CMYK attributes.
+/**
+ * Set Pixel black value.
+ *
+ * - Pixel is Observable. Setters call {Magick::Pixel#changed},
+ *   {Magick::Pixel#notify_observers}
+ * - Setters return their argument values for backward compatibility to when
+ *   Pixel was a Struct class.
+ *
+ * @param v [Numeric] the black value
+ * @return [Numeric] the given black value
  */
-DEF_PIXEL_CMYK_CHANNEL_ACCESSOR(cyan, red)
-DEF_PIXEL_CMYK_CHANNEL_ACCESSOR(magenta, green)
-DEF_PIXEL_CMYK_CHANNEL_ACCESSOR(yellow, blue)
-DEF_PIXEL_CMYK_CHANNEL_ACCESSOR(black, opacity)
+VALUE
+Pixel_black_eq(VALUE self, VALUE v)
+{
+    Pixel *pixel;
+
+    rb_check_frozen(self);
+    Data_Get_Struct(self, Pixel, pixel);
+    pixel->black = APP2QUANTUM(v);
+    rb_funcall(self, rm_ID_changed, 0);
+    rb_funcall(self, rm_ID_notify_observers, 1, self);
+    return QUANTUM2NUM(pixel->black);
+}
 
 
 /**
@@ -167,62 +352,108 @@ DEF_PIXEL_CMYK_CHANNEL_ACCESSOR(black, opacity)
  * @throw ArgumentError
  */
 static VALUE
-color_arg_rescue(VALUE arg)
+color_arg_rescue(VALUE arg, VALUE raised_exc ATTRIBUTE_UNUSED)
 {
     rb_raise(rb_eTypeError, "argument must be color name or pixel (%s given)",
             rb_class2name(CLASS_OF(arg)));
-    return (VALUE)0;
 }
 
 
 /**
- * Convert either a String color name or a Magick::Pixel to a PixelPacket.
+ * Convert either a String color name or a Magick::Pixel to a PixelColor.
  *
  * No Ruby usage (internal function)
  *
- * @param pp the PixelPacket to modify
+ * @param pp the PixelColor to modify
  * @param color the color name or Magick::Pixel
  */
 void
-Color_to_PixelPacket(PixelPacket *pp, VALUE color)
+Color_to_PixelColor(PixelColor *pp, VALUE color)
 {
     Pixel *pixel;
 
     // Allow color name or Pixel
     if (CLASS_OF(color) == Class_Pixel)
     {
+        memset(pp, 0, sizeof(*pp));
         Data_Get_Struct(color, Pixel, pixel);
-        *pp = *pixel;
+        pp->red     = pixel->red;
+        pp->green   = pixel->green;
+        pp->blue    = pixel->blue;
+#if defined(IMAGEMAGICK_7)
+        pp->alpha   = pixel->alpha;
+        pp->black   = pixel->black;
+#else
+        pp->opacity = pixel->opacity;
+#endif
     }
     else
     {
         // require 'to_str' here instead of just 'to_s'.
         color = rb_rescue(rb_str_to_str, color, color_arg_rescue, color);
-        Color_Name_to_PixelPacket(pp, color);
+        Color_Name_to_PixelColor(pp, color);
     }
 }
 
 
 /**
- * Convert a color name to a PixelPacket
+ * Convert either a String color name or a {Magick::Pixel} to a Pixel.
  *
  * No Ruby usage (internal function)
  *
- * @param color the PixelPacket to modify
+ * @param pp the Pixel to modify
+ * @param color the color name or Magick::Pixel
+ */
+void
+Color_to_Pixel(Pixel *pp, VALUE color)
+{
+    PixelColor pixel_color;
+
+    memset(pp, 0, sizeof(*pp));
+    // Allow color name or Pixel
+    if (CLASS_OF(color) == Class_Pixel)
+    {
+        Pixel *pixel;
+
+        Data_Get_Struct(color, Pixel, pixel);
+        memcpy(pp, pixel, sizeof(Pixel));
+    }
+    else
+    {
+        Color_to_PixelColor(&pixel_color, color);
+        pp->red   = pixel_color.red;
+        pp->green = pixel_color.green;
+        pp->blue  = pixel_color.blue;
+#if defined(IMAGEMAGICK_7)
+        pp->alpha = pixel_color.alpha;
+        pp->black = pixel_color.black;
+#else
+        pp->opacity = pixel_color.opacity;
+#endif
+    }
+}
+
+
+/**
+ * Convert a color name to a PixelColor
+ *
+ * No Ruby usage (internal function)
+ *
+ * @param color the PixelColor to modify
  * @param name_arg the coor name
  * @throw ArgumentError
  */
 static void
-Color_Name_to_PixelPacket(PixelPacket *color, VALUE name_arg)
+Color_Name_to_PixelColor(PixelColor *color, VALUE name_arg)
 {
     MagickBooleanType okay;
     char *name;
-    ExceptionInfo exception;
+    ExceptionInfo *exception;
 
-    GetExceptionInfo(&exception);
-    name = StringValuePtr(name_arg);
-    okay = QueryColorDatabase(name, color, &exception);
-    (void) DestroyExceptionInfo(&exception);
+    exception = AcquireExceptionInfo();
+    name = StringValueCStr(name_arg);
+    okay = QueryColorCompliance(name, AllCompliance, color, exception);
+    DestroyExceptionInfo(exception);
     if (!okay)
     {
         rb_raise(rb_eArgError, "invalid color name %s", name);
@@ -234,10 +465,7 @@ Color_Name_to_PixelPacket(PixelPacket *color, VALUE name_arg)
 /**
  * Allocate a Pixel object.
  *
- * No Ruby usage (internal function)
- *
- * @param class the Ruby class to use
- * @return a new Magick::Pixel object
+ * @return [Magick::Pixel] a new Magick::Pixel object
  */
 VALUE
 Pixel_alloc(VALUE class)
@@ -253,27 +481,27 @@ Pixel_alloc(VALUE class)
 /**
  * "Case equal" operator for Pixel.
  *
- * Ruby usage:
- *   - @verbatim Pixel#=== @endverbatim
- *
- * @param self this object
- * @param other the other object
- * @return true or false
+ * @param other [Object] the other object
+ * @return [Boolean] true or false
  */
 
 VALUE
 Pixel_case_eq(VALUE self, VALUE other)
 {
-    Pixel *this, *that;
-
     if (CLASS_OF(self) == CLASS_OF(other))
     {
+        Pixel *this, *that;
+
         Data_Get_Struct(self, Pixel, this);
         Data_Get_Struct(other, Pixel, that);
         return (this->red == that->red
             && this->blue == that->blue
             && this->green == that->green
+#if defined(IMAGEMAGICK_7)
+            && this->alpha == that->alpha) ? Qtrue : Qfalse;
+#else
             && this->opacity == that->opacity) ? Qtrue : Qfalse;
+#endif
     }
 
     return Qfalse;
@@ -283,18 +511,14 @@ Pixel_case_eq(VALUE self, VALUE other)
 /**
  * Clone a Pixel.
  *
- * Ruby usage:
- *   - @verbatim Pixel#clone @endverbatim
- *
- * @param self this object
- * @return a clone
- * @see Pixel_dup
- * @see Pixel_init_copy
+ * @return [Magick::Pixel] a clone object
+ * @see #dup
+ * @see #initialize_copy
  */
 VALUE
 Pixel_clone(VALUE self)
 {
-    volatile VALUE clone;
+    VALUE clone;
 
     clone = Pixel_dup(self);
     if (OBJ_FROZEN(self))
@@ -302,6 +526,8 @@ Pixel_clone(VALUE self)
         OBJ_FREEZE(clone);
     }
 
+    RB_GC_GUARD(clone);
+
     return clone;
 }
 
@@ -309,40 +535,30 @@ Pixel_clone(VALUE self)
 /**
  * Duplicate a Pixel.
  *
- * Ruby usage:
- *   - @verbatim Pixel#dup @endverbatim
- *
- * @param self this object
- * @return a clone
- * @see Pixel_clone
- * @see Pixel_init_copy
+ * @return [Magick::Pixel] a duplicated object
+ * @see #clone
+ * @see #initialize_copy
  */
 VALUE
 Pixel_dup(VALUE self)
 {
     Pixel *pixel;
-    volatile VALUE dup;
+    VALUE dup;
 
     pixel = ALLOC(Pixel);
     memset(pixel, '\0', sizeof(Pixel));
     dup = Data_Wrap_Struct(CLASS_OF(self), NULL, destroy_Pixel, pixel);
-    if (rb_obj_tainted(self))
-    {
-        (void) rb_obj_taint(dup);
-    }
+    RB_GC_GUARD(dup);
+
     return rb_funcall(dup, rm_ID_initialize_copy, 1, self);
 }
 
 
 /**
- * For use with Hash.
- *
- * Ruby usage:
- *   - @verbatim Pixel#eql? @endverbatim
+ * Equality. Returns true only if receiver and other are the same object.
  *
- * @param self this object
- * @param other the other object
- * @return true if hash to the same value, otherwise false
+ * @param other [Object] the other object
+ * @return [Boolean] true if other is the same value, otherwise false
  */
 VALUE
 Pixel_eql_q(VALUE self, VALUE other)
@@ -354,28 +570,23 @@ Pixel_eql_q(VALUE self, VALUE other)
 /**
  * Compare pixel values for equality.
  *
- * Ruby usage:
- *   - @verbatim Pixel#fcmp(other, fuzz, colorspace) @endverbatim
- *
- * Notes:
- *   - Default fuzz is 0.0
- *   - Default colorspace is RGBColorspace
- *
- * @param argc number of input arguments
- * @param argv array of input arguments
- * @param self this object
- * @return true if equal, otherwise false
+ * @overload fcmp(other, fuzz = 0.0, colorspace = Magick::RGBColorspace)
+ *   @param other [Magick::Pixel] The pixel to which the receiver is compared
+ *   @param fuzz [Float] The amount of fuzz to allow before the colors are considered to be different
+ *   @param colorspace [Magick::ColorspaceType] The colorspace
+ *   @return [Boolean] true if equal, otherwise false
  */
 VALUE
 Pixel_fcmp(int argc, VALUE *argv, VALUE self)
 {
-    Image *image;
-    Info *info;
-
-    Pixel *this, *that;
-    ColorspaceType colorspace = RGBColorspace;
     double fuzz = 0.0;
     unsigned int equal;
+    ColorspaceType colorspace = RGBColorspace;
+    PixelColor this, that;
+#if defined(IMAGEMAGICK_6)
+    Image *image;
+    Info *info;
+#endif
 
     switch (argc)
     {
@@ -391,9 +602,16 @@ Pixel_fcmp(int argc, VALUE *argv, VALUE self)
             break;
     }
 
-    Data_Get_Struct(self, Pixel, this);
-    Data_Get_Struct(argv[0], Pixel, that);
+    Color_to_PixelColor(&this, self);
+    Color_to_PixelColor(&that, argv[0]);
 
+#if defined(IMAGEMAGICK_7)
+    this.fuzz = fuzz;
+    this.colorspace = colorspace;
+    that.fuzz = fuzz;
+    that.colorspace = colorspace;
+    equal = IsFuzzyEquivalencePixelInfo(&this, &that);
+#else
     // The IsColorSimilar function expects to get the
     // colorspace and fuzz parameters from an Image structure.
 
@@ -403,10 +621,10 @@ Pixel_fcmp(int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eNoMemError, "not enough memory to continue");
     }
 
-    image = AcquireImage(info);
+    image = rm_acquire_image(info);
 
     // Delete Info now in case we have to raise an exception
-    (void) DestroyImageInfo(info);
+    DestroyImageInfo(info);
 
     if (!image)
     {
@@ -416,95 +634,82 @@ Pixel_fcmp(int argc, VALUE *argv, VALUE self)
     image->colorspace = colorspace;
     image->fuzz = fuzz;
 
-    equal = IsColorSimilar(image, this, that);
-    (void) DestroyImage(image);
+    equal = IsColorSimilar(image, &this, &that);
+    DestroyImage(image);
+#endif
 
     return equal ? Qtrue : Qfalse;
 }
 
 
 /**
- * Construct an Magick::Pixel corresponding to the given color name.
+ * Construct an {Magick::Pixel} corresponding to the given color name.
  *
- * Ruby usage:
- *   - @verbatim Magick::Pixel.from_color(string) @endverbatim
+ * - The "inverse" is {Image#to_color}, b/c the conversion of a pixel to a
+ *   color name requires both a color depth and if the opacity value has
+ *   meaning.
  *
- * Notes:
- *   - The "inverse" is Image_to_color, b/c the conversion of a pixel to a
- *     color name requires both a color depth and if the opacity value has
- *     meaning (i.e. whether image->matte == True or not).
- *
- * @param class the Ruby class to use
- * @param name the color name
- * @return a new Magic::Pixel object
- * @see Image_to_color
- * @see Pixel_to_color
+ * @param name [String] the color name
+ * @return [Magick::Pixel] a new Magic::Pixel object
+ * @see Magick::Image#to_color
+ * @see Magick::Pixel#to_color
  */
 VALUE
-Pixel_from_color(VALUE class, VALUE name)
+Pixel_from_color(VALUE class ATTRIBUTE_UNUSED, VALUE name)
 {
-    PixelPacket pp;
-    ExceptionInfo exception;
+    PixelColor pp;
+    ExceptionInfo *exception;
     MagickBooleanType okay;
 
-    class = class;      // defeat "never referenced" message from icc
-
-    GetExceptionInfo(&exception);
-    okay = QueryColorDatabase(StringValuePtr(name), &pp, &exception);
-    CHECK_EXCEPTION()
-    (void) DestroyExceptionInfo(&exception);
+    exception = AcquireExceptionInfo();
+    okay = QueryColorCompliance(StringValueCStr(name), AllCompliance, &pp, exception);
+    CHECK_EXCEPTION();
+    DestroyExceptionInfo(exception);
 
     if (!okay)
     {
-        rb_raise(rb_eArgError, "invalid color name: %s", StringValuePtr(name));
+        rb_raise(rb_eArgError, "invalid color name: %s", StringValueCStr(name));
     }
 
-    return Pixel_from_PixelPacket(&pp);
+    return Pixel_from_PixelColor(&pp);
 }
 
 
 /**
  * Construct an RGB pixel.
  *
- * Ruby usage:
- *   - @verbatim Pixel#from_hsla(hue, saturation, lightness) @endverbatim
- *   - @verbatim Pixel#from_hsla(hue, saturation, lightness, alpha) @endverbatim
- *
- * Notes:
- *   - Default alpha is 1.0
- *   - 0 <= hue < 360 OR "0%" <= hue < "100%"
- *   - 0 <= saturation <= 255 OR "0%" <= saturation <= "100%"
- *   - 0 <= lightness <= 255 OR "0%" <= lightness <= "100%"
- *   - 0 <= alpha <= 1 (0 is transparent, 1 is opaque) OR "0%" <= alpha <= "100%"
- *   - Replaces brain-dead Pixel_from_HSL.
- *
- * @param argc number of input arguments
- * @param argv array of input arguments
- * @param class the Ruby class to use
- * @return a new Magick::Pixel object
+ * - 0 <= +hue+ < 360 OR "0%" <= +hue+ < "100%"
+ * - 0 <= +saturation+ <= 255 OR "0%" <= +saturation+ <= "100%"
+ * - 0 <= +lightness+ <= 255 OR "0%" <= +lightness+ <= "100%"
+ * - 0 <= +alpha+ <= 1 (0 is transparent, 1 is opaque) OR "0%" <= +alpha+ <= "100%"
+ *
+ * @overload from_hsla(hue, saturation, lightness, alpha = 1.0)
+ *   @param hue [Numeric, String] A value in the range.
+ *   @param saturation [Numeric, String] A value in the range.
+ *   @param lightness [Numeric, String] A value in the range.
+ *   @param alpha [Numeric] The alpha value.
+ *   @return [Magick::Pixel] a new Magick::Pixel object
  */
 VALUE
-Pixel_from_hsla(int argc, VALUE *argv, VALUE class)
+Pixel_from_hsla(int argc, VALUE *argv, VALUE class ATTRIBUTE_UNUSED)
 {
     double h, s, l, a = 1.0;
-    MagickPixelPacket pp;
-    ExceptionInfo exception;
+    MagickPixel pp;
+    ExceptionInfo *exception;
     char name[50];
     MagickBooleanType alpha = MagickFalse;
 
-    class = class;          // defeat "unused parameter" message.
-
     switch (argc)
     {
         case 4:
-            a = rm_percentage(argv[3],1.0);
+            a = rm_percentage(argv[3], 1.0);
             alpha = MagickTrue;
         case 3:
             // saturation and lightness are out of 255 in new ImageMagicks and
             // out of 100 in old ImageMagicks. Compromise: always use %.
-            l = rm_percentage(argv[2],255.0); 
-            s = rm_percentage(argv[1],255.0);
-            h = rm_percentage(argv[0],360.0);
+            l = rm_percentage(argv[2], 255.0);
+            s = rm_percentage(argv[1], 255.0);
+            h = rm_percentage(argv[0], 360.0);
             break;
         default:
             rb_raise(rb_eArgError, "wrong number of arguments (%d for 3 or 4)", argc);
@@ -528,131 +733,130 @@ Pixel_from_hsla(int argc, VALUE *argv, VALUE class)
         rb_raise(rb_eRangeError, "hue %g out of range [0.0, 360.0)", h);
     }
 
-    // Ugly way of checking for change in ImageMagick 6.5.6-5 to see whether
-    // saturation/lightness should be out of 255 or out of 100.
-    if(MagickLibVersion < 0x656 ||
-        (MagickLibVersion == 0x656 && strcmp(MagickLibSubversion,"-5") <= 0) )
-    {
-      s = s/2.55;
-      l = l/2.55;
-    }
-
     memset(name, 0, sizeof(name));
     if (alpha)
     {
-        sprintf(name, "hsla(%-2.1f,%-2.1f,%-2.1f,%-2.1f)", h, s, l, a);
+        snprintf(name, sizeof(name), "hsla(%-2.1f,%-2.1f,%-2.1f,%-2.1f)", h, s, l, a);
     }
     else
     {
-        sprintf(name, "hsl(%-2.1f,%-2.1f,%-2.1f)", h, s, l);
+        snprintf(name, sizeof(name), "hsl(%-2.1f,%-2.1f,%-2.1f)", h, s, l);
     }
 
-    GetExceptionInfo(&exception);
+    exception = AcquireExceptionInfo();
 
-    (void) QueryMagickColor(name, &pp, &exception);
-    CHECK_EXCEPTION()
+#if defined(IMAGEMAGICK_7)
+    QueryColorCompliance(name, AllCompliance, &pp, exception);
+#else
+    QueryMagickColor(name, &pp, exception);
+#endif
+    CHECK_EXCEPTION();
 
-    (void) DestroyExceptionInfo(&exception);
+    DestroyExceptionInfo(exception);
 
-    return Pixel_from_MagickPixelPacket(&pp);
+    return Pixel_from_MagickPixel(&pp);
 }
 
 
 /**
- * Construct an RGB pixel from the array [hue, saturation, luminosity].
+ * Create a Magick::Pixel object from a MagickPixel structure.
+ *
+ * No Ruby usage (internal function)
  *
- * Ruby usage:
- *   - @verbatim Pixel.from_HSL  @endverbatim
+ * Notes:
+ *   - Bypasses normal Pixel.new, Pixel#initialize methods
  *
- * @param class the Ruby class to use
- * @param hsl the array
+ * @param pp the MagickPixel
  * @return a new Magick::Pixel object
- * @deprecated This method has been deprecated. Please use Pixel_from_hsla.
  */
 VALUE
-Pixel_from_HSL(VALUE class, VALUE hsl)
+Pixel_from_MagickPixel(const MagickPixel *pp)
 {
-    PixelPacket rgb;
-    double hue, saturation, luminosity;
-
-    class = class;      // defeat "never referenced" message from icc
-    memset(&rgb, 0, sizeof(rgb));
-
-    hsl = rb_Array(hsl);    // Ensure array
-    if (RARRAY_LEN(hsl) < 3)
-    {
-        rb_raise(rb_eArgError, "array argument must have at least 3 elements");
-    }
+    Pixel *pixel;
 
-    hue        = NUM2DBL(rb_ary_entry(hsl, 0));
-    saturation = NUM2DBL(rb_ary_entry(hsl, 1));
-    luminosity = NUM2DBL(rb_ary_entry(hsl, 2));
+    pixel          = ALLOC(Pixel);
+    pixel->red     = pp->red;
+    pixel->green   = pp->green;
+    pixel->blue    = pp->blue;
+#if defined(IMAGEMAGICK_7)
+    pixel->alpha   = pp->alpha;
+#else
+    pixel->opacity = pp->opacity;
+#endif
+    pixel->black   = pp->index;
 
-    rb_warning("Pixel#from_HSL is deprecated; use from_hsla");
-    ConvertHSLToRGB(hue, saturation, luminosity,
-                 &rgb.red, &rgb.green, &rgb.blue);
-    return Pixel_from_PixelPacket(&rgb);
+    return Data_Wrap_Struct(Class_Pixel, NULL, destroy_Pixel, pixel);
 }
 
 
 /**
- * Create a Magick::Pixel object from a MagickPixelPacket structure.
+ * Create a Magick::Pixel object from a PixelPacket structure.
  *
  * No Ruby usage (internal function)
  *
  * Notes:
  *   - Bypasses normal Pixel.new, Pixel#initialize methods
  *
- * @param pp the MagickPixelPacket
+ * @param pp the PixelPacket
  * @return a new Magick::Pixel object
  */
 VALUE
-Pixel_from_MagickPixelPacket(const MagickPixelPacket *pp)
+Pixel_from_PixelPacket(const PixelPacket *pp)
 {
     Pixel *pixel;
 
     pixel          = ALLOC(Pixel);
-    pixel->red     = ROUND_TO_QUANTUM(pp->red);
-    pixel->green   = ROUND_TO_QUANTUM(pp->green);
-    pixel->blue    = ROUND_TO_QUANTUM(pp->blue);
-    pixel->opacity = ROUND_TO_QUANTUM(pp->opacity);
+    pixel->red     = pp->red;
+    pixel->green   = pp->green;
+    pixel->blue    = pp->blue;
+#if defined(IMAGEMAGICK_7)
+    pixel->alpha   = pp->alpha;
+    pixel->black   = pp->black;
+#else
+    pixel->opacity = pp->opacity;
+    pixel->black   = 0;
+#endif
 
     return Data_Wrap_Struct(Class_Pixel, NULL, destroy_Pixel, pixel);
 }
 
 
 /**
- * Create a Magick::Pixel object from a PixelPacket structure.
+ * Create a Magick::Pixel object from a PixelColor structure.
  *
  * No Ruby usage (internal function)
  *
  * Notes:
  *   - Bypasses normal Pixel.new, Pixel#initialize methods
  *
- * @param pp the PixelPacket
+ * @param pp the PixelColor
  * @return a new Magick::Pixel object
  */
 VALUE
-Pixel_from_PixelPacket(const PixelPacket *pp)
+Pixel_from_PixelColor(const PixelColor *pp)
 {
     Pixel *pixel;
 
-    pixel = ALLOC(Pixel);
-    *pixel = *pp;
+    pixel          = ALLOC(Pixel);
+    pixel->red     = pp->red;
+    pixel->green   = pp->green;
+    pixel->blue    = pp->blue;
+#if defined(IMAGEMAGICK_7)
+    pixel->alpha   = pp->alpha;
+    pixel->black   = pp->black;
+#else
+    pixel->opacity = pp->opacity;
+    pixel->black   = 0;
+#endif
+
     return Data_Wrap_Struct(Class_Pixel, NULL, destroy_Pixel, pixel);
 }
 
 
 /**
- * Ruby usage:
- *   - @verbatim Pixel#hash @endverbatim
- *
- * Notes:
- *   - INT2FIX left-shifts 1 bit. Sacrifice 1 bit from the opacity attribute to
- *     the FIXNUM_FLAG.
+ * Compute a hash-code.
  *
- * @param self this object
- * @return the hash of self
+ * @return [Numeric] the hash of self
  */
 VALUE
 Pixel_hash(VALUE self)
@@ -665,25 +869,23 @@ Pixel_hash(VALUE self)
     hash  = ScaleQuantumToChar(pixel->red)   << 24;
     hash += ScaleQuantumToChar(pixel->green) << 16;
     hash += ScaleQuantumToChar(pixel->blue)  << 8;
-    hash += ScaleQuantumToChar(pixel->opacity);
-    hash >>= 1;
-
-    return INT2FIX(hash);
+#if defined(IMAGEMAGICK_7)
+    hash += ScaleQuantumToChar(pixel->alpha);
+#else
+    hash += ScaleQuantumToChar(QuantumRange - pixel->opacity);
+#endif
 
+    return UINT2NUM(hash >> 1);
 }
 
 
 /**
  * Initialize clone, dup methods.
  *
- * Ruby usage:
- *   - @verbatim Pixel#initialize_copy @endverbatim
- *
- * @param self this object
- * @param orig the original Pixel
- * @return self
- * @see Pixel_clone
- * @see Pixel_dup
+ * @param orig [Magick::Pixel] the original Pixel
+ * @return [Magick::Pixel] self
+ * @see #clone
+ * @see #dup
  */
 VALUE
 Pixel_init_copy(VALUE self, VALUE orig)
@@ -700,24 +902,14 @@ Pixel_init_copy(VALUE self, VALUE orig)
 
 
 /**
- * Ruby usage:
- *   - @verbatim Pixel#initialize @endverbatim
- *   - @verbatim Pixel#initialize(red) @endverbatim
- *   - @verbatim Pixel#initialize(red,green) @endverbatim
- *   - @verbatim Pixel#initialize(red,green,blue) @endverbatim
- *   - @verbatim Pixel#initialize(red,green,blue,opacity) @endverbatim
- *
- * Notes:
- *   - Default red is 0.0
- *   - Default green is 0.0
- *   - Default blue is 0.0
- *   - Default opacity is 0.0
- *   - For backward compatibility, arguments may be nil.
- *
- * @param argc number of input arguments
- * @param argv array of input arguments
- * @param self this object
- * @return self
+ * Initialize Pixel object.
+ *
+ * @overload initialize(red = 0, green = 0, blue = 0, opacity = 0)
+ *   @param red [Numeric] The red value
+ *   @param green [Numeric] The green value
+ *   @param blue [Numeric] The blue value
+ *   @param opacity [Numeric] The opacity value
+ *   @return [Magick::Pixel] self
  */
 VALUE
 Pixel_initialize(int argc, VALUE *argv, VALUE self)
@@ -726,13 +918,24 @@ Pixel_initialize(int argc, VALUE *argv, VALUE self)
 
     Data_Get_Struct(self, Pixel, pixel);
 
+#if defined(IMAGEMAGICK_7)
+    pixel->alpha = OpaqueAlpha;
+#endif
+
     switch(argc)
     {
         case 4:
+#if defined(IMAGEMAGICK_7)
+            if (argv[3] != Qnil)
+            {
+                pixel->alpha = APP2QUANTUM(argv[3]);
+            }
+#else
             if (argv[3] != Qnil)
             {
                 pixel->opacity = APP2QUANTUM(argv[3]);
             }
+#endif
         case 3:
             if (argv[2] != Qnil)
             {
@@ -761,11 +964,7 @@ Pixel_initialize(int argc, VALUE *argv, VALUE self)
 /**
  * Return the "intensity" of a pixel.
  *
- * Ruby usage:
- *   - @verbatim Pixel#intensity @endverbatim
- *
- * @param self this object
- * @return the intensity
+ * @return [Numeric] the intensity
  */
 VALUE
 Pixel_intensity(VALUE self)
@@ -786,24 +985,27 @@ Pixel_intensity(VALUE self)
 /**
  * Support Marshal.dump.
  *
- * Ruby usage:
- *   - @verbatim Pixel#marshal_dump @endverbatim
- *
- * @param self this object
- * @return a string representing the dumped pixel
+ * @return [Hash] a representing the dumped pixel
  */
 VALUE
 Pixel_marshal_dump(VALUE self)
 {
     Pixel *pixel;
-    volatile VALUE dpixel;
+    VALUE dpixel;
 
     Data_Get_Struct(self, Pixel, pixel);
     dpixel = rb_hash_new();
     rb_hash_aset(dpixel, CSTR2SYM("red"), QUANTUM2NUM(pixel->red));
     rb_hash_aset(dpixel, CSTR2SYM("green"), QUANTUM2NUM(pixel->green));
     rb_hash_aset(dpixel, CSTR2SYM("blue"), QUANTUM2NUM(pixel->blue));
+#if defined(IMAGEMAGICK_7)
+    rb_hash_aset(dpixel, CSTR2SYM("alpha"), QUANTUM2NUM(pixel->alpha));
+#else
     rb_hash_aset(dpixel, CSTR2SYM("opacity"), QUANTUM2NUM(pixel->opacity));
+#endif
+
+    RB_GC_GUARD(dpixel);
+
     return dpixel;
 }
 
@@ -811,11 +1013,7 @@ Pixel_marshal_dump(VALUE self)
 /**
  * Support Marshal.load.
  *
- * Ruby usage:
- *   - @verbatim Pixel#marshal_load @endverbatim
- *
- * @param self this object
- * @param dpixel the dumped pixel
+ * @param dpixel [Hash] the dumped pixel
  * @return self
  */
 VALUE
@@ -827,7 +1025,11 @@ Pixel_marshal_load(VALUE self, VALUE dpixel)
     pixel->red = NUM2QUANTUM(rb_hash_aref(dpixel, CSTR2SYM("red")));
     pixel->green = NUM2QUANTUM(rb_hash_aref(dpixel, CSTR2SYM("green")));
     pixel->blue = NUM2QUANTUM(rb_hash_aref(dpixel, CSTR2SYM("blue")));
+#if defined(IMAGEMAGICK_7)
+    pixel->alpha = NUM2QUANTUM(rb_hash_aref(dpixel, CSTR2SYM("alpha")));
+#else
     pixel->opacity = NUM2QUANTUM(rb_hash_aref(dpixel, CSTR2SYM("opacity")));
+#endif
     return self;
 }
 
@@ -835,12 +1037,8 @@ Pixel_marshal_load(VALUE self, VALUE dpixel)
 /**
  * Support Comparable mixin.
  *
- * Ruby usage:
- *   - @verbatim Pixel#<=> @endverbatim
- *
- * @param self this object
- * @param other the other Pixel
- * @return -1, 0, 1
+ * @param other [Object] the other Pixel
+ * @return [-1, 0, 1, nil] the result of compare
  */
 VALUE
 Pixel_spaceship(VALUE self, VALUE other)
@@ -852,20 +1050,27 @@ Pixel_spaceship(VALUE self, VALUE other)
 
     if (this->red != that->red)
     {
-        return INT2NUM((this->red - that->red)/abs(this->red - that->red));
+        return INT2NUM((this->red - that->red)/abs((int)(this->red - that->red)));
     }
     else if(this->green != that->green)
     {
-        return INT2NUM((this->green - that->green)/abs(this->green - that->green));
+        return INT2NUM((this->green - that->green)/abs((int)(this->green - that->green)));
     }
     else if(this->blue != that->blue)
     {
-        return INT2NUM((this->blue - that->blue)/abs(this->blue - that->blue));
+        return INT2NUM((this->blue - that->blue)/abs((int)(this->blue - that->blue)));
     }
+#if defined(IMAGEMAGICK_7)
+    else if(this->alpha != that->alpha)
+    {
+        return INT2NUM((this->alpha - that->alpha)/abs((int)(this->alpha - that->alpha)));
+    }
+#else
     else if(this->opacity != that->opacity)
     {
-        return INT2NUM((this->opacity - that->opacity)/abs(this->opacity - that->opacity));
+        return INT2NUM(((QuantumRange - this->opacity) - (QuantumRange - that->opacity))/abs((int)((QuantumRange - this->opacity) - (QuantumRange - that->opacity))));
     }
+#endif
 
     // Values are equal, check class.
 
@@ -875,26 +1080,18 @@ Pixel_spaceship(VALUE self, VALUE other)
 
 
 /**
- * Return [hue, saturation, lightness, alpha] in the same ranges as
- * Pixel_from_hsla.
- * 
- *
- * Ruby usage:
- *   - @verbatim Pixel#to_hsla @endverbatim
+ * Return [+hue+, +saturation+, +lightness+, +alpha+] in the same ranges as
+ * {Magick::Pixel.from_hsla}.
  *
- * Notes:
- *   - Replace brain-dead Pixel_to_HSL.
- *
- * @param self this object
- * @return an array with hsla data
- * @see Pixel_from_hsla
+ * @return [Array<Float>] an array with hsla data
+ * @see Pixel.from_hsla
  */
 VALUE
 Pixel_to_hsla(VALUE self)
 {
     double hue, sat, lum, alpha;
     Pixel *pixel;
-    volatile VALUE hsla;
+    VALUE hsla;
 
     Data_Get_Struct(self, Pixel, pixel);
 
@@ -903,6 +1100,20 @@ Pixel_to_hsla(VALUE self)
     sat *= 255.0;
     lum *= 255.0;
 
+#if defined(IMAGEMAGICK_7)
+    if (pixel->alpha == OpaqueAlpha)
+    {
+        alpha = 1.0;
+    }
+    else if (pixel->alpha == TransparentAlpha)
+    {
+        alpha = 0.0;
+    }
+    else
+    {
+        alpha = (double)(pixel->alpha) / (double)QuantumRange;
+    }
+#else
     if (pixel->opacity == OpaqueOpacity)
     {
         alpha = 1.0;
@@ -913,63 +1124,53 @@ Pixel_to_hsla(VALUE self)
     }
     else
     {
-        alpha = ROUND_TO_QUANTUM(QuantumRange - (pixel->opacity / QuantumRange));
+        alpha = (double)(QuantumRange - pixel->opacity) / (double)QuantumRange;
     }
+#endif
 
     hsla = rb_ary_new3(4, rb_float_new(hue), rb_float_new(sat), rb_float_new(lum), rb_float_new(alpha));
+
+    RB_GC_GUARD(hsla);
+
     return hsla;
 }
 
+
 /**
- * Convert an RGB pixel to the array [hue, saturation, luminosity].
+ * Convert a Pixel to a MagickPixel.
  *
- * Ruby usage:
- *   - @verbatim Pixel#to_HSL @endverbatim
+ * No Ruby usage (internal function)
  *
- * @param self this object
- * @return an array with hsl data
- * @deprecated This method has been deprecated. Please use Pixel_to_hsla.
+ * Notes:
+ *   - Same code as the private function SetMagickPixelPacket in ImageMagick.
+ *
+ * @param pixel the pixel
+ * @param pp the MagickPixel to be modified
  */
-VALUE
-Pixel_to_HSL(VALUE self)
+static void
+rm_set_magick_pixel_packet(Pixel *pixel, MagickPixel *pp)
 {
-    Pixel *pixel;
-    double hue, saturation, luminosity;
-    volatile VALUE hsl;
-
-    Data_Get_Struct(self, Pixel, pixel);
-
-    rb_warning("Pixel#to_HSL is deprecated; use to_hsla");
-    ConvertRGBToHSL(pixel->red, pixel->green, pixel->blue, &hue, &saturation, &luminosity);
-
-    hsl = rb_ary_new3(3, rb_float_new(hue), rb_float_new(saturation),
-                      rb_float_new(luminosity));
-
-    return hsl;
+    pp->red     = (MagickRealType) pixel->red;
+    pp->green   = (MagickRealType) pixel->green;
+    pp->blue    = (MagickRealType) pixel->blue;
+#if defined(IMAGEMAGICK_7)
+    pp->alpha   = (MagickRealType) pixel->alpha;
+#else
+    pp->opacity = (MagickRealType) pixel->opacity;
+#endif
+    pp->index   = (MagickRealType) 0.0;
 }
 
 
 /**
  * Return the color name corresponding to the pixel values.
  *
- * Ruby usage:
- *   - @verbatim Magick::Pixel#to_color @endverbatim
- *   - @verbatim Magick::Pixel#to_color(compliance) @endverbatim
- *   - @verbatim Magick::Pixel#to_color(compliance, matte) @endverbatim
- *   - @verbatim Magick::Pixel#to_color(compliance, matte, depth) @endverbatim
- *   - @verbatim Magick::Pixel#to_color(compliance, matte, depth, hex) @endverbatim
- *
- * Notes:
- *   - Default compliance is AllCompliance
- *   - Default matte is false
- *   - Default depth is QuantumDepth
- *   - Default hex is false
- *   - The conversion respects the value of the 'opacity' field in the Pixel
- *
- * @param argc number of input arguments
- * @param argv array of input arguments
- * @param self this object
- * @return the color name as a String
+ * @overload to_color(compliance = Magick::AllCompliance, alpha = false, depth = Magick::MAGICKCORE_QUANTUM_DEPTH, hex = false)
+ *   @param compliance [Magick::ComplianceType] A ComplianceType constant
+ *   @param alpha [Boolean] If false, the pixel's alpha attribute is ignored
+ *   @param depth [Numeric] An image depth
+ *   @param hex [Boolean] If true, represent the color name in hex format
+ *   @return [String] the color name as a String
  */
 VALUE
 Pixel_to_color(int argc, VALUE *argv, VALUE self)
@@ -977,13 +1178,13 @@ Pixel_to_color(int argc, VALUE *argv, VALUE self)
     Info *info;
     Image *image;
     Pixel *pixel;
-    MagickPixelPacket mpp;
+    MagickPixel mpp;
     MagickBooleanType hex = MagickFalse;
     char name[MaxTextExtent];
-    ExceptionInfo exception;
+    ExceptionInfo *exception;
     ComplianceType compliance = AllCompliance;
-    unsigned int matte = MagickFalse;
-    unsigned int depth = QuantumDepth;
+    unsigned int alpha = MagickFalse;
+    unsigned int depth = MAGICKCORE_QUANTUM_DEPTH;
 
     switch (argc)
     {
@@ -996,10 +1197,10 @@ Pixel_to_color(int argc, VALUE *argv, VALUE self)
             switch (depth)
             {
                 case 8:
-#if QuantumDepth == 16 || QuantumDepth == 32
+#if MAGICKCORE_QUANTUM_DEPTH == 16 || MAGICKCORE_QUANTUM_DEPTH == 32
                 case 16:
 #endif
-#if QuantumDepth == 32
+#if MAGICKCORE_QUANTUM_DEPTH == 32
                 case 32:
 #endif
                     break;
@@ -1008,7 +1209,7 @@ Pixel_to_color(int argc, VALUE *argv, VALUE self)
                     break;
             }
        case 2:
-            matte = RTEST(argv[1]);
+            alpha = RTEST(argv[1]);
         case 1:
             VALUE_TO_ENUM(argv[0], compliance, ComplianceType);
         case 0:
@@ -1020,38 +1221,52 @@ Pixel_to_color(int argc, VALUE *argv, VALUE self)
     Data_Get_Struct(self, Pixel, pixel);
 
     info = CloneImageInfo(NULL);
-    image = AcquireImage(info);
+    image = rm_acquire_image(info);
+    DestroyImageInfo(info);
+
+    if (!image)
+    {
+        rb_raise(rb_eNoMemError, "not enough memory to continue.");
+    }
+
+    exception = AcquireExceptionInfo();
+
     image->depth = depth;
-    image->matte = matte;
-    (void) DestroyImageInfo(info);
+#if defined(IMAGEMAGICK_7)
+    if (alpha)
+    {
+        image->alpha_trait = BlendPixelTrait;
+    }
+#else
+    image->matte = alpha;
+#endif
 
-    GetMagickPixelPacket(image, &mpp);
+    rm_init_magickpixel(image, &mpp);
     rm_set_magick_pixel_packet(pixel, &mpp);
 
-    GetExceptionInfo(&exception);
-
-#if defined(HAVE_NEW_QUERYMAGICKCOLORNAME)
     // Support for hex-format color names moved out of QueryMagickColorname
     // in 6.4.1-9. The 'hex' argument was removed as well.
     if (hex)
     {
         if (compliance == XPMCompliance)
         {
+#if defined(IMAGEMAGICK_7)
+            mpp.alpha_trait = UndefinedPixelTrait;
+#else
             mpp.matte = MagickFalse;
+#endif
             mpp.depth = (unsigned long) min(1.0 * image->depth, 16.0);
         }
-        (void) GetColorTuple(&mpp, MagickTrue, name);
+        GetColorTuple(&mpp, MagickTrue, name);
     }
     else
     {
-        (void) QueryMagickColorname(image, &mpp, compliance, name, &exception);
+        QueryColorname(image, &mpp, compliance, name, exception);
     }
-#else
-    (void) QueryMagickColorname(image, &mpp, compliance, hex, name, &exception);
-#endif
-    (void) DestroyImage(image);
-    CHECK_EXCEPTION()
-    (void) DestroyExceptionInfo(&exception);
+
+    DestroyImage(image);
+    CHECK_EXCEPTION();
+    DestroyExceptionInfo(exception);
 
     // Always return a string, even if it's ""
     return rb_str_new2(name);
@@ -1059,13 +1274,9 @@ Pixel_to_color(int argc, VALUE *argv, VALUE self)
 
 
 /**
- * Create a string representation of a Magick::Pixel.
+ * Return a string representation of a {Magick::Pixel} object.
  *
- * Ruby usage:
- *   - @verbatim Magick::Pixel#to_s @endverbatim
- *
- * @param self this object
- * @return the string
+ * @return [String] the string
  */
 VALUE
 Pixel_to_s(VALUE self)
@@ -1074,30 +1285,13 @@ Pixel_to_s(VALUE self)
     char buff[100];
 
     Data_Get_Struct(self, Pixel, pixel);
-    sprintf(buff, "red=" QuantumFormat ", green=" QuantumFormat ", blue=" QuantumFormat ", opacity=" QuantumFormat
-          , pixel->red, pixel->green, pixel->blue, pixel->opacity);
+    snprintf(buff, sizeof(buff), "red=" QuantumFormat ", green=" QuantumFormat ", blue=" QuantumFormat ", alpha=" QuantumFormat,
+            pixel->red, pixel->green, pixel->blue,
+#if defined(IMAGEMAGICK_7)
+            pixel->alpha);
+#else
+            (QuantumRange - pixel->opacity));
+#endif
     return rb_str_new2(buff);
 }
 
-
-/**
- * Convert a PixelPacket to a MagickPixelPacket.
- *
- * No Ruby usage (internal function)
- *
- * Notes:
- *   - Same code as the private function SetMagickPixelPacket in ImageMagick.
- *
- * @param pixel the pixel
- * @param pp the MagickPixelPacket to be modified
- */
-void
-rm_set_magick_pixel_packet(Pixel *pixel, MagickPixelPacket *pp)
-{
-    pp->red     = (MagickRealType) pixel->red;
-    pp->green   = (MagickRealType) pixel->green;
-    pp->blue    = (MagickRealType) pixel->blue;
-    pp->opacity = (MagickRealType) pixel->opacity;
-    pp->index   = (MagickRealType) 0.0;
-}
-