rmagick 4.0.0 → 4.1.0.rc1

data/ext/RMagick/rmstruct.c

@@ -289,7 +289,11 @@ Export_ColorInfo(ColorInfo *ci, VALUE st)
         ci->color.red = (MagickRealType) pixel.red;
         ci->color.green = (MagickRealType) pixel.green;
         ci->color.blue = (MagickRealType) pixel.blue;
+#if defined(IMAGEMAGICK_7)
+        ci->color.alpha = (MagickRealType) OpaqueAlpha;
+#else
         ci->color.opacity = (MagickRealType) OpaqueOpacity;
+#endif
         ci->color.index = (MagickRealType) 0;
     }
 
@@ -322,7 +326,11 @@ Color_to_MagickPixel(Image *image, MagickPixel *mpp, VALUE color)
     mpp->red = (MagickRealType) pp.red;
     mpp->green = (MagickRealType) pp.green;
     mpp->blue = (MagickRealType) pp.blue;
+#if defined(IMAGEMAGICK_7)
+    mpp->alpha = (MagickRealType) pp.alpha;
+#else
     mpp->opacity = (MagickRealType) pp.opacity;
+#endif
 }
 
 
@@ -367,7 +375,12 @@ Color_to_s(VALUE self)
 #endif
                   ci.name,
                   ComplianceType_name(&ci.compliance),
-                  ci.color.red, ci.color.green, ci.color.blue, QuantumRange - ci.color.opacity);
+                  ci.color.red, ci.color.green, ci.color.blue,
+#if defined(IMAGEMAGICK_7)
+                  ci.color.alpha);
+#else
+                  QuantumRange - ci.color.opacity);
+#endif
 
     destroy_ColorInfo(&ci);
     return rb_str_new2(buff);

data/ext/RMagick/rmutil.c

@@ -626,7 +626,18 @@ rm_app2quantum(VALUE obj)
 Image *
 rm_acquire_image(ImageInfo *info)
 {
+#if defined(IMAGEMAGICK_7)
+    Image *new_image;
+    ExceptionInfo *exception;
+
+    exception = AcquireExceptionInfo();
+    new_image = AcquireImage(info, exception);
+    CHECK_EXCEPTION()
+    (void) DestroyExceptionInfo(exception);
+    return new_image;
+#else
     return AcquireImage(info);
+#endif
 }
 
 
@@ -660,12 +671,19 @@ rm_cur_image(VALUE img)
 VALUE
 rm_pixelcolor_to_color_name(Image *image, PixelColor *color)
 {
+    PixelColor pp;
     char name[MaxTextExtent];
     ExceptionInfo *exception;
 
     exception = AcquireExceptionInfo();
 
-    (void) QueryColorname(image, color, X11Compliance, name, exception);
+    pp = *color;
+#if defined(IMAGEMAGICK_7)
+    pp.depth = MAGICKCORE_QUANTUM_DEPTH;
+    pp.colorspace = image->colorspace;
+#endif
+
+    (void) QueryColorname(image, &pp, X11Compliance, name, exception);
     CHECK_EXCEPTION()
     (void) DestroyExceptionInfo(exception);
 
@@ -701,7 +719,12 @@ rm_pixelcolor_to_color_name_info(Info *info, PixelColor *color)
         rb_raise(rb_eNoMemError, "not enough memory to continue.");
     }
 
+#if defined(IMAGEMAGICK_7)
+    image->alpha_trait = UndefinedPixelTrait;
+#else
     image->matte = MagickFalse;
+#endif
+
     color_name = rm_pixelcolor_to_color_name(image, color);
     (void) DestroyImage(image);
 
@@ -719,7 +742,11 @@ rm_pixelcolor_to_color_name_info(Info *info, PixelColor *color)
 void
 rm_init_magickpixel(const Image *image, MagickPixel *pp)
 {
+#if defined(IMAGEMAGICK_7)
+    GetPixelInfo(image, pp);
+#else
     GetMagickPixelPacket(image, pp);
+#endif
 }
 
 /**
@@ -736,7 +763,12 @@ rm_set_magickpixel(MagickPixel *pp, const char *color)
     ExceptionInfo *exception;
 
     exception = AcquireExceptionInfo();
+
+#if defined(IMAGEMAGICK_7)
+    (void) QueryColorCompliance(color, AllCompliance, pp, exception);
+#else
     (void) QueryMagickColor(color, pp, exception);
+#endif
     // This exception is ignored because the color comes from places where we control
     // the value and it is very unlikely that an exception will be thrown.
     (void) DestroyExceptionInfo(exception);
@@ -922,7 +954,18 @@ ImageMagickError_initialize(int argc, VALUE *argv, VALUE self)
 const char *
 rm_get_property(const Image *img, const char *property)
 {
+#if defined(IMAGEMAGICK_7)
+    const char *result;
+    ExceptionInfo *exception;
+
+    exception = AcquireExceptionInfo();
+    result = GetImageProperty(img, property, exception);
+    CHECK_EXCEPTION()
+    (void) DestroyExceptionInfo(exception);
+    return result;
+#else
     return GetImageProperty(img, property);
+#endif
 }
 
 
@@ -939,7 +982,18 @@ rm_get_property(const Image *img, const char *property)
 MagickBooleanType
 rm_set_property(Image *image, const char *property, const char *value)
 {
+#if defined(IMAGEMAGICK_7)
+    ExceptionInfo *exception;
+    MagickBooleanType okay;
+
+    exception = AcquireExceptionInfo();
+    okay = SetImageProperty(image, property, value, exception);
+    CHECK_EXCEPTION()
+    (void) DestroyExceptionInfo(exception);
+    return okay;
+#else
     return SetImageProperty(image, property, value);
+#endif
 }
 
 
@@ -1046,6 +1100,9 @@ void rm_sync_image_options(Image *image, Info *info)
     MagickStatusType flags;
     GeometryInfo geometry_info;
     const char *option;
+#if defined(IMAGEMAGICK_7)
+    ExceptionInfo *exception;
+#endif
 
     // The option strings will be set only when their attribute values were
     // set in the optional argument block.
@@ -1063,7 +1120,16 @@ void rm_sync_image_options(Image *image, Info *info)
 
     if (info->colorspace != UndefinedColorspace)
     {
+#if defined(IMAGEMAGICK_7)
+        exception = AcquireExceptionInfo();
+        SetImageColorspace(image, info->colorspace, exception);
+        // We should not throw an exception in this method because we will
+        // leak memory in the place where this method is called. And that is
+        // why the exception is being ignored here.
+        (void) DestroyExceptionInfo(exception);
+#else
         SetImageColorspace(image, info->colorspace);
+#endif
     }
 
     if (info->compression != UndefinedCompression)
@@ -1080,11 +1146,20 @@ void rm_sync_image_options(Image *image, Info *info)
     if (info->density)
     {
         flags = ParseGeometry(info->density, &geometry_info);
+#if defined(IMAGEMAGICK_7)
+        image->resolution.x = geometry_info.rho;
+        image->resolution.y = geometry_info.sigma;
+#else
         image->x_resolution = geometry_info.rho;
         image->y_resolution = geometry_info.sigma;
+#endif
         if ((flags & SigmaValue) == 0)
         {
+#if defined(IMAGEMAGICK_7)
+            image->resolution.y = image->resolution.x;
+#else
             image->y_resolution = image->x_resolution;
+#endif
         }
     }
 
@@ -1174,8 +1249,13 @@ void rm_sync_image_options(Image *image, Info *info)
               {
                 if (info->units == PixelsPerCentimeterResolution)
                 {
+#if defined(IMAGEMAGICK_7)
+                    image->resolution.x /= 2.54;
+                    image->resolution.y /= 2.54;
+#else
                     image->x_resolution /= 2.54;
                     image->y_resolution /= 2.54;
+#endif
                 }
                 break;
               }
@@ -1183,8 +1263,13 @@ void rm_sync_image_options(Image *image, Info *info)
               {
                 if (info->units == PixelsPerInchResolution)
                 {
+#if defined(IMAGEMAGICK_7)
+                    image->resolution.x *= 2.54;
+                    image->resolution.y *= 2.54;
+#else
                     image->x_resolution *= 2.54;
                     image->y_resolution *= 2.54;
+#endif
                 }
                 break;
               }
@@ -1219,8 +1304,16 @@ rm_exif_by_entry(Image *image)
     char *str;
     size_t len = 0, property_l, value_l;
     VALUE v;
+#if defined(IMAGEMAGICK_7)
+    ExceptionInfo *exception;
 
+    exception = AcquireExceptionInfo();
+    (void) GetImageProperty(image, "exif:*", exception);
+    CHECK_EXCEPTION()
+#else
     (void) GetImageProperty(image, "exif:*");
+#endif
+
     ResetImagePropertyIterator(image);
     property = GetNextImageProperty(image);
 
@@ -1236,7 +1329,12 @@ rm_exif_by_entry(Image *image)
                 len += 1;   // there will be a \n between property=value entries
             }
             len += property_l - 5;
-            value = GetImageProperty(image,property);
+#if defined(IMAGEMAGICK_7)
+            value = GetImageProperty(image, property, exception);
+            CHECK_EXCEPTION()
+#else
+            value = GetImageProperty(image, property);
+#endif
             if (value)
             {
                 // add 1 for the = between property and value
@@ -1248,8 +1346,12 @@ rm_exif_by_entry(Image *image)
 
     if (len == 0)
     {
+#if defined(IMAGEMAGICK_7)
+        (void) DestroyExceptionInfo(exception);
+#endif
         return Qnil;
     }
+
     str = xmalloc(len);
     len = 0;
 
@@ -1268,7 +1370,16 @@ rm_exif_by_entry(Image *image)
             }
             memcpy(str+len, property+5, property_l-5);
             len += property_l - 5;
-            value = GetImageProperty(image,property);
+#if defined(IMAGEMAGICK_7)
+            value = GetImageProperty(image, property, exception);
+            if (rm_should_raise_exception(exception, RetainExceptionRetention))
+            {
+                xfree(str);
+                rm_raise_exception(exception);
+            }
+#else
+            value = GetImageProperty(image, property);
+#endif
             if (value)
             {
                 value_l = strlen(value);
@@ -1280,6 +1391,10 @@ rm_exif_by_entry(Image *image)
         property = GetNextImageProperty(image);
     }
 
+#if defined(IMAGEMAGICK_7)
+    (void) DestroyExceptionInfo(exception);
+#endif
+
     v = rb_str_new(str, len);
     xfree(str);
 
@@ -1308,8 +1423,15 @@ rm_exif_by_number(Image *image)
     char *str;
     size_t len = 0, property_l, value_l;
     VALUE v;
+#if defined(IMAGEMAGICK_7)
+    ExceptionInfo *exception;
 
+    exception = AcquireExceptionInfo();
+    (void) GetImageProperty(image, "exif:!", exception);
+    CHECK_EXCEPTION()
+#else
     (void) GetImageProperty(image, "exif:!");
+#endif
     ResetImagePropertyIterator(image);
     property = GetNextImageProperty(image);
 
@@ -1325,7 +1447,12 @@ rm_exif_by_number(Image *image)
                 len += 1;   // there will be a \n between property=value entries
             }
             len += property_l;
-            value = GetImageProperty(image,property);
+#if defined(IMAGEMAGICK_7)
+            value = GetImageProperty(image, property, exception);
+            CHECK_EXCEPTION()
+#else
+            value = GetImageProperty(image, property);
+#endif
             if (value)
             {
                 // add 1 for the = between property and value
@@ -1337,8 +1464,12 @@ rm_exif_by_number(Image *image)
 
     if (len == 0)
     {
+#if defined(IMAGEMAGICK_7)
+        (void) DestroyExceptionInfo(exception);
+#endif
         return Qnil;
     }
+
     str = xmalloc(len);
     len = 0;
 
@@ -1357,7 +1488,16 @@ rm_exif_by_number(Image *image)
             }
             memcpy(str+len, property, property_l);
             len += property_l;
-            value = GetImageProperty(image,property);
+#if defined(IMAGEMAGICK_7)
+            value = GetImageProperty(image, property, exception);
+            if (rm_should_raise_exception(exception, RetainExceptionRetention))
+            {
+                xfree(str);
+                rm_raise_exception(exception);
+            }
+#else
+            value = GetImageProperty(image, property);
+#endif
             if (value)
             {
                 value_l = strlen(value);
@@ -1369,6 +1509,10 @@ rm_exif_by_number(Image *image)
         property = GetNextImageProperty(image);
     }
 
+#if defined(IMAGEMAGICK_7)
+    (void) DestroyExceptionInfo(exception);
+#endif
+
     v = rb_str_new(str, len);
     xfree(str);
 
@@ -1551,6 +1695,7 @@ rm_split(Image *image)
 }
 
 
+#if defined(IMAGEMAGICK_6)
 /**
  * If an ExceptionInfo struct in a list of images indicates a warning, issue a
  * warning message. If an ExceptionInfo struct indicates an error, raise an
@@ -1600,6 +1745,7 @@ rm_check_image_exception(Image *imglist, ErrorRetention retention)
 
     (void) DestroyExceptionInfo(exception);
 }
+#endif
 
 
 #define ERROR_MSG_SIZE 1024

data/lib/rmagick/version.rb

@@ -1,5 +1,5 @@
 module Magick
-  VERSION = '4.0.0'
+  VERSION = '4.1.0.rc1'
   MIN_RUBY_VERSION = '2.3.0'
   MIN_IM_VERSION = '6.7.7'
 end

data/lib/rmagick_internal.rb

@@ -25,6 +25,7 @@ module Magick
   @formats = nil
   @trace_proc = nil
   @exit_block_set_up = nil
+  IMAGEMAGICK_VERSION = Magick::Magick_version.split[1].split('-').first
 
   class << self
     def formats
@@ -239,7 +240,8 @@ module Magick
     # colorization rule
     def alpha(x, y, method)
       Kernel.raise ArgumentError, 'Unknown paint method' unless PAINT_METHOD_NAMES.key?(method.to_i)
-      primitive 'matte ' + format('%g,%g, %s', x, y, PAINT_METHOD_NAMES[method.to_i])
+      name = Gem::Version.new(Magick::IMAGEMAGICK_VERSION) > Gem::Version.new('7.0.0') ? 'alpha ' : 'matte '
+      primitive name + format('%g,%g, %s', x, y, PAINT_METHOD_NAMES[method.to_i])
     end
 
     # Draw an arc.

data/rmagick.gemspec

@@ -24,7 +24,6 @@ Gem::Specification.new do |s|
   s.executables                 = executables
   s.require_paths << 'ext' << 'deprecated'
 
-  s.rubyforge_project = 'rmagick'
   s.extensions = %w[ext/RMagick/extconf.rb]
   s.required_ruby_version = ">= #{Magick::MIN_RUBY_VERSION}"
   s.requirements << "ImageMagick #{Magick::MIN_IM_VERSION} or later"

data/spec/rmagick/image/dissolve_spec.rb

@@ -0,0 +1,54 @@
+RSpec.describe Magick::Image, '#dissolve' do
+  let(:img1) { Magick::Image.new(100, 100) { self.background_color = 'transparent' } }
+  let(:img2) { Magick::Image.new(100, 100) { self.background_color = 'green' }       }
+
+  it 'raises an error given invalid arguments' do
+    expect { img1.dissolve }.to raise_error(ArgumentError)
+    expect { img1.dissolve(img2, 'x') }.to raise_error(ArgumentError)
+    expect { img1.dissolve(img2, 0.50, 'x') }.to raise_error(ArgumentError)
+    expect { img1.dissolve(img2, 0.50, Magick::NorthEastGravity, 'x') }.to raise_error(TypeError)
+    expect { img1.dissolve(img2, 0.50, Magick::NorthEastGravity, 10, 'x') }.to raise_error(TypeError)
+  end
+
+  context 'when given 2 arguments' do
+    it 'works when alpha is float 0.0 to 1.0' do
+      dissolved = img1.dissolve(img2, 0.50)
+      expect(dissolved).to be_instance_of(Magick::Image)
+      expect(Float(dissolved.pixel_color(2, 2).alpha) / Magick::QuantumRange).to be_between(0.45, 0.55)
+      dissolved = img1.dissolve(img2, 0.20)
+      expect(Float(dissolved.pixel_color(2, 2).alpha) / Magick::QuantumRange).to be_between(0.15, 0.25)
+    end
+    it 'works when alpha is string percentage' do
+      dissolved = img1.dissolve(img2, '50%')
+      expect(dissolved).to be_instance_of(Magick::Image)
+      expect(Float(dissolved.pixel_color(2, 2).alpha) / Magick::QuantumRange).to be_between(0.45, 0.55)
+      dissolved = img1.dissolve(img2, '20%')
+      expect(Float(dissolved.pixel_color(2, 2).alpha) / Magick::QuantumRange).to be_between(0.15, 0.25)
+    end
+  end
+
+  context 'when given gravity' do
+    # generate an image to use with gravity
+    wk = Magick::Image.new(40, 40) { self.background_color = 'transparent' }
+    d = Magick::Draw.new
+    d.stroke('none').fill('blue')
+    d.circle(wk.columns / 2, wk.rows / 2, 4, wk.rows / 2)
+    d.draw(wk)
+
+    it 'works on colored background' do
+      # generate an image to use with gravity
+      dissolved = img2.dissolve(wk, 0.50, 1.0, Magick::CenterGravity)
+      expect(dissolved).to be_instance_of(Magick::Image)
+      expect(dissolved.pixel_color(10, 10)).to eq(img2.pixel_color(10, 10))
+      expect(Float(dissolved.pixel_color(50, 50).blue) / Magick::QuantumRange).to be_between(0.45, 0.55)
+      expect(Float(dissolved.pixel_color(50, 50).green)).to be_between(0, img2.pixel_color(2, 2).green).exclusive
+    end
+  end
+
+  # still need to test with destination percentage, offsets
+
+  it 'raises an error when the image has been destroyed' do
+    img1.destroy!
+    expect { img1.dissolve(img2, 0.50) }.to raise_error(Magick::DestroyedImageError)
+  end
+end