rmagick 2.16.0 → 5.1.0

data/examples/spinner.rb

@@ -1,49 +0,0 @@
-# Make a 32x32 animated GIF that resembles the OS X animation.
-# This produces a very small (~2.6Kb) GIF file.
-
-require 'rmagick'
-
-puts <<END_INFO
-This example creates an animated GIF that resembles the OS X "waiting" icon.
-You can view the GIF with the command
-
-    animate spinner.gif
-END_INFO
-
-NFRAMES = 12                    # number of frames in the animation
-DIM = 32                        # width & height of image in pixels
-DELAY = 100.0 / (NFRAMES/2)     # 2 rotations per second
-
-# 'frame' is a single frame in the animation.
-frame = Magick::Image.new(DIM, DIM) {self.background_color = 'transparent'}
-
-# 'spinner' will contain the frames that make up the animated GIF
-spinner = Magick::ImageList.new
-
-# 'level' is the change from darkest gray to white
-level = Magick::QuantumRange / 2 / NFRAMES
-
-NFRAMES.times do |x|
-  gc = Magick::Draw.new
-  gc.translate(DIM/2, DIM/2)
-  gc.stroke('none')
-  intensity = 0.58 * Magick::QuantumRange
-  fill_color = Magick::Pixel.new(intensity, intensity, intensity).to_color
-  gc.fill(fill_color)
-  angle = x * (360/NFRAMES)
-  NFRAMES.times do
-    gc.rotate(angle)
-    intensity = [intensity, Magick::QuantumRange].min
-    fill_color = Magick::Pixel.new(intensity, intensity, intensity).to_color
-    gc.fill(fill_color)
-    gc.roundrectangle(7, -1, 15, 0, 1, 1)
-    angle = -(360/NFRAMES)
-    intensity += level
-  end
-  spinner << frame.copy
-  gc.draw(spinner)
-end
-
-spinner.delay = DELAY
-spinner.compression = Magick::LZWCompression
-spinner.write('spinner.gif')

data/examples/thumbnail.rb

@@ -1,64 +0,0 @@
-require 'rmagick'
-include Magick
-
-puts <<END_INFO
-
-This example demonstrates how to make a thumbnail of an image.
-An image is resized to the target size (retaining its original
-aspect ratio, of course) and then "mounted" on a square background
-with raised edges.
-
-Usage:
-
-    ruby thumbnail.rb <filename <size>>
-
-where `filename' is the name of an image file and `size' is the
-size of the thumbnail in pixels. The default size is 120 pixels.
-If you don't specify any arguments this script uses a default
-image.
-
-END_INFO
-
-DEFAULT_SIZE = 120
-
-case ARGV.length
-when 2
-  size = ARGV[1].to_i
-  image = ARGV[0]
-when 1
-  image = ARGV[0]
-  size = DEFAULT_SIZE
-else
-  size = DEFAULT_SIZE
-  image = '../doc/ex/images/Flower_Hat.jpg'
-end
-
-geom = "#{size}x#{size}"
-
-# Read the image and resize it. The `change_geometry' method
-# computes the new image geometry and yields to a block. The
-# return value of the block is the return value of the method.
-
-img = Image.read(image)[0]
-img.change_geometry!(geom) { |cols, rows| img.thumbnail! cols, rows }
-
-# We need a background to display the thumbnail.
-# Create a square, neutral gray background with raised edges.
-# Make this background slightly larger than the image to allow
-# for the raised border. A 3-pixel raised edge means that the
-# background needs to be 6 pixels larger in each dimension.
-
-bg = Image.new(size+6, size+6) { self.background_color = 'gray75' }
-bg = bg.raise(3,3)
-
-# Just for the purposes of this example, display the thumbnail background on
-# a larger white background.
-
-white_bg = Image.new(size+50, size+50) {self.background_color = 'white'}
-white_bg = white_bg.composite(bg, CenterGravity, OverCompositeOp)
-
-# Finally, center the thumbnail on the gray background.
-thumbnail = white_bg.composite(img, CenterGravity, OverCompositeOp)
-
-thumbnail.write('thumbnail.gif')
-exit

data/examples/vignette.rb

@@ -1,78 +0,0 @@
-require 'rmagick'
-include Magick
-
-puts <<END_INFO
-
-    vi-gnette (n.) vin-'yet
-    A picture that shades off gradually into the surrounding paper.
-                                Merriam-Webster Dictionary
-
-    Vignettes are frequently used in formal portraiture and advertising
-    images. This example creates a vignette from a picture of a ballerina.
-    It takes a few seconds to run. Be patient.
-
-END_INFO
-
-ballerina = Image.read('../doc/ex/images/Ballerina3.jpg')[0]
-
-# Note: this technique won't work with every image. To make a pretty
-# vignette you need an image with a uniform, fairly dark background.
-
-# Start by drawing a white oval on a black background. (Although you don't
-# have to use an oval at all! Any shape will work. Try a rounded rectangle.)
-# The black pixels correspond to pixels in the image that will become
-# transparent. The white pixels correspond to pixels in the image that will
-# remain unchanged. Gray pixels, introduced by the blurring below, will
-# become more or less transparent depending on how dark or light the pixel is.
-
-# The size of the oval is arbitrary - in this case it's 90% of the
-# size of the image.
-
-oval = Image.new(ballerina.columns, ballerina.rows) {self.background_color = 'black'}
-gc = Draw.new
-gc.stroke('white')
-gc.fill('white')
-gc.ellipse(ballerina.columns/2, ballerina.rows/2,
-           ballerina.columns/2-(ballerina.columns*0.10),
-           ballerina.rows/2-(ballerina.rows*0.10), 0, 360)
-gc.draw(oval)
-
-# Add a lot of blurring to the oval. I use blur_image because it's much faster
-# than the gaussian_blur method and produces no observable difference. The
-# exact amount of blurring is a judgment call. The higher the 2nd argument, the
-# more blurring, although increasing the value above 20 doesn't seem to add any
-# additional blurriness.
-
-oval = oval.blur_image(0, 20)
-
-# The CopyOpacityCompositeOp transforms the opacity level of each image pixel
-# according to the intensity of the composite image pixels. In this case, the
-# black pixels outside the oval become transparent and the white pixels inside
-# the oval remain opaque. Each gray pixel around the border of the oval has a
-# varying level of transparency depending on how dark or light it is.
-
-ballerina.matte = true  # Ensure the ballerina image's opacity channel is enabled.
-oval.matte = false      # Force the CopyOpacityCompositeOp to use pixel intensity
-# to determine how much transparency to add to the ballerina
-# pixels.
-
-ballerina = ballerina.composite(oval, CenterGravity, CopyOpacityCompositeOp)
-
-# Since the vignette has multiple levels of transparency, we can't
-# save it as a GIF or a JPEG. The PNG format can handle it, though.
-
-begin
-  ballerina.write('vignette.png')
-rescue ImageMagickError
-  puts 'Write failed. No PNG support?'
-  # In case PNG support isn't installed, just ignore the exception.
-end
-
-# At this point the vignette is complete. However, the `display' method only
-# supports 1`level of transparency. Therefore, composite the vignette over a
-# standard "checkerboard" background. The resulting image will be 100% opaque.
-
-checkerboard = Image.read('pattern:checkerboard') {self.size = "#{ballerina.columns}x#{ballerina.rows}"}
-vignette = checkerboard[0].composite(ballerina, CenterGravity, OverCompositeOp)
-vignette.display
-exit

data/spec/rmagick/ImageList1_spec.rb

@@ -1,24 +0,0 @@
-RSpec.describe Magick::ImageList do
-  describe 'images_from_imagelist' do
-    it 'works with identical instances' do
-      expect do
-        img = Magick::Image.new(1, 1)
-        list = Magick::ImageList.new
-        list << img << img
-        res = list.append(false)
-        expect(res.columns).to eq(2)
-        expect(res.rows).to eq(1)
-      end.not_to raise_error
-
-      expect do
-        img = Magick::Image.new(1, 1)
-        img2 = Magick::Image.new(3, 3)
-        list = Magick::ImageList.new
-        list.concat([img, img2, img, img2, img])
-        res = list.append(false)
-        expect(res.columns).to eq(9)
-        expect(res.rows).to eq(3)
-      end.not_to raise_error
-    end
-  end
-end

data/spec/rmagick/draw_spec.rb

@@ -1,156 +0,0 @@
-class Magick::Draw
-  def self._dummy_img_
-    @@_dummy_img_
-  end
-end
-
-RSpec.describe Magick::Draw do
-  let(:draw) { Magick::Draw.new }
-
-  describe '._dummy_img_' do
-    it 'works' do
-      # initially this variable is not defined.
-      expect { Magick::Draw._dummy_img_ }.to raise_error(NameError)
-
-      # cause it to become defined. save the object id.
-      draw.get_type_metrics('ABCDEF')
-      dummy = nil
-      expect { dummy = Magick::Draw._dummy_img_ }.not_to raise_error
-
-      expect(dummy).to be_instance_of(Magick::Image)
-
-      # ensure that it is always the same object
-      draw.get_type_metrics('ABCDEF')
-      dummy2 = nil
-      expect { dummy2 = Magick::Draw._dummy_img_ }.not_to raise_error
-      expect(dummy).to eq dummy2
-    end
-  end
-
-  describe '#kerning=' do
-    it 'assigns without raising an error' do
-      expect { draw.kerning = 1 }.not_to raise_error
-    end
-  end
-
-  describe '#kerning' do
-    it 'accepts a valid parameter without raising an error' do
-      expect { draw.kerning(1) }.not_to raise_error
-    end
-
-    it 'raises an error when given an invalid parameter' do
-      expect { draw.kerning('a') }.to raise_error(ArgumentError)
-      expect { draw.kerning([]) }.to raise_error(TypeError)
-    end
-  end
-
-  describe '#interline_spacing=' do
-    it 'assigns without raising an error' do
-      expect { draw.interline_spacing = 1 }.not_to raise_error
-    end
-  end
-
-  describe '#interline_spacing' do
-    it 'accepts a valid parameter without raising an error' do
-      expect { draw.interline_spacing(1) }.not_to raise_error
-    end
-
-    it 'raises an error when given an invalid parameter' do
-      expect { draw.interline_spacing('a') }.to raise_error(ArgumentError)
-      expect { draw.interline_spacing([]) }.to raise_error(TypeError)
-    end
-  end
-
-  describe '#interword_spacing=' do
-    it 'assigns without raising an error' do
-      expect { draw.interword_spacing = 1 }.not_to raise_error
-    end
-  end
-
-  describe '#interword_spacing' do
-    it 'accepts a valid parameter without raising an error' do
-      expect { draw.interword_spacing(1) }.not_to raise_error
-    end
-
-    it 'raises an error when given an invalid parameter' do
-      expect { draw.interword_spacing('a') }.to raise_error(ArgumentError)
-      expect { draw.interword_spacing([]) }.to raise_error(TypeError)
-    end
-  end
-
-  describe '#marshal_dump', '#marshal_load' do
-    it 'marshals without an error' do
-      skip 'this spec fails on some versions of ImageMagick'
-      rose = Magick::Image.read('rose:').first
-      granite = Magick::Image.read('granite:').first
-      s = granite.to_blob { self.format = 'miff' }
-      granite = Magick::Image.from_blob(s).first
-      blue_stroke = Magick::Image.new(20,20) { self.background_color = 'blue' }
-      s = blue_stroke.to_blob { self.format = 'miff' }
-      blue_stroke = Magick::Image.from_blob(s).first
-
-      draw.affine = Magick::AffineMatrix.new(1, 2, 3, 4, 5, 6)
-      draw.decorate = Magick::LineThroughDecoration
-      draw.encoding = 'AdobeCustom'
-      draw.gravity = Magick::CenterGravity
-      draw.fill = Magick::Pixel.from_color('red')
-      draw.stroke = Magick::Pixel.from_color('blue')
-      draw.stroke_width = 5
-      draw.fill_pattern = granite
-      draw.stroke_pattern = blue_stroke
-      draw.text_antialias = true
-      draw.font = 'Arial-Bold'
-      draw.font_family = 'arial'
-      draw.font_style = Magick::ItalicStyle
-      draw.font_stretch = Magick::CondensedStretch
-      draw.font_weight = Magick::BoldWeight
-      draw.pointsize = 12
-      draw.density = '72x72'
-      draw.align = Magick::CenterAlign
-      draw.undercolor = Magick::Pixel.from_color('green')
-      draw.kerning = 10.5
-      draw.interword_spacing = 3.75
-
-      draw.circle(20, 25, 20, 28)
-      dumped = nil
-      expect { dumped = Marshal.dump(draw) }.not_to raise_error
-      expect { Marshal.load(dumped) }.not_to raise_error
-    end
-  end
-
-  describe '#fill_pattern' do
-    it 'accepts an Image argument' do
-      img = Magick::Image.new(20,20)
-      expect { draw.fill_pattern = img }.not_to raise_error
-    end
-
-    it 'accepts an ImageList argument' do
-      img = Magick::Image.new(20,20)
-      ilist = Magick::ImageList.new
-      ilist << img
-      expect { draw.fill_pattern = ilist }.not_to raise_error
-    end
-
-    it 'does not accept arbitrary arguments' do
-      expect { draw.fill_pattern = 1 }.to raise_error(NoMethodError)
-    end
-  end
-
-  describe '#stroke_pattern' do
-    it 'accepts an Image argument' do
-      img = Magick::Image.new(20,20)
-      expect { draw.stroke_pattern = img }.not_to raise_error
-    end
-
-    it 'accepts an ImageList argument' do
-      img = Magick::Image.new(20,20)
-      ilist = Magick::ImageList.new
-      ilist << img
-      expect { draw.stroke_pattern = ilist }.not_to raise_error
-    end
-
-    it 'does not accept arbitrary arguments' do
-      expect { draw.stroke_pattern = 1 }.to raise_error(NoMethodError)
-    end
-  end
-end

data/spec/rmagick/image/blue_shift_spec.rb

@@ -1,16 +0,0 @@
-RSpec.describe Magick::Image, '#blue_shift' do
-
-  let(:img) { Magick::Image.read(IMAGES_DIR+'/Button_0.gif').first }
-
-  it 'returns a new Image' do
-    res = img.blue_shift
-    expect(res).to be_instance_of(Magick::Image)
-    expect(res).not_to eq img
-  end
-
-  it 'accepts one argument' do
-    expect { img.blue_shift(2) }.not_to raise_error
-    expect { img.blue_shift(2, 3) }.to raise_error(ArgumentError)
-  end
-
-end

data/spec/rmagick/image/composite_spec.rb

@@ -1,140 +0,0 @@
-RSpec.describe Magick::Image, '#composite' do
-
-  let(:img1) { Magick::Image.read(IMAGES_DIR+'/Button_0.gif').first }
-  let(:img2) { Magick::Image.read(IMAGES_DIR+'/Button_1.gif').first }
-  let(:composite_ops) do
-    [
-      Magick::UndefinedCompositeOp,
-      Magick::NoCompositeOp,
-      Magick::AddCompositeOp,
-      Magick::AtopCompositeOp,
-      Magick::BumpmapCompositeOp,
-      Magick::ClearCompositeOp,
-      Magick::ColorizeCompositeOp,
-      Magick::CopyBlueCompositeOp,
-      Magick::CopyCompositeOp,
-      Magick::CopyGreenCompositeOp,
-      Magick::CopyOpacityCompositeOp,
-      Magick::CopyRedCompositeOp,
-      Magick::CopyCyanCompositeOp,
-      Magick::CopyMagentaCompositeOp,
-      Magick::CopyYellowCompositeOp,
-      Magick::CopyBlackCompositeOp,
-      Magick::DarkenCompositeOp,
-      Magick::DifferenceCompositeOp,
-      Magick::DisplaceCompositeOp,
-      Magick::DissolveCompositeOp,
-      Magick::DstAtopCompositeOp,
-      Magick::DstCompositeOp,
-      Magick::DstInCompositeOp,
-      Magick::DstOutCompositeOp,
-      Magick::DstOverCompositeOp,
-      Magick::HueCompositeOp,
-      Magick::InCompositeOp,
-      Magick::LightenCompositeOp,
-      Magick::LuminizeCompositeOp,
-      Magick::MinusCompositeOp,
-      Magick::ModulateCompositeOp,
-      Magick::MultiplyCompositeOp,
-      Magick::OutCompositeOp,
-      Magick::OverCompositeOp,
-      Magick::OverlayCompositeOp,
-      Magick::PlusCompositeOp,
-      Magick::ReplaceCompositeOp,
-      Magick::SaturateCompositeOp,
-      Magick::ScreenCompositeOp,
-      Magick::SrcAtopCompositeOp,
-      Magick::SrcCompositeOp,
-      Magick::SrcInCompositeOp,
-      Magick::SrcOutCompositeOp,
-      Magick::SrcOverCompositeOp,
-      Magick::SubtractCompositeOp,
-      Magick::ThresholdCompositeOp,
-      Magick::XorCompositeOp,
-      Magick::BlendCompositeOp,
-      Magick::ColorBurnCompositeOp,
-      Magick::ColorDodgeCompositeOp,
-      Magick::ExclusionCompositeOp,
-      Magick::HardLightCompositeOp,
-      Magick::SoftLightCompositeOp
-    ]
-  end
-  let(:gravity) do
-    [
-      Magick::NorthEastGravity,
-      Magick::EastGravity,
-      Magick::SouthWestGravity,
-      Magick::SouthGravity,
-      Magick::SouthEastGravity
-    ]
-  end
-
-  it 'raises an error given invalid arguments' do
-    expect { img1.composite }.to raise_error(ArgumentError)
-    expect { img1.composite(img2) }.to raise_error(ArgumentError)
-    expect do
-      img1.composite(img2, Magick::NorthWestGravity)
-    end.to raise_error(ArgumentError)
-    expect { img1.composite(2) }.to raise_error(ArgumentError)
-    expect { img1.composite(img2, 2) }.to raise_error(ArgumentError)
-  end
-
-  context 'when given 3 arguments' do
-    it 'works when 2nd argument is a gravity' do
-      composite_ops.each do |op|
-        gravity.each do |grav|
-          expect { img1.composite(img2, grav, op) }.not_to raise_error
-        end
-      end
-    end
-
-    it 'raises an error when 2nd argument is not a gravity' do
-      expect do
-        img1.composite(img2, 2, Magick::OverCompositeOp)
-      end.to raise_error(TypeError)
-    end
-  end
-
-  context 'when given 4 arguments' do
-    it 'works when 4th argument is a composite operator' do
-      # there are way too many CompositeOperators to test them all, so just try
-      # few representative ops
-      composite_ops.each do |op|
-        expect { img1.composite(img2, 0, 0, op) }.not_to raise_error
-      end
-    end
-
-    it 'returns a new Magick::Image object' do
-      res = img1.composite(img2, 0, 0, Magick::OverCompositeOp)
-      expect(res).to be_instance_of(Magick::Image)
-    end
-
-    it 'raises an error when 4th argument is not a composite operator' do
-      expect { img1.composite(img2, 0, 0, 2) }.to raise_error(TypeError)
-    end
-  end
-
-  context 'when given 5 arguments' do
-    it 'works when 2nd argument is gravity and 5th is a composite operator' do
-      composite_ops.each do |op|
-        gravity.each do |grav|
-          expect { img1.composite(img2, grav, 0, 0, op) }.not_to raise_error
-        end
-      end
-    end
-
-    it 'raises an error when 2nd argument is not a gravity' do
-      expect do
-        img1.composite(img2, 0, 0, 2, Magick::OverCompositeOp)
-      end.to raise_error(TypeError)
-    end
-  end
-
-  it 'raises an error when the image has been destroyed' do
-    img2.destroy!
-    expect do
-      img1.composite(img2, Magick::CenterGravity, Magick::OverCompositeOp)
-    end.to raise_error(Magick::DestroyedImageError)
-  end
-
-end

data/spec/rmagick/image/constitute_spec.rb

@@ -1,15 +0,0 @@
-RSpec.describe Magick::Image, '#constitute' do
-
-  let(:img) { Magick::Image.read(IMAGES_DIR+'/Button_0.gif').first }
-  let(:pixels) { img.dispatch(0, 0, img.columns, img.rows, 'RGBA') }
-
-  it 'returns an equivalent image to the given pixels' do
-    res = Magick::Image.constitute(img.columns, img.rows, 'RGBA', pixels)
-    # The constituted image is in MIFF format so we
-    # can't compare it directly to the original image.
-    expect(res.columns).to eq img.columns
-    expect(res.rows).to eq img.rows
-    expect(pixels.all? { |v| 0 <= v && v <= Magick::QuantumRange }).to be true
-  end
-
-end

data/spec/rmagick/image/dispatch_spec.rb

@@ -1,18 +0,0 @@
-RSpec.describe Magick::Image, '#dispatch' do
-
-  let(:img) { Magick::Image.read(IMAGES_DIR+'/Button_0.gif').first }
-
-  it 'expects exactly 5 or 6 arguments' do
-    expect { img.dispatch }.to raise_error(ArgumentError)
-    expect { img.dispatch(0) }.to raise_error(ArgumentError)
-    expect { img.dispatch(0, 0) }.to raise_error(ArgumentError)
-    expect { img.dispatch(0, 0, img.columns) }.to raise_error(ArgumentError)
-    expect do
-      img.dispatch(0, 0, img.columns, img.rows)
-    end.to raise_error(ArgumentError)
-    expect do
-      img.dispatch(0, 0, 20, 20, 'RGBA', false, false)
-    end.to raise_error(ArgumentError)
-  end
-
-end

data/spec/rmagick/image/from_blob_spec.rb

@@ -1,14 +0,0 @@
-RSpec.describe Magick::Image, '#from_blob' do
-
-  let(:img) { Magick::Image.read(IMAGES_DIR+'/Button_0.gif').first }
-  let(:blob) { img.to_blob }
-
-  it 'returns an image equal to the original' do
-    expect(blob).to be_instance_of(String)
-    res = Magick::Image.from_blob(blob)
-    expect(res).to be_instance_of(Array)
-    expect(res.first).to be_instance_of(Magick::Image)
-    expect(res.first).to eq img
-  end
-
-end

data/spec/rmagick/image/ping_spec.rb

@@ -1,14 +0,0 @@
-RSpec.describe Magick::Image, '#ping' do
-
-  it 'returns an image from the source, omitting pixel data' do
-    res = Magick::Image.ping(IMAGES_DIR+'/Button_0.gif')
-    expect(res).to be_instance_of(Array)
-    image = res.first
-    expect(image).to be_instance_of(Magick::Image)
-    expect(image.format).to eq 'GIF'
-    expect(image.columns).to eq 127
-    expect(image.rows).to eq 120
-    expect(image.filename).to match(/Button_0.gif/)
-  end
-
-end

data/spec/rmagick/image/properties_spec.rb

@@ -1,29 +0,0 @@
-RSpec.describe Magick::Image, '#properties' do
-
-  let(:img) { Magick::Image.new(20, 20) }
-  let(:freeze_error) { RUBY_VERSION[/^1\.9|^2/] ? RuntimeError : TypeError }
-
-  before(:each) do
-    img['a'] = 'str_1'
-    img['b'] = 'str_2'
-    img['c'] = 'str_3'
-  end
-
-  it 'allows assignment of arbitrary properties' do
-    expect(img['a']).to eq 'str_1'
-    expect(img['b']).to eq 'str_2'
-    expect(img['c']).to eq 'str_3'
-    expect(img['d']).to be nil
-  end
-
-  it 'returns a hash of assigned properties' do
-    expected_properties = { 'a' => 'str_1', 'b' => 'str_2', 'c' => 'str_3' }
-    expect(img.properties).to eq(expected_properties)
-  end
-
-  it 'raises an error when trying to assign properties to a frozen image' do
-    img.freeze
-    expect { img['d'] = 'str_4' }.to raise_error(freeze_error)
-  end
-
-end

data/spec/spec_helper.rb

@@ -1,4 +0,0 @@
-require 'rmagick'
-
-root_dir = File.expand_path('../..', __FILE__)
-IMAGES_DIR = File.join(root_dir, 'doc/ex/images')