rmagick 2.13.2 → 4.2.2

data/ext/RMagick/rmfill.c

@@ -19,8 +19,8 @@ typedef struct
     double y1; /**< y position of first point */
     double x2; /**< x position of second point */
     double y2; /**< y position of second point */
-    PixelPacket start_color; /**< the start color */
-    PixelPacket stop_color; /**< the stop color */
+    PixelColor start_color; /**< the start color */
+    PixelColor stop_color; /**< the stop color */
 } rm_GradientFill;
 
 /** Data associated with a TextureFill */
@@ -44,10 +44,7 @@ static void free_Fill(void *fill)
 /**
  * Create new GradientFill object.
  *
- * No Ruby usage (internal function)
- *
- * @param class the Ruby class to use
- * @return a new GradientFill object
+ * @return [Magick::GradientFill] a new GradientFill object
  */
 VALUE
 GradientFill_alloc(VALUE class)
@@ -59,19 +56,15 @@ GradientFill_alloc(VALUE class)
 
 
 /**
- * Store the vector points and the start and stop colors.
- *
- * Ruby usage:
- *   - @verbatim GradientFill#initialize(x1,y1,x2,y2,start_color,stop_color) @endverbatim
- *
- * @param self this object
- * @param x1 x position of first point
- * @param y1 y position of first point
- * @param x2 x position of second point
- * @param y2 y position of second point
- * @param start_color the start color
- * @param stop_color the stop color
- * @return self
+ * Initialize GradientFill object.
+ *
+ * @param x1 [Float] x position of first point
+ * @param y1 [Float] y position of first point
+ * @param x2 [Float] x position of second point
+ * @param y2 [Float] y position of second point
+ * @param start_color [Magick::Pixel, String] the start color
+ * @param stop_color [Magick::Pixel, String] the stop color
+ * @return [Magick::GradientFill] self
  */
 VALUE
 GradientFill_initialize(
@@ -91,8 +84,8 @@ GradientFill_initialize(
     fill->y1 = NUM2DBL(y1);
     fill->x2 = NUM2DBL(x2);
     fill->y2 = NUM2DBL(y2);
-    Color_to_PixelPacket(&fill->start_color, start_color);
-    Color_to_PixelPacket(&fill->stop_color, stop_color);
+    Color_to_PixelColor(&fill->start_color, start_color);
+    Color_to_PixelColor(&fill->stop_color, stop_color);
 
     return self;
 }
@@ -113,17 +106,15 @@ point_fill(
           Image *image,
           double x0,
           double y0,
-          PixelPacket *start_color,
-          PixelPacket *stop_color)
+          PixelColor *start_color,
+          PixelColor *stop_color)
 {
     double steps, distance;
-    unsigned long x, y;
+    ssize_t x, y;
     MagickRealType red_step, green_step, blue_step;
-#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
-    ExceptionInfo exception;
+    ExceptionInfo *exception;
 
-    GetExceptionInfo(&exception);
-#endif
+    exception = AcquireExceptionInfo();
 
     steps = sqrt((double)((image->columns-x0)*(image->columns-x0)
                           + (image->rows-y0)*(image->rows-y0)));
@@ -132,38 +123,41 @@ point_fill(
     green_step = ((MagickRealType)stop_color->green - (MagickRealType)start_color->green) / steps;
     blue_step  = ((MagickRealType)stop_color->blue  - (MagickRealType)start_color->blue)  / steps;
 
-    for (y = 0; y < image->rows; y++)
+    for (y = 0; y < (ssize_t) image->rows; y++)
     {
-        PixelPacket *row_pixels;
-
-#if defined(HAVE_QUEUEAUTHENTICPIXELS)
-        row_pixels = QueueAuthenticPixels(image, 0, (long int)y, image->columns, 1, &exception);
-        CHECK_EXCEPTION()
+#if defined(IMAGEMAGICK_7)
+        Quantum *row_pixels;
 #else
-        row_pixels = SetImagePixels(image, 0, (long int)y, image->columns, 1);
-        rm_check_image_exception(image, RetainOnError);
+        PixelPacket *row_pixels;
 #endif
-        for (x = 0; x < image->columns; x++)
+
+        row_pixels = QueueAuthenticPixels(image, 0, y, image->columns, 1, exception);
+        CHECK_EXCEPTION();
+
+        for (x = 0; x < (ssize_t) image->columns; x++)
         {
             distance = sqrt((double)((x-x0)*(x-x0)+(y-y0)*(y-y0)));
+
+#if defined(IMAGEMAGICK_7)
+            SetPixelRed(image,   ROUND_TO_QUANTUM(start_color->red   + (distance * red_step)), row_pixels);
+            SetPixelGreen(image, ROUND_TO_QUANTUM(start_color->green + (distance * green_step)), row_pixels);
+            SetPixelBlue(image,  ROUND_TO_QUANTUM(start_color->blue  + (distance * blue_step)), row_pixels);
+            SetPixelAlpha(image, OpaqueAlpha, row_pixels);
+
+            row_pixels += GetPixelChannels(image);
+#else
             row_pixels[x].red     = ROUND_TO_QUANTUM(start_color->red   + (distance * red_step));
             row_pixels[x].green   = ROUND_TO_QUANTUM(start_color->green + (distance * green_step));
             row_pixels[x].blue    = ROUND_TO_QUANTUM(start_color->blue  + (distance * blue_step));
             row_pixels[x].opacity = OpaqueOpacity;
+#endif
         }
 
-#if defined(HAVE_SYNCAUTHENTICPIXELS)
-        SyncAuthenticPixels(image, &exception);
-        CHECK_EXCEPTION()
-#else
-        SyncImagePixels(image);
-        rm_check_image_exception(image, RetainOnError);
-#endif
+        SyncAuthenticPixels(image, exception);
+        CHECK_EXCEPTION();
     }
 
-#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
-    DestroyExceptionInfo(&exception);
-#endif
+    DestroyExceptionInfo(exception);
 }
 
 /**
@@ -181,19 +175,19 @@ static void
 vertical_fill(
              Image *image,
              double x1,
-             PixelPacket *start_color,
-             PixelPacket *stop_color)
+             PixelColor *start_color,
+             PixelColor *stop_color)
 {
     double steps;
-    unsigned long x, y;
-    PixelPacket *master;
+    ssize_t x, y;
     MagickRealType red_step, green_step, blue_step;
-#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
-    ExceptionInfo exception;
-
-    GetExceptionInfo(&exception);
+    ExceptionInfo *exception;
+#if defined(IMAGEMAGICK_6)
+    PixelPacket *master;
 #endif
 
+    exception = AcquireExceptionInfo();
+
     steps = FMAX(x1, ((long)image->columns)-x1);
 
     // If x is to the left of the x-axis, add that many steps so that
@@ -208,11 +202,37 @@ vertical_fill(
     green_step = ((MagickRealType)stop_color->green - (MagickRealType)start_color->green) / steps;
     blue_step  = ((MagickRealType)stop_color->blue  - (MagickRealType)start_color->blue)  / steps;
 
+
+#if defined(IMAGEMAGICK_7)
+    for (y = 0; y < (ssize_t) image->rows; y++)
+    {
+        Quantum *row_pixels;
+
+        row_pixels = QueueAuthenticPixels(image, 0, y, image->columns, 1, exception);
+        CHECK_EXCEPTION();
+
+        for (x = 0; x < (ssize_t) image->columns; x++)
+        {
+            double distance = fabs(x1 - x);
+            SetPixelRed(image,   ROUND_TO_QUANTUM(start_color->red   + (distance * red_step)), row_pixels);
+            SetPixelGreen(image, ROUND_TO_QUANTUM(start_color->green + (distance * green_step)), row_pixels);
+            SetPixelBlue(image,  ROUND_TO_QUANTUM(start_color->blue  + (distance * blue_step)), row_pixels);
+            SetPixelAlpha(image, OpaqueAlpha, row_pixels);
+
+            row_pixels += GetPixelChannels(image);
+        }
+
+        SyncAuthenticPixels(image, exception);
+        CHECK_EXCEPTION();
+    }
+
+    DestroyExceptionInfo(exception);
+#else
     // All the rows are the same. Make a "master row" and simply copy
     // it to each actual row.
     master = ALLOC_N(PixelPacket, image->columns);
 
-    for (x = 0; x < image->columns; x++)
+    for (x = 0; x < (ssize_t) image->columns; x++)
     {
         double distance   = fabs(x1 - x);
         master[x].red     = ROUND_TO_QUANTUM(start_color->red   + (red_step * distance));
@@ -222,34 +242,31 @@ vertical_fill(
     }
 
     // Now copy the master row to each actual row.
-    for (y = 0; y < image->rows; y++)
+    for (y = 0; y < (ssize_t) image->rows; y++)
     {
         PixelPacket *row_pixels;
 
-#if defined(HAVE_QUEUEAUTHENTICPIXELS)
-        row_pixels = QueueAuthenticPixels(image, 0, (long int)y, image->columns, 1, &exception);
-        CHECK_EXCEPTION()
-#else
-        row_pixels = SetImagePixels(image, 0, (long int)y, image->columns, 1);
-        rm_check_image_exception(image, RetainOnError);
-#endif
+        row_pixels = QueueAuthenticPixels(image, 0, y, image->columns, 1, exception);
+        if (rm_should_raise_exception(exception, RetainExceptionRetention))
+        {
+            xfree((void *)master);
+            rm_raise_exception(exception);
+        }
 
         memcpy(row_pixels, master, image->columns * sizeof(PixelPacket));
 
-#if defined(HAVE_SYNCAUTHENTICPIXELS)
-        SyncAuthenticPixels(image, &exception);
-        CHECK_EXCEPTION()
-#else
-        SyncImagePixels(image);
-        rm_check_image_exception(image, RetainOnError);
-#endif
+        SyncAuthenticPixels(image, exception);
+        if (rm_should_raise_exception(exception, RetainExceptionRetention))
+        {
+            xfree((void *)master);
+            rm_raise_exception(exception);
+        }
     }
 
-#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
-    DestroyExceptionInfo(&exception);
-#endif
+    DestroyExceptionInfo(exception);
 
-    xfree((void *)master);
+    xfree((void *) master);
+#endif
 }
 
 /**
@@ -266,19 +283,19 @@ static void
 horizontal_fill(
                Image *image,
                double y1,
-               PixelPacket *start_color,
-               PixelPacket *stop_color)
+               PixelColor *start_color,
+               PixelColor *stop_color)
 {
     double steps;
-    unsigned long x, y;
-    PixelPacket *master;
+    ssize_t x, y;
     MagickRealType red_step, green_step, blue_step;
-#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
-    ExceptionInfo exception;
-
-    GetExceptionInfo(&exception);
+    ExceptionInfo *exception;
+#if defined(IMAGEMAGICK_6)
+    PixelPacket *master;
 #endif
 
+    exception = AcquireExceptionInfo();
+
     steps = FMAX(y1, ((long)image->rows)-y1);
 
     // If the line is below the y-axis, add that many steps so the color
@@ -292,11 +309,36 @@ horizontal_fill(
     green_step = ((MagickRealType)stop_color->green - (MagickRealType)start_color->green) / steps;
     blue_step  = ((MagickRealType)stop_color->blue  - (MagickRealType)start_color->blue)  / steps;
 
+#if defined(IMAGEMAGICK_7)
+    for (y = 0; y < (ssize_t) image->rows; y++)
+    {
+        Quantum *row_pixels;
+
+        row_pixels = QueueAuthenticPixels(image, 0, y, image->columns, 1, exception);
+        CHECK_EXCEPTION();
+
+        double distance = fabs(y1 - y);
+        for (x = 0; x < (ssize_t) image->columns; x++)
+        {
+            SetPixelRed(image,   ROUND_TO_QUANTUM(start_color->red   + (distance * red_step)), row_pixels);
+            SetPixelGreen(image, ROUND_TO_QUANTUM(start_color->green + (distance * green_step)), row_pixels);
+            SetPixelBlue(image,  ROUND_TO_QUANTUM(start_color->blue  + (distance * blue_step)), row_pixels);
+            SetPixelAlpha(image, OpaqueAlpha, row_pixels);
+
+            row_pixels += GetPixelChannels(image);
+        }
+
+        SyncAuthenticPixels(image, exception);
+        CHECK_EXCEPTION();
+    }
+
+    DestroyExceptionInfo(exception);
+#else
     // All the columns are the same, so make a master column and copy it to
     // each of the "real" columns.
     master = ALLOC_N(PixelPacket, image->rows);
 
-    for (y = 0; y < image->rows; y++)
+    for (y = 0; y < (ssize_t) image->rows; y++)
     {
         double distance   = fabs(y1 - y);
         master[y].red     = ROUND_TO_QUANTUM(start_color->red   + (distance * red_step));
@@ -305,32 +347,31 @@ horizontal_fill(
         master[y].opacity = OpaqueOpacity;
     }
 
-    for (x = 0; x < image->columns; x++)
+    for (x = 0; x < (ssize_t) image->columns; x++)
     {
         PixelPacket *col_pixels;
 
-#if defined(HAVE_QUEUEAUTHENTICPIXELS)
-        col_pixels = QueueAuthenticPixels(image, (long int)x, 0, 1, image->rows, &exception);
-#else
-        col_pixels = SetImagePixels(image, (long int)x, 0, 1, image->rows);
-        rm_check_image_exception(image, RetainOnError);
-#endif
+        col_pixels = QueueAuthenticPixels(image, x, 0, 1, image->rows, exception);
+        if (rm_should_raise_exception(exception, RetainExceptionRetention))
+        {
+            xfree((void *)master);
+            rm_raise_exception(exception);
+        }
+
         memcpy(col_pixels, master, image->rows * sizeof(PixelPacket));
 
-#if defined(HAVE_SYNCAUTHENTICPIXELS)
-        SyncAuthenticPixels(image, &exception);
-        CHECK_EXCEPTION()
-#else
-        SyncImagePixels(image);
-        rm_check_image_exception(image, RetainOnError);
-#endif
+        SyncAuthenticPixels(image, exception);
+        if (rm_should_raise_exception(exception, RetainExceptionRetention))
+        {
+            xfree((void *)master);
+            rm_raise_exception(exception);
+        }
     }
 
-#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
-    DestroyExceptionInfo(&exception);
-#endif
+    DestroyExceptionInfo(exception);
 
-    xfree((PixelPacket *)master);
+    xfree((void *) master);
+#endif
 }
 
 /**
@@ -354,18 +395,16 @@ v_diagonal_fill(
                double y1,
                double x2,
                double y2,
-               PixelPacket *start_color,
-               PixelPacket *stop_color)
+               PixelColor *start_color,
+               PixelColor *stop_color)
 {
-    unsigned long x, y;
+    ssize_t x, y;
     MagickRealType red_step, green_step, blue_step;
     double m, b, steps = 0.0;
     double d1, d2;
-#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
-    ExceptionInfo exception;
+    ExceptionInfo *exception;
 
-    GetExceptionInfo(&exception);
-#endif
+    exception = AcquireExceptionInfo();
 
     // Compute the equation of the line: y=mx+b
     m = ((double)(y2 - y1))/((double)(x2 - x1));
@@ -379,7 +418,7 @@ v_diagonal_fill(
 
     if (d1 < 0 && d2 < 0)
     {
-        steps += FMAX(fabs(d1),fabs(d2));
+        steps += FMAX(fabs(d1), fabs(d2));
     }
     else if (d1 > (double)image->rows && d2 > (double)image->rows)
     {
@@ -393,7 +432,7 @@ v_diagonal_fill(
     // If the line is entirely > image->rows, swap the start & end color
     if (steps < 0)
     {
-        PixelPacket t = *stop_color;
+        PixelColor t = *stop_color;
         *stop_color = *start_color;
         *start_color = t;
         steps = -steps;
@@ -403,39 +442,40 @@ v_diagonal_fill(
     green_step = ((MagickRealType)stop_color->green - (MagickRealType)start_color->green) / steps;
     blue_step =  ((MagickRealType)stop_color->blue  - (MagickRealType)start_color->blue)  / steps;
 
-    for (y = 0; y < image->rows; y++)
+    for (y = 0; y < (ssize_t) image->rows; y++)
     {
-        PixelPacket *row_pixels;
-
-#if defined(HAVE_QUEUEAUTHENTICPIXELS)
-        row_pixels = QueueAuthenticPixels(image, 0, (long int)y, image->columns, 1, &exception);
-        CHECK_EXCEPTION()
+#if defined(IMAGEMAGICK_7)
+        Quantum *row_pixels;
 #else
-        row_pixels = SetImagePixels(image, 0, (long int)y, image->columns, 1);
-        rm_check_image_exception(image, RetainOnError);
+        PixelPacket *row_pixels;
 #endif
-        for (x = 0; x < image->columns; x++)
+
+        row_pixels = QueueAuthenticPixels(image, 0, y, image->columns, 1, exception);
+        CHECK_EXCEPTION();
+
+        for (x = 0; x < (ssize_t) image->columns; x++)
         {
             double distance = (double) abs((int)(y-(m * x + b)));
+#if defined(IMAGEMAGICK_7)
+            SetPixelRed(image,   ROUND_TO_QUANTUM(start_color->red   + (distance * red_step)), row_pixels);
+            SetPixelGreen(image, ROUND_TO_QUANTUM(start_color->green + (distance * green_step)), row_pixels);
+            SetPixelBlue(image,  ROUND_TO_QUANTUM(start_color->blue  + (distance * blue_step)), row_pixels);
+            SetPixelAlpha(image, OpaqueAlpha, row_pixels);
+
+            row_pixels += GetPixelChannels(image);
+#else
             row_pixels[x].red     = ROUND_TO_QUANTUM(start_color->red   + (distance * red_step));
             row_pixels[x].green   = ROUND_TO_QUANTUM(start_color->green + (distance * green_step));
             row_pixels[x].blue    = ROUND_TO_QUANTUM(start_color->blue  + (distance * blue_step));
             row_pixels[x].opacity = OpaqueOpacity;
+#endif
         }
 
-#if defined(HAVE_SYNCAUTHENTICPIXELS)
-        SyncAuthenticPixels(image, &exception);
-        CHECK_EXCEPTION()
-#else
-        SyncImagePixels(image);
-        rm_check_image_exception(image, RetainOnError);
-#endif
+        SyncAuthenticPixels(image, exception);
+        CHECK_EXCEPTION();
     }
 
-#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
-    DestroyExceptionInfo(&exception);
-#endif
-
+    DestroyExceptionInfo(exception);
 }
 
 /**
@@ -459,18 +499,16 @@ h_diagonal_fill(
                double y1,
                double x2,
                double y2,
-               PixelPacket *start_color,
-               PixelPacket *stop_color)
+               PixelColor *start_color,
+               PixelColor *stop_color)
 {
-    unsigned long x, y;
+    ssize_t x, y;
     double m, b, steps = 0.0;
     MagickRealType red_step, green_step, blue_step;
     double d1, d2;
-#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
-    ExceptionInfo exception;
+    ExceptionInfo *exception;
 
-    GetExceptionInfo(&exception);
-#endif
+    exception = AcquireExceptionInfo();
 
     // Compute the equation of the line: y=mx+b
     m = ((double)(y2 - y1))/((double)(x2 - x1));
@@ -486,11 +524,11 @@ h_diagonal_fill(
     // the number of steps.
     if (d1 < 0 && d2 < 0)
     {
-        steps += FMAX(fabs(d1),fabs(d2));
+        steps += FMAX(fabs(d1), fabs(d2));
     }
     else if (d1 > (double)image->columns && d2 > (double)image->columns)
     {
-        steps += FMAX(abs((int)(image->columns-d1)),abs((int)(image->columns-d2)));
+        steps += FMAX(abs((int)(image->columns-d1)), abs((int)(image->columns-d2)));
     }
 
     d1 = FMAX(d1, image->columns-d1);
@@ -500,7 +538,7 @@ h_diagonal_fill(
     // If the line is entirely > image->columns, swap the start & end color
     if (steps < 0)
     {
-        PixelPacket t = *stop_color;
+        PixelColor t = *stop_color;
         *stop_color = *start_color;
         *start_color = t;
         steps = -steps;
@@ -510,57 +548,55 @@ h_diagonal_fill(
     green_step = ((MagickRealType)stop_color->green - (MagickRealType)start_color->green) / steps;
     blue_step =  ((MagickRealType)stop_color->blue  - (MagickRealType)start_color->blue)  / steps;
 
-    for (y = 0; y < image->rows; y++)
+    for (y = 0; y < (ssize_t) image->rows; y++)
     {
-        PixelPacket *row_pixels;
-
-#if defined(HAVE_QUEUEAUTHENTICPIXELS)
-        row_pixels = QueueAuthenticPixels(image, 0, (long int)y, image->columns, 1, &exception);
-        CHECK_EXCEPTION()
+#if defined(IMAGEMAGICK_7)
+        Quantum *row_pixels;
 #else
-        row_pixels = SetImagePixels(image, 0, (long int)y, image->columns, 1);
-        rm_check_image_exception(image, RetainOnError);
+        PixelPacket *row_pixels;
 #endif
-        for (x = 0; x < image->columns; x++)
+
+        row_pixels = QueueAuthenticPixels(image, 0, y, image->columns, 1, exception);
+        CHECK_EXCEPTION();
+
+        for (x = 0; x < (ssize_t) image->columns; x++)
         {
             double distance = (double) abs((int)(x-((y-b)/m)));
+#if defined(IMAGEMAGICK_7)
+            SetPixelRed(image,   ROUND_TO_QUANTUM(start_color->red   + (distance * red_step)), row_pixels);
+            SetPixelGreen(image, ROUND_TO_QUANTUM(start_color->green + (distance * green_step)), row_pixels);
+            SetPixelBlue(image,  ROUND_TO_QUANTUM(start_color->blue  + (distance * blue_step)), row_pixels);
+            SetPixelAlpha(image, OpaqueAlpha, row_pixels);
+
+            row_pixels += GetPixelChannels(image);
+#else
             row_pixels[x].red     = ROUND_TO_QUANTUM(start_color->red   + (distance * red_step));
             row_pixels[x].green   = ROUND_TO_QUANTUM(start_color->green + (distance * green_step));
             row_pixels[x].blue    = ROUND_TO_QUANTUM(start_color->blue  + (distance * blue_step));
             row_pixels[x].opacity = OpaqueOpacity;
+#endif
         }
 
-#if defined(HAVE_SYNCAUTHENTICPIXELS)
-        SyncAuthenticPixels(image, &exception);
-        CHECK_EXCEPTION()
-#else
-        SyncImagePixels(image);
-        rm_check_image_exception(image, RetainOnError);
-#endif
+        SyncAuthenticPixels(image, exception);
+        CHECK_EXCEPTION();
     }
 
-#if defined(HAVE_SYNCAUTHENTICPIXELS) || defined(HAVE_QUEUEAUTHENTICPIXELS)
-    DestroyExceptionInfo(&exception);
-#endif
+    DestroyExceptionInfo(exception);
 }
 
 /**
  * Call GradientFill with the start and stop colors specified when this fill
  * object was created.
  *
- * Ruby usage:
- *   - @verbatim GradientFill#fill(image) @endverbatim
- *
- * @param self this object
- * @param image_obj the image
- * @return self
+ * @param image_obj [Magick::Image] the image to fill
+ * @return [Magick::GradientFill] self
  */
 VALUE
 GradientFill_fill(VALUE self, VALUE image_obj)
 {
     rm_GradientFill *fill;
     Image *image;
-    PixelPacket start_color, stop_color;
+    PixelColor start_color, stop_color;
     double x1, y1, x2, y2;          // points on the line
 
     Data_Get_Struct(self, rm_GradientFill, fill);
@@ -631,51 +667,38 @@ free_TextureFill(void *fill_obj)
     rm_TextureFill *fill = (rm_TextureFill *)fill_obj;
 
     // Do not trace destruction
-    (void) DestroyImage(fill->texture);
+    if (fill->texture)
+    {
+        DestroyImage(fill->texture);
+    }
     xfree(fill);
 }
 
 /**
  * Create new TextureFill object.
  *
- * No Ruby usage (internal function)
- *
- * Notes:
- *   - The texture is an Image or Image *object
- *
- * @param class the Ruby class to use
- * @return a new TextureFill object
+ * @return [Magick::TextureFill] a new TextureFill object
  */
 VALUE
 TextureFill_alloc(VALUE class)
 {
     rm_TextureFill *fill;
-    return Data_Make_Struct(class
-                            , rm_TextureFill
-                            , NULL
-                            , free_TextureFill
-                            , fill);
+    return Data_Make_Struct(class, rm_TextureFill, NULL, free_TextureFill, fill);
 }
 
 /**
- * Store the texture image.
- *
- * Ruby usage:
- *   - @verbatim TextureFill#initialize(texture) @endverbatim
- *
- * Notes:
- *   - The texture is an Image or Image *object
+ * Initialize TextureFill object.
  *
- * @param self this object
- * @param texture_arg the texture
- * @return self
+ * @param texture_arg [Magick::Image, Magick::ImageList] Either an imagelist or an image. If an
+ *   imagelist, uses the current image.
+ * @return [Magick::TextureFill] self
  */
 VALUE
 TextureFill_initialize(VALUE self, VALUE texture_arg)
 {
     rm_TextureFill *fill;
     Image *texture;
-    volatile VALUE texture_image;
+    VALUE texture_image;
 
     Data_Get_Struct(self, rm_TextureFill, fill);
 
@@ -683,9 +706,12 @@ TextureFill_initialize(VALUE self, VALUE texture_arg)
 
     // Bump the reference count on the texture image.
     texture = rm_check_destroyed(texture_image);
-    (void) ReferenceImage(texture);
+    ReferenceImage(texture);
 
     fill->texture = texture;
+
+    RB_GC_GUARD(texture_image);
+
     return self;
 }
 
@@ -693,24 +719,30 @@ TextureFill_initialize(VALUE self, VALUE texture_arg)
  * Call TextureFill with the texture specified when this fill object was
  * created.
  *
- * Ruby usage:
- *   - @verbatim TextureFill#fill(image) @endverbatim
- *
- * @param self this object
- * @param image_obj the image
- * @return self
+ * @param image_obj [Magick::Image] the image to fill
+ * @return [Magick::TextureFill] self
  */
 VALUE
 TextureFill_fill(VALUE self, VALUE image_obj)
 {
     rm_TextureFill *fill;
     Image *image;
+#if defined(IMAGEMAGICK_7)
+    ExceptionInfo *exception;
+#endif
 
     image = rm_check_destroyed(image_obj);
     Data_Get_Struct(self, rm_TextureFill, fill);
 
-    (void) TextureImage(image, fill->texture);
+#if defined(IMAGEMAGICK_7)
+    exception = AcquireExceptionInfo();
+    TextureImage(image, fill->texture, exception);
+    CHECK_EXCEPTION();
+    DestroyExceptionInfo(exception);
+#else
+    TextureImage(image, fill->texture);
     rm_check_image_exception(image, RetainOnError);
+#endif
 
     return self;
 }