rmagick 1.14.1 → 1.15.0

data/ext/RMagick/rmagick_config.h.in

@@ -39,8 +39,6 @@
 #undef HAVE_CONTRASTSTRETCHIMAGECHANNEL
 /* Introduced in IM 6.0.1 */
 #undef HAVE_CONVOLVEIMAGECHANNEL
-/* Introduced in IM 5.5.7, GM 1.1 */
-#undef HAVE_COPYCYANCOMPOSITEOP
 /* Introduced in IM 6.0.0 */
 #undef HAVE_DSTCOMPOSITEOP
 /* Introduced in IM 6.0.1 */
@@ -55,6 +53,8 @@
 #undef HAVE_EXTENDEDUNSIGNEDINTEGRALTYPE
 /* Introduced in IM 5.5.5 - Not defined in GraphicsMagick */
 #undef HAVE_FUZZYCOLORCOMPARE
+/* Introduced in IM 6.2.0 */
+#undef HAVE_FXIMAGECHANNEL
 /* Introduced in IM 6.0.0, GM 1.1 */
 #undef HAVE_GAMMAIMAGECHANNEL
 /* Introduced in IM 6.0.1 */
@@ -147,6 +147,8 @@
 #undef HAVE_JPEG2000COMPRESSION
 /* Introduced in GM 1.2 */
 #undef HAVE_LABCOLORSPACE
+/* Introduced in IM 6.3.1 */
+#undef HAVE_LINEARSTRETCHIMAGE
 /* Introduced in IM 6.2.3 */
 #undef HAVE_LOGCOLORSPACE
 /* Introduced in IM 6.0.2 */
@@ -169,8 +171,14 @@
 #undef HAVE_NEW_COLORINFO
 /* Introduced in IM 6.1.0 */
 #undef HAVE_NORMALIZEIMAGECHANNEL
+/* Introduced in IM 6.3.0 */
+#undef HAVE_ORDEREDPOSTERIZEIMAGECHANNEL
+/* Introduced in IM 6.2.9 */
+#undef HAVE_PALETTEBILEVELMATTETYPE
 /* Introduced in IM 5.5.4 - Not available in GM */
 #undef HAVE_PARSESIZEGEOMETRY
+/* Introduced in IM 6.3.1-6 */
+#undef HAVE_POLAROIDIMAGE
 /* Introduced in IM 6.0.0 */
 #undef HAVE_POSTERIZEIMAGE
 /* Introduced in IM 5.5.1? Not available in GM */
@@ -189,6 +197,8 @@
 #undef HAVE_REC601YCBCRCOLORSPACE
 #undef HAVE_REC709LUMACOLORSPACE
 #undef HAVE_REC709YCBCRCOLORSPACE
+/* Introduced in IM 6.3.1-3 */
+#undef HAVE_RECOLORIMAGE
 /* Introduced in IM 6.2.1 */
 #undef HAVE_NEW_REMOVEIMAGEPROFILE
 #undef HAVE_REPLACECOMPOSITEOP

data/ext/RMagick/rmdraw.c

@@ -1,6 +1,6 @@
-/* $Id: rmdraw.c,v 1.34 2006/09/01 19:19:20 rmagick Exp $ */
+/* $Id: rmdraw.c,v 1.43 2007/01/20 17:40:41 rmagick Exp $ */
 /*============================================================================\
-|                Copyright (C) 2006 by Timothy P. Hunter
+|                Copyright (C) 2007 by Timothy P. Hunter
 | Name:     rmdraw.c
 | Author:   Tim Hunter
 | Purpose:  Contains Draw class methods.
@@ -13,9 +13,10 @@
 static void mark_Draw(void *);
 static void destroy_Draw(void *);
 static void destroy_Montage(void *);
+static VALUE new_DrawOptions(void);
 
 typedef MagickBooleanType (get_type_metrics_func_t)(Image *, const DrawInfo *, TypeMetric *);
-static VALUE get_type_metrics(int, VALUE *, VALUE, get_type_metrics_func_t *);
+static VALUE get_type_metrics(int, VALUE *, VALUE, get_type_metrics_func_t);
 
 
 /*
@@ -48,21 +49,6 @@ Draw_align_eq(VALUE self, VALUE align)
     return self;
 }
 
-/*
-    Method:     Draw#border_color=
-    Purpose:    border_color attribute writer
-*/
-VALUE
-Draw_border_color_eq(VALUE self, VALUE border_color)
-{
-    Draw *draw;
-
-    rm_check_frozen(self);
-    Data_Get_Struct(self, Draw, draw);
-    Color_to_PixelPacket(&draw->info->border_color, border_color);
-    return self;
-}
-
 /*
     Method:     Draw#decorate=
     Purpose:    decorate attribute writer
@@ -369,7 +355,7 @@ Draw_text_antialias_eq(VALUE self, VALUE text_antialias)
 
     rm_check_frozen(self);
     Data_Get_Struct(self, Draw, draw);
-    draw->info->text_antialias = RTEST(text_antialias);
+    draw->info->text_antialias = (MagickBooleanType) RTEST(text_antialias);
     return self;
 }
 
@@ -388,7 +374,7 @@ Draw_tile_eq(VALUE self, VALUE image)
 
     if (draw->info->fill_pattern)
     {
-        DestroyImage(draw->info->fill_pattern);
+        (void) DestroyImage(draw->info->fill_pattern);
         draw->info->fill_pattern = NULL;
     }
 
@@ -753,46 +739,23 @@ VALUE Draw_init_copy(VALUE self, VALUE orig)
     return self;
 }
 
+
 /*
     Method:     Draw#initialize <{ info initializers }>
     Purpose:    Initialize Draw object
-    Notes:      Here are the DrawInfo fields that are copied from Info.
-                These are the only Info fields that can be usefully
-                set in the initializer block.
-
-                DrawInfo            Info
-                --------            ---------
-                stroke_antialias    antialias
-                font                font
-                density             density
-                text_antialias      antialias
-                pointsize           pointsize
-                border_color        border_color
-                server_name         server_name
-                debug               debug
 */
 VALUE
 Draw_initialize(VALUE self)
 {
-    Draw *draw;
-    Info *info;
-    volatile VALUE info_obj;
+    Draw *draw, *draw_options;
+    volatile VALUE options;
 
     Data_Get_Struct(self, Draw, draw);
 
-    // Create a new Info object, running the info parms block in the process
-    info_obj = rm_info_new();
-
-    // Use the Info structure to create the DrawInfo structure
-    Data_Get_Struct(info_obj, Info, info);
-    draw->info = CloneDrawInfo(info, NULL);
-    if (!draw->info)
-    {
-        rb_raise(rb_eNoMemError, "not enough memory to continue");
-    }
-
-    draw->primitives = (VALUE)0;
-    draw->tmpfile_ary = NULL;
+    options = new_DrawOptions();
+    Data_Get_Struct(options, Draw, draw_options);
+    draw->info = draw_options->info;
+    draw_options->info = NULL;
 
     return self;
 }
@@ -815,11 +778,11 @@ Draw_inspect(VALUE self)
     Purpose:    Create a new Draw object
     Raises:     ImageMagickError if no memory
 */
-VALUE
+
 #if defined(HAVE_RB_DEFINE_ALLOC_FUNC)
-Draw_alloc(VALUE class)
+VALUE Draw_alloc(VALUE class)
 #else
-Draw_new(VALUE class)
+VALUE Draw_new(VALUE class)
 #endif
 {
     Draw *draw;
@@ -887,7 +850,10 @@ destroy_Draw(void *drawptr)
     Draw *draw = (Draw *)drawptr;
     struct TmpFile_Name *tmpfile;
 
-    DestroyDrawInfo(draw->info);
+    if (draw->info)
+    {
+        (void) DestroyDrawInfo(draw->info);
+    }
 
     // Erase any temporary image files.
     while (draw->tmpfile_ary)
@@ -901,6 +867,76 @@ destroy_Draw(void *drawptr)
     xfree(drawptr);
 }
 
+
+/*
+    Static:     new_DrawOptions
+    Purpose:    Allocate & initialize a DrawOptions object.
+*/
+static VALUE new_DrawOptions(void)
+{
+#if defined(HAVE_RB_DEFINE_ALLOC_FUNC)
+    return DrawOptions_initialize(Draw_alloc(Class_DrawOptions));
+#else
+    return DrawOptions_new(Class_DrawOptions);
+#endif
+}
+
+
+/*
+    Method:     DrawOptions#allocate
+                DarwOptions#new
+    Purpose:    Create a DrawOptions object
+    Notes:      The DrawOptions class is the same as the Draw class except
+                is has only the attribute writer functions.
+*/
+#if defined(HAVE_RB_DEFINE_ALLOC_FUNC)
+VALUE DrawOptions_alloc(VALUE class)
+#else
+VALUE DrawOptions_new(VALUE class)
+#endif
+{
+    Draw *draw_options;
+    volatile VALUE draw_options_obj;
+
+    draw_options = ALLOC(Draw);
+    memset(draw_options, 0, sizeof(Draw));
+    draw_options_obj = Data_Wrap_Struct(class, mark_Draw, destroy_Draw, draw_options);
+
+#if !defined(HAVE_RB_DEFINE_ALLOC_FUNC)
+    rb_obj_call_init(draw_options_obj, 0, NULL);
+#endif
+
+    return draw_options_obj;
+}
+
+
+/*
+    Method:     DrawOptions#initialize
+    Purpose:    Initialize a DrawOptions object
+*/
+VALUE DrawOptions_initialize(VALUE self)
+{
+    Draw *draw_options;
+
+    Data_Get_Struct(self, Draw, draw_options);
+    draw_options->info = magick_malloc(sizeof(DrawInfo));
+    if (!draw_options->info)
+    {
+        rb_raise(rb_eNoMemError, "not enough memory to continue");
+    }
+
+    GetDrawInfo(NULL, draw_options->info);
+
+    if (rb_block_given_p())
+    {
+        // Run the block in self's context
+        (void) rb_obj_instance_eval(0, NULL, self);
+    }
+
+    return self;
+}
+
+
 /*
     Method:     Magick::Montage#background_color(color-name)
     Purpose:    set background_color value
@@ -1100,7 +1136,7 @@ Montage_new(VALUE class)
     }
 
     montage_info = CloneMontageInfo(image_info, NULL);
-    DestroyImageInfo(image_info);
+    (void) (void) DestroyImageInfo(image_info);
 
     if (!montage_info)
     {
@@ -1113,7 +1149,7 @@ Montage_new(VALUE class)
     montage_obj = Data_Wrap_Struct(class, NULL, destroy_Montage, montage);
 
 #if !defined(HAVE_RB_DEFINE_ALLOC_FUNC)
-    rb_obj_call_init(montage_obj, 0, NULL);
+    (void) rb_obj_call_init(montage_obj, 0, NULL);
 #endif
 
     return montage_obj;
@@ -1145,11 +1181,14 @@ destroy_Montage(void *obj)
     Montage *montage = obj;
 
     // If we saved a temporary texture image, delete it now.
-    if (montage->info->texture != NULL)
+    if (montage->info && montage->info->texture != NULL)
     {
         rm_delete_temp_image(montage->info->texture);
     }
-    DestroyMontageInfo(montage->info);
+    if (montage->info)
+    {
+        (void) DestroyMontageInfo(montage->info);
+    }
     xfree(montage);
 }
 
@@ -1177,7 +1216,7 @@ Montage_shadow_eq(VALUE self, VALUE shadow)
     Montage *montage;
 
     Data_Get_Struct(self, Montage, montage);
-    montage->info->shadow = RTEST(shadow);
+    montage->info->shadow = (MagickBooleanType) RTEST(shadow);
     return self;
 }
 
@@ -1257,6 +1296,107 @@ Montage_title_eq(VALUE self, VALUE title)
 }
 
 
+/*
+    Extern:     PolaroidOptions_alloc()
+    Purpose:    Allocate a new Magick::PolaroidOptions object
+    Notes:      Internally a PolaroidOptions object is the same as a Draw
+                object. The methods are implemented by Draw methods in
+                rmdraw.c.
+*/
+VALUE
+PolaroidOptions_alloc(VALUE class)
+{
+    volatile VALUE polaroid_obj;
+    ImageInfo *image_info;
+    Draw *draw;
+
+    image_info = CloneImageInfo(NULL);
+
+    draw = ALLOC(Draw);
+    memset(draw, 0, sizeof(*draw));
+
+    draw->info=CloneDrawInfo(image_info,(DrawInfo *) NULL);
+    (void)(void) DestroyImageInfo(image_info);
+
+    polaroid_obj = Data_Wrap_Struct(class, NULL, destroy_Draw, draw);
+
+    return polaroid_obj;
+}
+
+
+/*
+    Method:     PolaroidOptions.new
+    Purpose:    Ruby 1.6 singleton function to allocate and init a PolaroidOptions
+                object
+*/
+#if !defined(HAVE_RB_DEFINE_ALLOC_FUNC)
+VALUE PolaroidOptions_new(VALUE class)
+{
+    volatile VALUE polaroid_obj;
+
+    polaroid_obj = PolaroidOptions_alloc(class);
+    rb_obj_call_init(polaroid_obj, 0, NULL);
+
+    return polaroid_obj;
+}
+#endif
+
+
+/*
+    Method:     Magick::PolaroidOptions#initialize
+    Purpose:    Yield to an optional block
+*/
+VALUE
+PolaroidOptions_initialize(VALUE self)
+{
+    Draw *draw;
+    ExceptionInfo exception;
+
+    // Default shadow color
+    Data_Get_Struct(self, Draw, draw);
+
+    GetExceptionInfo(&exception);
+    (void) QueryColorDatabase("gray75", &draw->shadow_color, &exception);
+    CHECK_EXCEPTION()
+
+    if (rb_block_given_p())
+    {
+        // Run the block in self's context
+        (void) rb_obj_instance_eval(0, NULL, self);
+    }
+    return self;
+}
+
+
+/*
+    Extern:     rm_polaroid_new
+    Purpose:    allocate a PolaroidOptions instance
+    Notes:      Internal use
+*/
+VALUE rm_polaroid_new(void)
+{
+#if defined(HAVE_RB_DEFINE_ALLOC_FUNC)
+    return PolaroidOptions_initialize(PolaroidOptions_alloc(Class_PolaroidOptions));
+#else
+    return PolaroidOptions_new(Class_PolaroidOptions);
+#endif
+}
+
+
+/*
+    Method:     PolaroidOptions#shadow_color=
+    Purpose:    Set the shadow color attribute
+*/
+VALUE PolaroidOptions_shadow_color_eq(VALUE self, VALUE shadow)
+{
+    Draw *draw;
+
+    Data_Get_Struct(self, Draw, draw);
+    Color_to_PixelPacket(&draw->shadow_color, shadow);
+    return self;
+}
+
+
 static VALUE get_dummy_tm_img(VALUE klass)
 {
     volatile VALUE dummy_img = 0;
@@ -1276,7 +1416,7 @@ static VALUE get_dummy_tm_img(VALUE klass)
         {
             rb_raise(rb_eNoMemError, "not enough memory to continue");
         }
-        DestroyImageInfo(info);
+        (void) DestroyImageInfo(info);
         dummy_img = rm_image_new(image);
 
         RUBY18(rb_cvar_set(klass, ID__dummy_img_, dummy_img, 0));
@@ -1298,10 +1438,10 @@ get_type_metrics(
      int argc,
      VALUE *argv,
      VALUE self,
-     get_type_metrics_func_t *getter)
+     get_type_metrics_func_t getter)
 {
      static char attrs[] = "OPbcdefghiklmnopqrstuwxyz[@#%";
- #define ATTRS_L (sizeof(attrs)-1)
+ #define ATTRS_L ((int)(sizeof(attrs)-1))
      Image *image;
      Draw *draw;
      TypeMetric metrics;

data/ext/RMagick/rmfill.c

@@ -1,6 +1,6 @@
-/* $Id: rmfill.c,v 1.15 2006/06/28 23:06:15 rmagick Exp $ */
+/* $Id: rmfill.c,v 1.17 2007/01/12 00:11:16 rmagick Exp $ */
 /*============================================================================\
-|                Copyright (C) 2006 by Timothy P. Hunter
+|                Copyright (C) 2007 by Timothy P. Hunter
 | Name:     rmfill.c
 | Author:   Tim Hunter
 | Purpose:  GradientFill, TextureFill class definitions for RMagick
@@ -116,7 +116,7 @@ point_fill(
     PixelPacket *stop_color)
 {
     double steps, distance;
-    long x, y;
+    unsigned long x, y;
     double red_step, green_step, blue_step;
 
     steps = sqrt((double)((image->columns-x0)*(image->columns-x0)
@@ -129,16 +129,16 @@ point_fill(
     {
         PixelPacket *row_pixels;
 
-        if (!(row_pixels = SetImagePixels(image, 0, y, image->columns, 1)))
+        if (!(row_pixels = SetImagePixels(image, 0, (long int)y, image->columns, 1)))
         {
             rm_check_image_exception(image, RetainOnError);
         }
         for (x = 0; x < image->columns; x++)
         {
             distance = sqrt((double)((x-x0)*(x-x0)+(y-y0)*(y-y0)));
-            row_pixels[x].red     = start_color->red   + (distance * red_step);
-            row_pixels[x].green   = start_color->green + (distance * green_step);
-            row_pixels[x].blue    = start_color->blue  + (distance * blue_step);
+            row_pixels[x].red     = RoundToQuantum(start_color->red   + (distance * red_step));
+            row_pixels[x].green   = RoundToQuantum(start_color->green + (distance * green_step));
+            row_pixels[x].blue    = RoundToQuantum(start_color->blue  + (distance * blue_step));
             row_pixels[x].opacity = OpaqueOpacity;
         }
         if (!SyncImagePixels(image))
@@ -161,7 +161,7 @@ vertical_fill(
     PixelPacket *stop_color)
 {
     double steps;
-    long x, y;
+    unsigned long x, y;
     volatile PixelPacket *master;
     double red_step, green_step, blue_step;
 
@@ -196,9 +196,9 @@ vertical_fill(
     for (x = 0; x < image->columns; x++)
     {
         double distance   = fabs(x1 - x);
-        master[x].red     = start_color->red   + (red_step * distance);
-        master[x].green   = start_color->green + (green_step * distance);
-        master[x].blue    = start_color->blue  + (blue_step * distance);
+        master[x].red     = RoundToQuantum(start_color->red   + (red_step * distance));
+        master[x].green   = RoundToQuantum(start_color->green + (green_step * distance));
+        master[x].blue    = RoundToQuantum(start_color->blue  + (blue_step * distance));
         master[x].opacity = OpaqueOpacity;
     }
 
@@ -207,7 +207,7 @@ vertical_fill(
     {
         PixelPacket *row_pixels;
 
-        if (!(row_pixels = SetImagePixels(image, 0, y, image->columns, 1)))
+        if (!(row_pixels = SetImagePixels(image, 0, (long int)y, image->columns, 1)))
         {
             rm_check_image_exception(image, RetainOnError);
         }
@@ -234,7 +234,7 @@ horizontal_fill(
     PixelPacket *stop_color)
 {
     double steps;
-    long x, y;
+    unsigned long x, y;
     volatile PixelPacket *master;
     double red_step, green_step, blue_step;
 
@@ -267,9 +267,9 @@ horizontal_fill(
     for (y = 0; y < image->rows; y++)
     {
         double distance   = fabs(y1 - y);
-        master[y].red     = start_color->red   + (distance * red_step);
-        master[y].green   = start_color->green + (distance * green_step);
-        master[y].blue    = start_color->blue  + (distance * blue_step);
+        master[y].red     = RoundToQuantum(start_color->red   + (distance * red_step));
+        master[y].green   = RoundToQuantum(start_color->green + (distance * green_step));
+        master[y].blue    = RoundToQuantum(start_color->blue  + (distance * blue_step));
         master[y].opacity = OpaqueOpacity;
     }
 
@@ -277,7 +277,7 @@ horizontal_fill(
     {
         PixelPacket *col_pixels;
 
-        if (!(col_pixels = SetImagePixels(image, x, 0, 1, image->rows)))
+        if (!(col_pixels = SetImagePixels(image, (long int)x, 0, 1, image->rows)))
         {
             rm_check_image_exception(image, RetainOnError);
         }
@@ -306,7 +306,7 @@ v_diagonal_fill(
     PixelPacket *start_color,
     PixelPacket *stop_color)
 {
-    long x, y;
+    unsigned long x, y;
     double red_step, green_step, blue_step;
     double m, b, steps = 0.0;
     double d1, d2;
@@ -325,7 +325,7 @@ v_diagonal_fill(
     {
         steps += FMAX(fabs(d1),fabs(d2));
     }
-    else if (d1 > image->rows && d2 > image->rows)
+    else if (d1 > (double)image->rows && d2 > (double)image->rows)
     {
         steps += FMAX(d1-image->rows, d2-image->rows);
     }
@@ -351,16 +351,16 @@ v_diagonal_fill(
     {
         PixelPacket *row_pixels;
 
-        if (!(row_pixels = SetImagePixels(image, 0, y, image->columns, 1)))
+        if (!(row_pixels = SetImagePixels(image, 0, (long int)y, image->columns, 1)))
         {
             rm_check_image_exception(image, RetainOnError);
         }
         for (x = 0; x < image->columns; x++)
         {
-            double distance = fabs(y-(m * x + b));
-            row_pixels[x].red     = start_color->red   + (distance * red_step);
-            row_pixels[x].green   = start_color->green + (distance * green_step);
-            row_pixels[x].blue    = start_color->blue  + (distance * blue_step);
+            double distance = (double) abs((int)(y-(m * x + b)));
+            row_pixels[x].red     = RoundToQuantum(start_color->red   + (distance * red_step));
+            row_pixels[x].green   = RoundToQuantum(start_color->green + (distance * green_step));
+            row_pixels[x].blue    = RoundToQuantum(start_color->blue  + (distance * blue_step));
             row_pixels[x].opacity = OpaqueOpacity;
         }
         if (!SyncImagePixels(image))
@@ -385,7 +385,7 @@ h_diagonal_fill(
     PixelPacket *start_color,
     PixelPacket *stop_color)
 {
-    long x, y;
+    unsigned long x, y;
     double m, b, steps = 0.0;
     double red_step, green_step, blue_step;
     double d1, d2;
@@ -398,7 +398,7 @@ h_diagonal_fill(
     // the left or right side of the image between y=0 and y=image->rows.
     // When y=0, x=-b/m. When y=image->rows, x = (image->rows-b)/m.
     d1 = -b/m;
-    d2 = (image->rows-b)/m;
+    d2 = (double) ((image->rows-b) / m);
 
     // If the line is entirely to the right or left of the image, increase
     // the number of steps.
@@ -406,9 +406,9 @@ h_diagonal_fill(
     {
         steps += FMAX(fabs(d1),fabs(d2));
     }
-    else if (d1 > image->columns && d2 > image->columns)
+    else if (d1 > (double)image->columns && d2 > (double)image->columns)
     {
-        steps += FMAX(fabs(image->columns-d1),fabs(image->columns-d2));
+        steps += FMAX(abs((int)(image->columns-d1)),abs((int)(image->columns-d2)));
     }
 
     d1 = FMAX(d1, image->columns-d1);
@@ -432,16 +432,16 @@ h_diagonal_fill(
     {
         PixelPacket *row_pixels;
 
-        if (!(row_pixels = SetImagePixels(image, 0, y, image->columns, 1)))
+        if (!(row_pixels = SetImagePixels(image, 0, (long int)y, image->columns, 1)))
         {
             rm_check_image_exception(image, RetainOnError);
         }
         for (x = 0; x < image->columns; x++)
         {
-            double distance = fabs(x-((y-b)/m));
-            row_pixels[x].red     = start_color->red   + (distance * red_step);
-            row_pixels[x].green   = start_color->green + (distance * green_step);
-            row_pixels[x].blue    = start_color->blue  + (distance * blue_step);
+            double distance = (double) abs((int)(x-((y-b)/m)));
+            row_pixels[x].red     = RoundToQuantum(start_color->red   + (distance * red_step));
+            row_pixels[x].green   = RoundToQuantum(start_color->green + (distance * green_step));
+            row_pixels[x].blue    = RoundToQuantum(start_color->blue  + (distance * blue_step));
             row_pixels[x].opacity = OpaqueOpacity;
         }
         if (!SyncImagePixels(image))
@@ -529,7 +529,7 @@ free_TextureFill(void *fill_obj)
 {
     rm_TextureFill *fill = (rm_TextureFill *)fill_obj;
 
-    DestroyImage(fill->texture);
+    (void) DestroyImage(fill->texture);
     xfree(fill);
 }
 
@@ -585,7 +585,7 @@ TextureFill_initialize(VALUE self, VALUE texture_arg)
 
     // Bump the reference count on the texture image.
     Data_Get_Struct(texture_image, Image, texture);
-    ReferenceImage(texture);
+    (void) ReferenceImage(texture);
 
     fill->texture = texture;
     return self;
@@ -604,7 +604,7 @@ TextureFill_fill(VALUE self, VALUE image_obj)
     Data_Get_Struct(image_obj, Image, image);
     Data_Get_Struct(self, rm_TextureFill, fill);
 
-    TextureImage(image, fill->texture);
+    (void) TextureImage(image, fill->texture);
     rm_check_image_exception(image, RetainOnError);
 
     return self;