rmagick 4.0.0 → 5.3.0

data/ext/RMagick/rmpixel.c

@@ -12,55 +12,22 @@
 
 #include "rmagick.h"
 
-
-/*
- *  Declare Pixel channel attribute writers
-*/
-//! Pixel channel attribute writer.
-#define DEF_PIXEL_CHANNEL_WRITER(_channel_) \
-extern VALUE \
-Pixel_##_channel_##_eq(VALUE self, VALUE v) \
-{ \
-    Pixel *pixel; \
- \
-    rb_check_frozen(self); \
-    Data_Get_Struct(self, Pixel, pixel); \
-    pixel->_channel_ = APP2QUANTUM(v); \
-    (void) rb_funcall(self, rm_ID_changed, 0); \
-    (void) rb_funcall(self, rm_ID_notify_observers, 1, self); \
-    return QUANTUM2NUM((pixel->_channel_)); \
-}
-
-
-/*
- *  Declare Pixel CMYK channel attribute accessors
-*/
-//! Pixel CMYK channel attribute accessor.
-#define DEF_PIXEL_CMYK_CHANNEL_ACCESSOR(_cmyk_channel_, _rgb_channel_) \
-extern VALUE \
-Pixel_##_cmyk_channel_##_eq(VALUE self, VALUE v) \
-{ \
-    Pixel *pixel; \
- \
-    rb_check_frozen(self); \
-    Data_Get_Struct(self, Pixel, pixel); \
-    pixel->_rgb_channel_ = APP2QUANTUM(v); \
-    (void) rb_funcall(self, rm_ID_changed, 0); \
-    (void) rb_funcall(self, rm_ID_notify_observers, 1, self); \
-    return QUANTUM2NUM(pixel->_rgb_channel_); \
-} \
- \
-extern VALUE \
-Pixel_##_cmyk_channel_(VALUE self) \
-{ \
-    Pixel *pixel; \
- \
-    Data_Get_Struct(self, Pixel, pixel); \
-    return INT2NUM(pixel->_rgb_channel_); \
-}
+#if defined(IMAGEMAGICK_6)
+    #define QueryColorname QueryMagickColorname
+#endif
 
 
+static VALUE color_arg_rescue(VALUE, VALUE ATTRIBUTE_UNUSED) ATTRIBUTE_NORETURN;
 static void Color_Name_to_PixelColor(PixelColor *, VALUE);
+static void Pixel_destroy(void *);
+static size_t Pixel_memsize(const void *);
+
+const rb_data_type_t rm_pixel_data_type = {
+    "Magick::Pixel",
+    { NULL, Pixel_destroy, Pixel_memsize, },
+    0, 0,
+    RUBY_TYPED_FROZEN_SHAREABLE,
+};
 
 
 /**
@@ -68,151 +35,334 @@ static void Color_Name_to_PixelColor(PixelColor *, VALUE);
  *
  * No Ruby usage (internal function)
  *
- * @param pixel the Pixel object to destroy
+ * @param ptr the Pixel object to destroy
  */
-void
-destroy_Pixel(Pixel *pixel)
+static void
+Pixel_destroy(void *ptr)
 {
+    Pixel *pixel = (Pixel *)ptr;
     xfree(pixel);
 }
 
 
 /**
- * Get Pixel red attribute.
+  * Get Pixel object size.
+  *
+  * No Ruby usage (internal function)
+  *
+  * @param ptr pointer to the Pixel object
+  */
+static size_t
+Pixel_memsize(const void *ptr)
+{
+    return sizeof(Pixel);
+}
+
+
+/**
+ * Get Pixel red value.
  *
- * Ruby usage:
- *   - @verbatim Pixel#red @endverbatim
+ * @return [Numeric] the red value
+ */
+VALUE
+Pixel_red(VALUE self)
+{
+    IMPLEMENT_TYPED_ATTR_READER(Pixel, red, int, &rm_pixel_data_type);
+}
+
+/**
+ * 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_TYPED_ATTR_READER(Pixel, green, int, &rm_pixel_data_type);
+}
 
 /**
- * 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_TYPED_ATTR_READER(Pixel, blue, int, &rm_pixel_data_type);
+}
+
+/**
+ * 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;
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, 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);
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, 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 alpha attribute.
+ * Set Pixel green value.
  *
- * Ruby usage:
- *   - @verbatim Pixel#alpha @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 alpha value
+ * @param v [Numeric] the green value
+ * @return [Numeric] the given green value
  */
 VALUE
-Pixel_alpha(VALUE self)
+Pixel_green_eq(VALUE self, VALUE v)
 {
     Pixel *pixel;
-    Data_Get_Struct(self, Pixel, pixel);
-    return C_int_to_R_int(QuantumRange - pixel->opacity);
+
+    rb_check_frozen(self);
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, 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);
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, 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);
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, 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;
+
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, 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
  */
-DEF_PIXEL_CHANNEL_WRITER(green)
+VALUE
+Pixel_cyan_eq(VALUE self, VALUE v)
+{
+    Pixel *pixel;
+
+    rb_check_frozen(self);
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, 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);
+}
 
 /**
- * Set Pixel blue attribute.
+ * Get Pixel magenta value.
  *
- * Ruby usage:
- *   - @verbatim Pixel#blue= @endverbatim
+ * @return [Numeric] the magenta value
+ */
+VALUE
+Pixel_magenta(VALUE self)
+{
+    Pixel *pixel;
+
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, pixel);
+    return INT2NUM(pixel->green);
+}
+
+/**
+ * Set Pixel magenta 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 blue value
- * @return self
+ * @param v [Numeric] the magenta value
+ * @return [Numeric] the given magenta value
  */
-DEF_PIXEL_CHANNEL_WRITER(blue)
+VALUE
+Pixel_magenta_eq(VALUE self, VALUE v)
+{
+    Pixel *pixel;
+
+    rb_check_frozen(self);
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, 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 alpha attribute.
+ * Get Pixel yellow value.
  *
- * Ruby usage:
- *   - @verbatim Pixel#alpha= @endverbatim
+ * @return [Numeric] the yellow value
+ */
+VALUE
+Pixel_yellow(VALUE self)
+{
+    Pixel *pixel;
+
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, pixel);
+    return INT2NUM(pixel->blue);
+}
+
+/**
+ * Set Pixel yellow 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 alpha value
- * @return self
+ * @param v [Numeric] the yellow value
+ * @return [Numeric] the given yellow value
  */
 VALUE
-Pixel_alpha_eq(VALUE self, VALUE v)
+Pixel_yellow_eq(VALUE self, VALUE v)
 {
     Pixel *pixel;
- 
+
     rb_check_frozen(self);
-    Data_Get_Struct(self, Pixel, pixel);
-    pixel->opacity = QuantumRange - APP2QUANTUM(v);
-    (void) rb_funcall(self, rm_ID_changed, 0);
-    (void) rb_funcall(self, rm_ID_notify_observers, 1, self);
-    return QUANTUM2NUM(QuantumRange - pixel->opacity);
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, 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/set Pixel CMYK attributes.
+/**
+ * Get Pixel black value.
+ *
+ * @return [Numeric] the 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(VALUE self)
+{
+    Pixel *pixel;
+
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, pixel);
+    return INT2NUM(pixel->black);
+}
+
+/**
+ * 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
+ */
+VALUE
+Pixel_black_eq(VALUE self, VALUE v)
+{
+    Pixel *pixel;
+
+    rb_check_frozen(self);
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, 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);
+}
 
 
 /**
@@ -226,11 +376,10 @@ 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;
 }
 
 
@@ -251,11 +400,16 @@ Color_to_PixelColor(PixelColor *pp, VALUE color)
     if (CLASS_OF(color) == Class_Pixel)
     {
         memset(pp, 0, sizeof(*pp));
-        Data_Get_Struct(color, Pixel, pixel);
+        TypedData_Get_Struct(color, Pixel, &rm_pixel_data_type, pixel);
         pp->red     = pixel->red;
         pp->green   = pixel->green;
         pp->blue    = pixel->blue;
+#if defined(IMAGEMAGICK_7)
+        pp->black   = pixel->black;
+        rm_set_pixelinfo_alpha(pp, pixel->alpha);
+#else
         pp->opacity = pixel->opacity;
+#endif
     }
     else
     {
@@ -266,6 +420,44 @@ Color_to_PixelColor(PixelColor *pp, VALUE color)
 }
 
 
+/**
+ * Convert either a String color name or a {Magick::Pixel} to a Pixel.
+ *
+ * No Ruby usage (internal function)
+ *
+ * @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;
+
+        TypedData_Get_Struct(color, Pixel, &rm_pixel_data_type, 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
  *
@@ -283,9 +475,9 @@ Color_Name_to_PixelColor(PixelColor *color, VALUE name_arg)
     ExceptionInfo *exception;
 
     exception = AcquireExceptionInfo();
-    name = StringValuePtr(name_arg);
+    name = StringValueCStr(name_arg);
     okay = QueryColorCompliance(name, AllCompliance, color, exception);
-    (void) DestroyExceptionInfo(exception);
+    DestroyExceptionInfo(exception);
     if (!okay)
     {
         rb_raise(rb_eArgError, "invalid color name %s", name);
@@ -297,10 +489,7 @@ Color_Name_to_PixelColor(PixelColor *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)
@@ -309,34 +498,34 @@ Pixel_alloc(VALUE class)
 
     pixel = ALLOC(Pixel);
     memset(pixel, '\0', sizeof(Pixel));
-    return Data_Wrap_Struct(class, NULL, destroy_Pixel, pixel);
+    return TypedData_Wrap_Struct(class, &rm_pixel_data_type, pixel);
 }
 
 
 /**
  * "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))
     {
-        Data_Get_Struct(self, Pixel, this);
-        Data_Get_Struct(other, Pixel, that);
+        Pixel *this, *that;
+
+        TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, this);
+        TypedData_Get_Struct(other, Pixel, &rm_pixel_data_type, 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;
@@ -346,13 +535,9 @@ 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)
@@ -374,13 +559,9 @@ 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)
@@ -390,12 +571,7 @@ Pixel_dup(VALUE self)
 
     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);
-    }
-
+    dup = TypedData_Wrap_Struct(CLASS_OF(self), &rm_pixel_data_type, pixel);
     RB_GC_GUARD(dup);
 
     return rb_funcall(dup, rm_ID_initialize_copy, 1, self);
@@ -403,14 +579,10 @@ Pixel_dup(VALUE self)
 
 
 /**
- * For use with Hash.
+ * Equality. Returns true only if receiver and other are the same object.
  *
- * Ruby usage:
- *   - @verbatim Pixel#eql? @endverbatim
- *
- * @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)
@@ -422,17 +594,11 @@ 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)
@@ -440,9 +606,11 @@ Pixel_fcmp(int argc, VALUE *argv, VALUE self)
     double fuzz = 0.0;
     unsigned int equal;
     ColorspaceType colorspace = RGBColorspace;
+    PixelColor this, that;
+#if defined(IMAGEMAGICK_6)
     Image *image;
     Info *info;
-    Pixel *this, *that;
+#endif
 
     switch (argc)
     {
@@ -458,9 +626,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.
 
@@ -473,7 +648,7 @@ Pixel_fcmp(int argc, VALUE *argv, VALUE self)
     image = rm_acquire_image(info);
 
     // Delete Info now in case we have to raise an exception
-    (void) DestroyImageInfo(info);
+    DestroyImageInfo(info);
 
     if (!image)
     {
@@ -483,29 +658,25 @@ 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 ATTRIBUTE_UNUSED, VALUE name)
@@ -515,13 +686,13 @@ Pixel_from_color(VALUE class ATTRIBUTE_UNUSED, VALUE name)
     MagickBooleanType okay;
 
     exception = AcquireExceptionInfo();
-    okay = QueryColorCompliance(StringValuePtr(name), AllCompliance, &pp, exception);
-    CHECK_EXCEPTION()
-    (void) DestroyExceptionInfo(exception);
+    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_PixelColor(&pp);
@@ -531,21 +702,17 @@ Pixel_from_color(VALUE class ATTRIBUTE_UNUSED, VALUE name)
 /**
  * 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%"
- *
- * @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 ATTRIBUTE_UNUSED)
@@ -559,14 +726,14 @@ Pixel_from_hsla(int argc, VALUE *argv, VALUE class ATTRIBUTE_UNUSED)
     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);
@@ -593,19 +760,23 @@ Pixel_from_hsla(int argc, VALUE *argv, VALUE class ATTRIBUTE_UNUSED)
     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);
     }
 
     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_MagickPixel(&pp);
 }
@@ -628,12 +799,17 @@ Pixel_from_MagickPixel(const MagickPixel *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;
+#else
+    pixel->opacity = pp->opacity;
+#endif
+    pixel->black   = pp->index;
 
-    return Data_Wrap_Struct(Class_Pixel, NULL, destroy_Pixel, pixel);
+    return TypedData_Wrap_Struct(Class_Pixel, &rm_pixel_data_type, pixel);
 }
 
 
@@ -657,9 +833,15 @@ Pixel_from_PixelPacket(const PixelPacket *pp)
     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);
+    return TypedData_Wrap_Struct(Class_Pixel, &rm_pixel_data_type, pixel);
 }
 
 
@@ -683,22 +865,22 @@ Pixel_from_PixelColor(const PixelColor *pp)
     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);
+    return TypedData_Wrap_Struct(Class_Pixel, &rm_pixel_data_type, 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)
@@ -706,12 +888,16 @@ Pixel_hash(VALUE self)
     Pixel *pixel;
     unsigned int hash;
 
-    Data_Get_Struct(self, Pixel, pixel);
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, pixel);
 
     hash  = ScaleQuantumToChar(pixel->red)   << 24;
     hash += ScaleQuantumToChar(pixel->green) << 16;
     hash += ScaleQuantumToChar(pixel->blue)  << 8;
+#if defined(IMAGEMAGICK_7)
+    hash += ScaleQuantumToChar(pixel->alpha);
+#else
     hash += ScaleQuantumToChar(QuantumRange - pixel->opacity);
+#endif
 
     return UINT2NUM(hash >> 1);
 }
@@ -720,22 +906,18 @@ Pixel_hash(VALUE self)
 /**
  * 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)
 {
     Pixel *copy, *original;
 
-    Data_Get_Struct(orig, Pixel, original);
-    Data_Get_Struct(self, Pixel, copy);
+    TypedData_Get_Struct(orig, Pixel, &rm_pixel_data_type, original);
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, copy);
 
     *copy = *original;
 
@@ -744,39 +926,40 @@ 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)
 {
     Pixel *pixel;
 
-    Data_Get_Struct(self, Pixel, pixel);
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, 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)
             {
@@ -805,11 +988,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)
@@ -817,7 +996,7 @@ Pixel_intensity(VALUE self)
     Pixel *pixel;
     Quantum intensity;
 
-    Data_Get_Struct(self, Pixel, pixel);
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, pixel);
 
     intensity = ROUND_TO_QUANTUM((0.299*pixel->red)
                                 + (0.587*pixel->green)
@@ -830,11 +1009,7 @@ 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)
@@ -842,12 +1017,16 @@ Pixel_marshal_dump(VALUE self)
     Pixel *pixel;
     VALUE dpixel;
 
-    Data_Get_Struct(self, Pixel, pixel);
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, 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);
 
@@ -858,11 +1037,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
@@ -870,11 +1045,15 @@ Pixel_marshal_load(VALUE self, VALUE dpixel)
 {
     Pixel *pixel;
 
-    Data_Get_Struct(self, Pixel, pixel);
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, pixel);
     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;
 }
 
@@ -882,37 +1061,40 @@ 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)
 {
     Pixel *this, *that;
 
-    Data_Get_Struct(self, Pixel, this);
-    Data_Get_Struct(other, Pixel, that);
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, this);
+    TypedData_Get_Struct(other, Pixel, &rm_pixel_data_type, that);
 
     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(((QuantumRange - this->opacity) - (QuantumRange - that->opacity))/abs((QuantumRange - this->opacity) - (QuantumRange - that->opacity)));
+        return INT2NUM(((QuantumRange - this->opacity) - (QuantumRange - that->opacity))/abs((int)((QuantumRange - this->opacity) - (QuantumRange - that->opacity))));
     }
+#endif
 
     // Values are equal, check class.
 
@@ -922,16 +1104,11 @@ Pixel_spaceship(VALUE self, VALUE other)
 
 
 /**
- * Return [hue, saturation, lightness, alpha] in the same ranges as
- * Pixel_from_hsla.
- *
+ * Return [+hue+, +saturation+, +lightness+, +alpha+] in the same ranges as
+ * {Magick::Pixel.from_hsla}.
  *
- * Ruby usage:
- *   - @verbatim Pixel#to_hsla @endverbatim
- *
- * @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)
@@ -940,13 +1117,27 @@ Pixel_to_hsla(VALUE self)
     Pixel *pixel;
     VALUE hsla;
 
-    Data_Get_Struct(self, Pixel, pixel);
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, pixel);
 
     ConvertRGBToHSL(pixel->red, pixel->green, pixel->blue, &hue, &sat, &lum);
     hue *= 360.0;
     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;
@@ -959,6 +1150,7 @@ Pixel_to_hsla(VALUE self)
     {
         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));
 
@@ -985,7 +1177,11 @@ rm_set_magick_pixel_packet(Pixel *pixel, MagickPixel *pp)
     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;
 }
 
@@ -993,24 +1189,12 @@ rm_set_magick_pixel_packet(Pixel *pixel, MagickPixel *pp)
 /**
  * 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 MAGICKCORE_QUANTUM_DEPTH
- *   - 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)
@@ -1023,7 +1207,7 @@ Pixel_to_color(int argc, VALUE *argv, VALUE self)
     char name[MaxTextExtent];
     ExceptionInfo *exception;
     ComplianceType compliance = AllCompliance;
-    unsigned int matte = MagickFalse;
+    unsigned int alpha = MagickFalse;
     unsigned int depth = MAGICKCORE_QUANTUM_DEPTH;
 
     switch (argc)
@@ -1049,7 +1233,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:
@@ -1058,44 +1242,55 @@ Pixel_to_color(int argc, VALUE *argv, VALUE self)
             rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 to 2)", argc);
     }
 
-    Data_Get_Struct(self, Pixel, pixel);
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, pixel);
 
     info = CloneImageInfo(NULL);
     image = rm_acquire_image(info);
-    (void) DestroyImageInfo(info);
+    DestroyImageInfo(info);
 
     if (!image)
     {
         rb_raise(rb_eNoMemError, "not enough memory to continue.");
     }
 
+    exception = AcquireExceptionInfo();
+
     image->depth = depth;
-    image->matte = matte;
+#if defined(IMAGEMAGICK_7)
+    if (alpha)
+    {
+        image->alpha_trait = BlendPixelTrait;
+    }
+#else
+    image->matte = alpha;
+#endif
 
     rm_init_magickpixel(image, &mpp);
     rm_set_magick_pixel_packet(pixel, &mpp);
 
-    exception = AcquireExceptionInfo();
-
     // 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);
     }
 
-    (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);
@@ -1103,13 +1298,9 @@ Pixel_to_color(int argc, VALUE *argv, VALUE self)
 
 
 /**
- * Create a string representation of a Magick::Pixel.
- *
- * Ruby usage:
- *   - @verbatim Magick::Pixel#to_s @endverbatim
+ * Return a string representation of a {Magick::Pixel} object.
  *
- * @param self this object
- * @return the string
+ * @return [String] the string
  */
 VALUE
 Pixel_to_s(VALUE self)
@@ -1117,10 +1308,14 @@ Pixel_to_s(VALUE self)
     Pixel *pixel;
     char buff[100];
 
-    Data_Get_Struct(self, Pixel, pixel);
-    sprintf(buff, "red=" QuantumFormat ", green=" QuantumFormat ", blue=" QuantumFormat ", alpha=" QuantumFormat,
+    TypedData_Get_Struct(self, Pixel, &rm_pixel_data_type, pixel);
+    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);
 }