rmagick 3.2.0 → 4.3.0

data/ext/RMagick/rmfill.c

@@ -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(
@@ -132,25 +125,39 @@ point_fill(
 
     for (y = 0; y < (ssize_t) image->rows; y++)
     {
+#if defined(IMAGEMAGICK_7)
+        Quantum *row_pixels;
+#else
         PixelPacket *row_pixels;
+#endif
 
         row_pixels = QueueAuthenticPixels(image, 0, y, image->columns, 1, exception);
-        CHECK_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
         }
 
         SyncAuthenticPixels(image, exception);
-        CHECK_EXCEPTION()
+        CHECK_EXCEPTION();
     }
 
-    (void) DestroyExceptionInfo(exception);
+    DestroyExceptionInfo(exception);
 }
 
 /**
@@ -173,9 +180,11 @@ vertical_fill(
 {
     double steps;
     ssize_t x, y;
-    PixelPacket *master;
     MagickRealType red_step, green_step, blue_step;
     ExceptionInfo *exception;
+#if defined(IMAGEMAGICK_6)
+    PixelPacket *master;
+#endif
 
     exception = AcquireExceptionInfo();
 
@@ -193,6 +202,32 @@ 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);
@@ -228,9 +263,10 @@ vertical_fill(
         }
     }
 
-    (void) DestroyExceptionInfo(exception);
+    DestroyExceptionInfo(exception);
 
     xfree((void *) master);
+#endif
 }
 
 /**
@@ -252,9 +288,11 @@ horizontal_fill(
 {
     double steps;
     ssize_t x, y;
-    PixelPacket *master;
     MagickRealType red_step, green_step, blue_step;
     ExceptionInfo *exception;
+#if defined(IMAGEMAGICK_6)
+    PixelPacket *master;
+#endif
 
     exception = AcquireExceptionInfo();
 
@@ -271,6 +309,31 @@ 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);
@@ -305,9 +368,10 @@ horizontal_fill(
         }
     }
 
-    (void) DestroyExceptionInfo(exception);
+    DestroyExceptionInfo(exception);
 
     xfree((void *) master);
+#endif
 }
 
 /**
@@ -354,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)
     {
@@ -380,25 +444,38 @@ v_diagonal_fill(
 
     for (y = 0; y < (ssize_t) image->rows; y++)
     {
+#if defined(IMAGEMAGICK_7)
+        Quantum *row_pixels;
+#else
         PixelPacket *row_pixels;
+#endif
 
         row_pixels = QueueAuthenticPixels(image, 0, y, image->columns, 1, exception);
-        CHECK_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
         }
 
         SyncAuthenticPixels(image, exception);
-        CHECK_EXCEPTION()
+        CHECK_EXCEPTION();
     }
 
-    (void) DestroyExceptionInfo(exception);
+    DestroyExceptionInfo(exception);
 }
 
 /**
@@ -447,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);
@@ -473,37 +550,46 @@ h_diagonal_fill(
 
     for (y = 0; y < (ssize_t) image->rows; y++)
     {
+#if defined(IMAGEMAGICK_7)
+        Quantum *row_pixels;
+#else
         PixelPacket *row_pixels;
+#endif
 
         row_pixels = QueueAuthenticPixels(image, 0, y, image->columns, 1, exception);
-        CHECK_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
         }
 
         SyncAuthenticPixels(image, exception);
-        CHECK_EXCEPTION()
+        CHECK_EXCEPTION();
     }
 
-    (void) DestroyExceptionInfo(exception);
+    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)
@@ -581,44 +667,31 @@ 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.
+ * Initialize TextureFill object.
  *
- * Ruby usage:
- *   - @verbatim TextureFill#initialize(texture) @endverbatim
- *
- * Notes:
- *   - The texture is an Image or Image *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)
@@ -633,7 +706,7 @@ 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;
 
@@ -646,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;
 }