rmagick 7.1.4 → 7.1.6

data/ext/RMagick/rmimage.cpp

@@ -2714,27 +2714,6 @@ Image_chromaticity_eq(VALUE self, VALUE chroma)
 }
 
 
-/**
- * Same as {Magick::Image#dup} except the frozen state of the original is propagated to the new
- * copy.
- *
- * @return [Magick::Image] a clone of this object
- */
-VALUE
-Image_clone(VALUE self)
-{
-    VALUE clone;
-
-    clone = Image_dup(self);
-    if (OBJ_FROZEN(self))
-    {
-        OBJ_FREEZE(clone);
-    }
-
-    RB_GC_GUARD(clone);
-
-    return clone;
-}
 
 
 /**
@@ -2900,6 +2879,35 @@ Image_color_histogram(VALUE self)
 }
 
 
+/**
+ * Return true if the format is one handled by ImageMagick's META coder. set_profile
+ * decodes the profile with the coder of that name, so any other format would run an
+ * unrelated decoder (MSL, MVG, SVG, ...) on the profile bytes.
+ *
+ * No Ruby usage (internal function)
+ *
+ * @param format the format name
+ * @return true if the format is a META profile format, otherwise false
+ */
+static bool
+is_meta_profile_format(const char *format)
+{
+    static const char *meta_formats[] = {
+        "8BIM", "8BIMTEXT", "8BIMWTEXT", "APP1", "APP1JPEG", "EXIF",
+        "ICC", "ICM", "IPTC", "IPTCTEXT", "IPTCWTEXT", "XMP"
+    };
+
+    for (size_t i = 0; i < sizeof(meta_formats) / sizeof(meta_formats[0]); i++)
+    {
+        if (rm_strcasecmp(format, meta_formats[i]) == 0)
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+
 /**
  * Store all the profiles in the profile in the target image. Called from
  * Image_color_profile_eq and Image_iptc_profile_eq.
@@ -2927,10 +2935,17 @@ set_profile(VALUE self, const char *name, VALUE profile)
 
     profile_blob = rm_str2cstr(&profile, &profile_length);
 
+    // Reject the name before GetMagickInfo(), which loads the coder module it names
+    // ("*" loads all of them).
+    if (!is_meta_profile_format(name))
+    {
+        rb_raise(rb_eArgError, "unknown name: %s", name);
+    }
+
     exception = AcquireExceptionInfo();
     m = GetMagickInfo(name, exception);
     CHECK_EXCEPTION();
-    if (!m)
+    if (!m || !is_meta_profile_format(m->name))
     {
         DestroyExceptionInfo(exception);
         rb_raise(rb_eArgError, "unknown name: %s", name);
@@ -3861,7 +3876,8 @@ composite_channel(int bang, int argc, VALUE *argv, VALUE self)
 
 
 /**
- * Composite the source over the destination image channel as dictated by the affine transform.
+ * Composite the source over the destination image, changing only the specified channels of the
+ * destination. The arguments before the channels are the same as those of {Image#composite}.
  *
  * @overload composite_channel(image, x_off, y_off, composite_op, channel = Magick::AllChannels)
  *   @param image [Magick::Image, Magick::ImageList] Either an imagelist or an image. If an
@@ -3934,8 +3950,8 @@ Image_composite_channel(int argc, VALUE *argv, VALUE self)
 
 
 /**
- * Composite the source over the destination image channel as dictated by the affine transform.
- * In-place form of {Image#composite_channel}.
+ * Composite the source over the destination image, changing only the specified channels of the
+ * destination. In-place form of {Image#composite_channel}.
  *
  * @overload composite_channel!(image, x_off, y_off, composite_op, channel = Magick::AllChannels)
  *   @param image [Magick::Image, Magick::ImageList] Either an imagelist or an image. If an
@@ -3997,7 +4013,7 @@ Image_composite_channel(int argc, VALUE *argv, VALUE self)
  *   @param composite_op [Magick::CompositeOperator] the composite operator
  *   @param *channels [Magick::ChannelType] one or more ChannelType arguments.
  *
- * @return [Magick::Image] a new image
+ * @return [Magick::Image] self
  * @see Image#composite_channel
  * @see Image#composite!
  */
@@ -6186,22 +6202,6 @@ Image__dump(VALUE self, VALUE depth ATTRIBUTE_UNUSED)
 }
 
 
-/**
- * Duplicates an image.
- *
- * @return [Magick::Image] a new image
- */
-VALUE
-Image_dup(VALUE self)
-{
-    VALUE dup;
-
-    rm_check_destroyed(self);
-    dup = TypedData_Wrap_Struct(CLASS_OF(self), &rm_image_data_type, NULL);
-    RB_GC_GUARD(dup);
-
-    return rb_funcall(dup, rm_ID_initialize_copy, 1, self);
-}
 
 
 /**
@@ -8305,6 +8305,42 @@ Image_import_pixels(int argc, VALUE *argv, VALUE self)
 }
 
 
+/**
+ * Append formatted text to the buffer used by build_inspect_string.
+ *
+ * No Ruby usage (internal function)
+ *
+ * Notes:
+ *   - vsnprintf returns the length of the untruncated text, so only the bytes
+ *     that actually fit are counted. The returned offset never exceeds len-1,
+ *     so once the buffer is full later appends add nothing to it.
+ *
+ * @param buffer buffer for the output string
+ * @param len length of buffer
+ * @param x # bytes used in buffer, at most len-1
+ * @param format printf-style format string
+ * @return the new # bytes used in buffer, at most len-1
+ * @see build_inspect_string
+ */
+static int
+append_inspect_string(char *buffer, size_t len, int x, const char *format, ...)
+{
+    va_list args;
+    int n;
+
+    va_start(args, format);
+    n = vsnprintf(buffer+x, len-x, format, args);
+    va_end(args);
+
+    if (n > 0)
+    {
+        x += (int)min((size_t)n, len-1-x);
+    }
+
+    return x;
+}
+
+
 /**
  * Override Object#inspect - return a string description of the image.
  *
@@ -8328,56 +8364,56 @@ build_inspect_string(Image *image, char *buffer, size_t len)
     // Print magick filename if different from current filename.
     if (*image->magick_filename != '\0' && strcmp(image->magick_filename, image->filename) != 0)
     {
-        x += snprintf(buffer+x, len-x, "%.1024s=>", image->magick_filename);
+        x = append_inspect_string(buffer, len, x, "%.1024s=>", image->magick_filename);
     }
     // Print current filename.
-    x += snprintf(buffer+x, len-x, "%.1024s", image->filename);
+    x = append_inspect_string(buffer, len, x, "%.1024s", image->filename);
     // Print scene number.
     if ((GetPreviousImageInList(image) != NULL) && (GetNextImageInList(image) != NULL) && image->scene > 0)
     {
-        x += snprintf(buffer+x, len-x, "[%" RMIuSIZE "]", image->scene);
+        x = append_inspect_string(buffer, len, x, "[%" RMIuSIZE "]", image->scene);
     }
     // Print format
-    x += snprintf(buffer+x, len-x, " %s ", image->magick);
+    x = append_inspect_string(buffer, len, x, " %s ", image->magick);
 
     // Print magick columnsXrows if different from current.
     if (image->magick_columns != 0 || image->magick_rows != 0)
     {
         if (image->magick_columns != image->columns || image->magick_rows != image->rows)
         {
-            x += snprintf(buffer+x, len-x, "%" RMIuSIZE "x%" RMIuSIZE "=>", image->magick_columns, image->magick_rows);
+            x = append_inspect_string(buffer, len, x, "%" RMIuSIZE "x%" RMIuSIZE "=>", image->magick_columns, image->magick_rows);
         }
     }
 
-    x += snprintf(buffer+x, len-x, "%" RMIuSIZE "x%" RMIuSIZE " ", image->columns, image->rows);
+    x = append_inspect_string(buffer, len, x, "%" RMIuSIZE "x%" RMIuSIZE " ", image->columns, image->rows);
 
     // Print current columnsXrows
     if (   image->page.width != 0 || image->page.height != 0
            || image->page.x != 0     || image->page.y != 0)
     {
-        x += snprintf(buffer+x, len-x, "%" RMIuSIZE "x%" RMIuSIZE "+%" RMIdSIZE "+%" RMIdSIZE " ",
-                      image->page.width, image->page.height,
-                      image->page.x, image->page.y);
+        x = append_inspect_string(buffer, len, x, "%" RMIuSIZE "x%" RMIuSIZE "+%" RMIdSIZE "+%" RMIdSIZE " ",
+                                  image->page.width, image->page.height,
+                                  image->page.x, image->page.y);
     }
 
     if (image->storage_class == DirectClass)
     {
-        x += snprintf(buffer+x, len-x, "DirectClass ");
+        x = append_inspect_string(buffer, len, x, "DirectClass ");
         if (image->total_colors != 0)
         {
             if (image->total_colors >= (unsigned long)(1 << 24))
             {
-                x += snprintf(buffer+x, len-x, "%" RMIuSIZE "mc ", image->total_colors/1024/1024);
+                x = append_inspect_string(buffer, len, x, "%" RMIuSIZE "mc ", image->total_colors/1024/1024);
             }
             else
             {
                 if (image->total_colors >= (unsigned long)(1 << 16))
                 {
-                    x += snprintf(buffer+x, len-x, "%" RMIuSIZE "kc ", image->total_colors/1024);
+                    x = append_inspect_string(buffer, len, x, "%" RMIuSIZE "kc ", image->total_colors/1024);
                 }
                 else
                 {
-                    x += snprintf(buffer+x, len-x, "%" RMIuSIZE "c ", image->total_colors);
+                    x = append_inspect_string(buffer, len, x, "%" RMIuSIZE "c ", image->total_colors);
                 }
             }
         }
@@ -8388,39 +8424,39 @@ build_inspect_string(Image *image, char *buffer, size_t len)
         // building with GM. GM defines that field as an unsigned int.
         if (image->total_colors <= image->colors)
         {
-            x += snprintf(buffer+x, len-x, "PseudoClass %ldc ", (long) image->colors);
+            x = append_inspect_string(buffer, len, x, "PseudoClass %ldc ", (long) image->colors);
         }
         else
         {
-            x += snprintf(buffer+x, len-x, "PseudoClass %" RMIuSIZE "=>%" RMIuSIZE "c ", image->total_colors, image->colors);
+            x = append_inspect_string(buffer, len, x, "PseudoClass %" RMIuSIZE "=>%" RMIuSIZE "c ", image->total_colors, image->colors);
             if (image->error.mean_error_per_pixel != 0.0)
             {
-                x += snprintf(buffer+x, len-x, "%ld/%.6f/%.6fdb ",
-                              (long) (image->error.mean_error_per_pixel+0.5),
-                              image->error.normalized_mean_error,
-                              image->error.normalized_maximum_error);
+                x = append_inspect_string(buffer, len, x, "%ld/%.6f/%.6fdb ",
+                                          (long) (image->error.mean_error_per_pixel+0.5),
+                                          image->error.normalized_mean_error,
+                                          image->error.normalized_maximum_error);
             }
         }
     }
 
     // Print bit depth
     quantum_depth = GetImageQuantumDepth(image, MagickTrue);
-    x += snprintf(buffer+x, len-x, "%lu-bit", quantum_depth);
+    x = append_inspect_string(buffer, len, x, "%lu-bit", quantum_depth);
 
     // Print blob info if appropriate.
     if (GetBlobSize(image) != 0)
     {
         if (GetBlobSize(image) >= (1 << 24))
         {
-            x += snprintf(buffer+x, len-x, " %lumb", (unsigned long) (GetBlobSize(image)/1024/1024));
+            x = append_inspect_string(buffer, len, x, " %lumb", (unsigned long) (GetBlobSize(image)/1024/1024));
         }
         else if (GetBlobSize(image) >= 1024)
         {
-            x += snprintf(buffer+x, len-x, " %lukb", (unsigned long) (GetBlobSize(image)/1024));
+            x = append_inspect_string(buffer, len, x, " %lukb", (unsigned long) (GetBlobSize(image)/1024));
         }
         else
         {
-            x += snprintf(buffer+x, len-x, " %lub", (unsigned long) GetBlobSize(image));
+            x = append_inspect_string(buffer, len, x, " %lub", (unsigned long) GetBlobSize(image));
         }
     }
 
@@ -8440,7 +8476,7 @@ build_inspect_string(Image *image, char *buffer, size_t len)
         }
     }
 
-    assert(x < (int)(len-1));
+    assert(x < (int)len);
     buffer[x] = '\0';
 
     return;
@@ -8625,11 +8661,12 @@ Image_level2(int argc, VALUE *argv, VALUE self)
 /**
  * Similar to {Image#level2} but applies to a single channel only.
  *
- * @overload level_channel(aChannelType, black = 0.0, white = 1.0, gamma = Magick::QuantumRange)
+ * @overload level_channel(aChannelType, black = 0.0, white = Magick::QuantumRange - black, gamma = 1.0)
  *   @param aChannelType [Magick::ChannelType] A ChannelType value.
  *   @param black [Numeric] A black point level in the range 0..QuantumRange.
  *   @param white [Numeric] A white point level in the range 0..QuantumRange.
- *   @param gamma [Numeric] A gamma correction in the range 0.0 - 10.0.
+ *   @param gamma [Numeric] A gamma correction. Unlike with {Image#level}, a value greater than 10.0 is
+ *     used as given.
  *   @return [Magick::Image] a new image
  *   @see Image#level2
  */
@@ -10868,8 +10905,9 @@ Image_pixel_interpolation_method_eq(VALUE self, VALUE method)
 
 /**
  * Produce an image that looks like a Polaroid instant picture. If the image has a "Caption"
- * property, the value is used as a caption. A caption whose first non-blank character is '@'
- * is rejected because ImageMagick reads the caption from the file it names.
+ * property, the value is used as a caption. A caption whose first non-blank character is '@',
+ * or that contains a %[fx:@...], %[hex:@...] or %[pixel:@...] escape, is rejected because
+ * ImageMagick reads the file it names.
  *
  * The following annotate attributes control the label rendering:
  * align, decorate, density, encoding, fill, font, font_family, font_stretch, font_style,
@@ -10890,7 +10928,7 @@ Image_pixel_interpolation_method_eq(VALUE self, VALUE method)
  *   @yieldparam opt [Magick::Image::PolaroidOptions]
  *
  * @return [Magick::Image] a new image
- * @raise [ArgumentError] if the "Caption" property begins with '@'
+ * @raise [ArgumentError] if the "Caption" property names a file with '@'
  */
 VALUE
 Image_polaroid(int argc, VALUE *argv, VALUE self)
@@ -10928,20 +10966,11 @@ Image_polaroid(int argc, VALUE *argv, VALUE self)
 #else
     caption = GetImageProperty(clone, "Caption");
 #endif
-    if (caption)
+    if (caption && rm_has_file_reference(caption))
     {
-        const char *p = caption;
-
-        while (isspace((int) ((unsigned char) *p)))
-        {
-            p++;
-        }
-        if (*p == '@')
-        {
-            DestroyImage(clone);
-            DestroyExceptionInfo(exception);
-            rb_raise(rb_eArgError, "the Caption property must not begin with '@'");
-        }
+        DestroyImage(clone);
+        DestroyExceptionInfo(exception);
+        rb_raise(rb_eArgError, "the Caption property must not name a file with '@'");
     }
 
 #if defined(IMAGEMAGICK_7)
@@ -11045,11 +11074,13 @@ Image_preview(VALUE self, VALUE preview)
 
 /**
  * Set the image profile. If "profile" is nil, deletes the profile. Otherwise "profile" must be a
- * string containing the specified profile.
+ * string containing the specified profile, and "name" must be one of the profile formats of
+ * ImageMagick's META coder (8BIM, APP1, EXIF, ICC, ICM, IPTC, XMP and their variants).
  *
  * @param name [String, nil] The profile name, or "*" to represent all the profiles in the image.
  * @param profile [String] The profile value, or nil to cause the profile to be removed.
  * @return [Magick::Image] self
+ * @raise [ArgumentError] if "profile" is not nil and "name" is not a META profile format
  */
 VALUE
 Image_profile_bang(VALUE self, VALUE name, VALUE profile)
@@ -11999,35 +12030,71 @@ Image_rendering_intent_eq(VALUE self, VALUE ri)
 
 #if defined(IMAGEMAGICK_7)
 /**
- * Create new blurred image.
+ * Return the image to resize or resample with the given blur factor.
+ *
+ * ImageMagick 7 dropped the blur argument of ResizeImage() and ResampleImage(). Their filter
+ * reads the factor from the "filter:blur" artifact instead, as ImageMagick 6 did on top of the
+ * argument, so the factor is set there, multiplied by any "filter:blur" the image already has.
+ * A factor of 1.0 leaves the filter as it is.
  *
  * No Ruby usage (internal function)
  *
  * @param image the image
- * @param blur the blur
- * @return NULL if not apply blur, otherwise a new image
+ * @param blur the blur factor: > 1.0 blurs and < 1.0 sharpens
+ * @return the image itself when blur is 1.0, otherwise a clone that shares its pixels and has
+ *   the artifact set, which the caller destroys
  */
 static Image*
-blurred_image(Image* image, double blur)
+image_with_filter_blur(Image* image, double blur)
 {
-    ExceptionInfo *exception;
-    Image *new_image;
+    Image *clone;
+    const char *artifact;
+    char value[MaxTextExtent];
 
-    exception = AcquireExceptionInfo();
-    if (blur > 1.0)
+    if (blur == 1.0)
     {
-        GVL_STRUCT_TYPE(BlurImage) args = { image, blur, blur, exception };
-        new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(BlurImage), &args);
+        return image;
     }
-    else
+
+    artifact = GetImageArtifact(image, "filter:blur");
+    if (artifact)
     {
-        GVL_STRUCT_TYPE(SharpenImage) args = { image, blur, blur, exception };
-        new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(SharpenImage), &args);
+        blur *= InterpretLocaleValue(artifact, (char **)NULL);
     }
-    rm_check_exception(exception, new_image, DestroyOnError);
-    DestroyExceptionInfo(exception);
+    snprintf(value, sizeof(value), "%.17g", blur);
 
-    return new_image;
+    clone = rm_clone_image(image);
+    if (!SetImageArtifact(clone, "filter:blur", value))
+    {
+        DestroyImage(clone);
+        rb_raise(rb_eNoMemError, "not enough memory to continue");
+    }
+    return clone;
+}
+
+
+/**
+ * Give the result of a resize or resample the "filter:blur" artifact of the original image, or
+ * none, instead of the one image_with_filter_blur() set on the image it was made from.
+ *
+ * No Ruby usage (internal function)
+ *
+ * @param result the result image
+ * @param image the original image
+ */
+static void
+restore_filter_blur(Image* result, Image* image)
+{
+    const char *artifact = GetImageArtifact(image, "filter:blur");
+
+    if (artifact)
+    {
+        (void) SetImageArtifact(result, "filter:blur", artifact);
+    }
+    else
+    {
+        (void) DeleteImageArtifact(result, "filter:blur");
+    }
 }
 #endif
 
@@ -12112,12 +12179,22 @@ resample(int bang, int argc, VALUE *argv, VALUE self)
             break;
     }
 
+#if defined(IMAGEMAGICK_7)
+    // Before AcquireExceptionInfo(), since it can raise
+    Image *source = image_with_filter_blur(image, blur);
+#endif
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
-    Image *preprocess = blurred_image(image, blur);
-    GVL_STRUCT_TYPE(ResampleImage) args = { preprocess, x_resolution, y_resolution, filter, exception };
+    GVL_STRUCT_TYPE(ResampleImage) args = { source, x_resolution, y_resolution, filter, exception };
     new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ResampleImage), &args);
-    DestroyImage(preprocess);
+    if (source != image)
+    {
+        if (new_image)
+        {
+            restore_filter_blur(new_image, image);
+        }
+        DestroyImage(source);
+    }
 #else
     GVL_STRUCT_TYPE(ResampleImage) args = { image, x_resolution, y_resolution, filter, blur, exception };
     new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ResampleImage), &args);
@@ -12147,12 +12224,12 @@ resample(int bang, int argc, VALUE *argv, VALUE self)
  * the original resolution of the image must be specified via the density attribute prior to
  * specifying the resample resolution.
  *
- * @overload resample(x_resolution = 72.0, y_resolution = 72.0, filter = self.filter, blur = self.blur)
+ * @overload resample(x_resolution = 72.0, y_resolution = x_resolution, filter = self.filter, blur = 1.0)
  *   @param x_resolution [Numeric] the target horizontal resolution.
  *   @param y_resolution [Numeric] the target vertical resolution.
  *   @param filter [Magick::FilterType] the filter type
- *   @param blur [Numeric] the blur size
- *   @return [Magick] a new image
+ *   @param blur [Numeric] the blur factor of the filter: > 1.0 blurs and < 1.0 sharpens
+ *   @return [Magick::Image] a new image
  *   @see Image#resample!
  */
 VALUE
@@ -12167,12 +12244,12 @@ Image_resample(int argc, VALUE *argv, VALUE self)
  * Resample image to specified horizontal resolution, vertical resolution, filter and blur factor.
  * In-place form of {Image#resample}.
  *
- * @overload resample!(x_resolution = 72.0, y_resolution = 72.0, filter = self.filter, blur = self.blur)
+ * @overload resample!(x_resolution = 72.0, y_resolution = x_resolution, filter = self.filter, blur = 1.0)
  *   @param x_resolution [Numeric] the target horizontal resolution.
  *   @param y_resolution [Numeric] the target vertical resolution.
  *   @param filter [Magick::FilterType] the filter type
- *   @param blur [Numeric] the blur size
- *   @return [Magick] a new image
+ *   @param blur [Numeric] the blur factor of the filter: > 1.0 blurs and < 1.0 sharpens
+ *   @return [Magick::Image] self
  *   @see Image#resample
  */
 VALUE
@@ -12253,14 +12330,21 @@ resize(int bang, int argc, VALUE *argv, VALUE self)
             break;
     }
 
+#if defined(IMAGEMAGICK_7)
+    // Before AcquireExceptionInfo(), since it can raise
+    Image *source = image_with_filter_blur(image, blur);
+#endif
     exception = AcquireExceptionInfo();
 #if defined(IMAGEMAGICK_7)
-    Image *preprocess = (argc == 4) ? blurred_image(image, blur) : image;
-    GVL_STRUCT_TYPE(ResizeImage) args = { preprocess, columns, rows, filter, exception };
+    GVL_STRUCT_TYPE(ResizeImage) args = { source, columns, rows, filter, exception };
     new_image = (Image *)CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ResizeImage), &args);
-    if (argc == 4)
+    if (source != image)
     {
-        DestroyImage(preprocess);
+        if (new_image)
+        {
+            restore_filter_blur(new_image, image);
+        }
+        DestroyImage(source);
     }
 #else
     GVL_STRUCT_TYPE(ResizeImage) args = { image, columns, rows, filter, blur, exception };
@@ -12293,7 +12377,7 @@ resize(int bang, int argc, VALUE *argv, VALUE self)
  *   @param cols [Numeric] The desired width
  *   @param rows [Numeric] The desired height.
  *   @param filter [Magick::FilterType] the filter type
- *   @param blur [Numeric] the blur size
+ *   @param blur [Numeric] the blur factor of the filter: > 1.0 blurs and < 1.0 sharpens
  *
  * @return [Magick::Image] a new image
  * @see Image#resize!
@@ -12319,7 +12403,7 @@ Image_resize(int argc, VALUE *argv, VALUE self)
  *   @param cols [Numeric] The desired width
  *   @param rows [Numeric] The desired height.
  *   @param filter [Magick::FilterType] the filter type
- *   @param blur [Numeric] the blur size
+ *   @param blur [Numeric] the blur factor of the filter: > 1.0 blurs and < 1.0 sharpens
  *
  * @return [Magick::Image] a new image
  * @see Image#resize!
@@ -14537,8 +14621,8 @@ Image_ticks_per_second_eq(VALUE self, VALUE tps)
  *   @param red_alpha [Numeric] the red value
  *   @param green_alpha [Numeric] the green value
  *   @param blue_alpha [Numeric] the blue value
- *   @param alpha_alpha [Numeric] the alpha value
- *   @return a new image
+ *   @param alpha_alpha [Numeric] accepted but ignored: TintImage leaves the alpha channel unchanged
+ *   @return [Magick::Image] a new image
  */
 VALUE
 Image_tint(int argc, VALUE *argv, VALUE self)
@@ -15189,7 +15273,8 @@ VALUE Image_image_type_eq(VALUE self, VALUE image_type)
 
 
 /**
- * Removes an artifact from the image and returns its value.
+ * Removes an artifact from the image. The same as {Image#define} with a nil value, except that it
+ * returns self and that the name must be a String.
  *
  * @param artifact [String] the artifact
  * @return [Magick::Image] self