rdp-rmagick 0.0.0

data/doc/ex/coalesce.rb

@@ -0,0 +1,60 @@
+#! /usr/local/bin/ruby -w
+require 'RMagick'
+
+buttons = Magick::ImageList.new
+
+# Read 25 alphabet image files, scale to 1/4 size
+letter = 'A'
+26.times {
+    if letter != 'M'            # "M" is not the same size as the other letters
+        tiny = Magick::Image.read('images/Button_' + letter + '.gif').first
+        tiny.scale! 0.25
+        buttons << tiny
+    end
+    letter.succ!
+    }
+
+# Create a image that will hold the alphabet images in 5 rows and 5 columns.
+cells = Magick::ImageList.new
+cells.new_image buttons.columns*5, buttons.rows*5 do
+    self.background_color = "#000000ff"     # transparent
+    end
+cells.matte = true
+
+offset = Magick::Rectangle.new(0,0,0,0)
+
+# Create 2 arrays from which we can randomly choose row,col pairs
+row = [0]*5 + [1]*5 + [2]*5 + [3]*5 + [4]*5
+col = (0..4).to_a * 5
+
+# The coalesce method composites the 2nd image over the 1st, the 3rd image
+# over the result, and so forth, respecting the page offset of the images.
+
+srand 1234
+25.times { |i|
+    # Randomly select a row and column for this copy of the "tinya" image.
+    # Compute the x,y position of this copy in pixels and store the
+    # result in the image's page attribute. Append a copy of the image
+    # to the image array in "a".
+    n = rand row.length
+    x = row.delete_at n
+    y = col.delete_at n
+
+    button = buttons[i]
+    offset.x = x*button.columns
+    offset.y = y*button.rows
+    button.page = offset
+    button.matte = true
+    cells << button
+    }
+
+puts "This may take a few seconds..."
+cells.delay = 10
+cells.iterations = 10000
+res = cells.coalesce
+res.write "coalesce_anim.gif"
+res[25].write "coalesce.gif"
+exit
+
+
+

data/doc/ex/color_fill_to_border.rb

@@ -0,0 +1,29 @@
+#! /usr/local/bin/ruby -w
+require 'RMagick'
+
+# Demonstrate the Image#color_fill_to_border method
+
+before = Magick::Image.new(200,200) {
+    self.background_color = 'white'
+    self.border_color = 'black'
+    }
+before.border!(1,1,'black')
+
+circle = Magick::Draw.new
+circle.fill('transparent')
+circle.stroke('black')
+circle.stroke_width(2)
+circle.circle(100,100,180,100)
+circle.fill('plum1')
+circle.stroke('transparent')
+circle.circle( 60,100, 40,100)
+circle.circle(140,100,120,100)
+circle.circle(100, 60,100, 40)
+circle.circle(100,140,100,120)
+circle.draw(before)
+
+before.write('color_fill_to_border_before.gif')
+
+after = before.color_fill_to_border(100,100, 'aquamarine')
+after.write('color_fill_to_border_after.gif')
+exit

data/doc/ex/color_floodfill.rb

@@ -0,0 +1,28 @@
+#! /usr/local/bin/ruby -w
+require 'RMagick'
+
+# Demonstrate the Image#color_floodfill method
+
+before = Magick::Image.new(200,200) { self.background_color = 'white' }
+before.border!(1,1,'black')
+
+circle = Magick::Draw.new
+circle.fill('transparent')
+circle.stroke_width(2)
+circle.stroke('black')
+circle.circle(100,100,180,100)
+circle.fill('plum1')
+circle.stroke('transparent')
+circle.circle( 60,100, 40,100)
+circle.circle(140,100,120,100)
+circle.circle(100, 60,100, 40)
+circle.circle(100,140,100,120)
+circle.draw(before)
+
+before.write('color_floodfill_before.gif')
+
+aquamarine = Magick::Pixel.from_color('aquamarine')
+after = before.color_floodfill(100,100, aquamarine)
+
+after.write('color_floodfill_after.gif')
+exit

data/doc/ex/color_histogram.rb

@@ -0,0 +1,48 @@
+#! /usr/local/bin/ruby -w
+
+require 'RMagick'
+
+NUM_COLORS = 256
+HIST_HEIGHT = 200
+
+img = Magick::Image.read('images/Hot_Air_Balloons_H.jpg').first
+img = img.quantize(NUM_COLORS)
+
+hist = img.color_histogram
+
+# sort pixels by increasing count
+pixels = hist.keys.sort_by {|pixel| hist[pixel] }
+
+scale = HIST_HEIGHT / (hist.values.max*1.025)   # put 2.5% air at the top
+
+gc = Magick::Draw.new
+gc.stroke_width(1)
+gc.affine(1, 0, 0, -scale, 0, HIST_HEIGHT)
+
+# handle images with fewer than NUM_COLORS colors
+start = NUM_COLORS - img.number_colors
+
+pixels.each { |pixel|
+    gc.stroke(pixel.to_color)
+    gc.line(start, 0, start, hist[pixel])
+    start = start.succ
+}
+
+hatch = Magick::HatchFill.new("white", "gray95")
+canvas = Magick::Image.new(NUM_COLORS, HIST_HEIGHT, hatch)
+gc.draw(canvas)
+
+text = Magick::Draw.new
+text.annotate(canvas, 0, 0, 0, 20, "Color Frequency\nHistogram") {
+    self.pointsize = 10
+    self.gravity = Magick::NorthGravity
+    self.stroke = 'transparent'
+    }
+
+canvas.border!(1, 1, "white")
+canvas.border!(1, 1, "black")
+canvas.border!(3, 3, "white")
+canvas.write("color_histogram.gif")
+
+exit
+

data/doc/ex/color_reset.rb

@@ -0,0 +1,11 @@
+#! /usr/local/bin/ruby -w
+require 'RMagick'
+
+# Demonstrate the Image#color_reset! method
+
+f = Magick::Image.new(100,100) { self.background_color = 'white' }
+red = Magick::Pixel.from_color('red')
+f.color_reset!(red)
+#f.display
+f.write('color_reset.gif')
+exit

data/doc/ex/colorize.rb

@@ -0,0 +1,16 @@
+#!/usr/local/bin/ruby -w
+require 'RMagick'
+
+# Demonstrate the Image#colorize method by converting
+# a full-color image to "sepia-tone"
+
+img = Magick::Image.read('images/Flower_Hat.jpg').first
+
+# Convert the color image to monochrome
+mono = img.quantize(256, Magick::GRAYColorspace)
+
+# Colorize with a 30% blend of a brownish-orange color
+colorized = mono.colorize(0.30, 0.30, 0.30, '#cc9933')
+
+colorized.write('colorize.jpg')
+exit

data/doc/ex/colors.rb

@@ -0,0 +1,64 @@
+#! /usr/local/bin/ruby -w
+require 'RMagick'
+include Magick
+
+puts("Creating colors.miff. This may take a few seconds...")
+
+colors = ImageList.new
+
+# Add a row of "null" colors so we'll have
+# room to add the title at the top.
+4.times { colors.read('null:') }
+
+puts("\tCreating color swatches...")
+
+# Create a 200x25 image for each named color.
+# Label with the name, RGB values, and compliance type.
+colors { |c|
+    if c.name !~ /grey/ then    # omit SVG 'grays'
+        colors.new_image(200, 25) {
+            self.background_color = c.color
+            self.border_color = 'gray50'
+            }
+        rgb  = sprintf('#%02x%02x%02x', c.color.red&0xff,  c.color.green&0xff, c.color.blue&0xff)
+        rgb += sprintf('%02x', c.color.opacity&0xff) if c.color.opacity != 0
+        m = /(.*?)Compliance/.match c.compliance.to_s
+        colors.cur_image['Label'] = "#{c.name} (#{rgb}) #{m[1]}"
+    end
+}
+
+puts("\tCreating montage...")
+
+# Montage. Each image will have 40 tiles.
+# There will be 16 images.
+montage = colors.montage {
+    self.geometry = '200x25+10+5'
+    self.gravity = CenterGravity
+    self.tile = '4x10'
+    self.background_color = 'black'
+    self.border_width = 1
+    self.fill = 'white'
+    self.stroke = 'transparent'
+}
+
+# Add the title at the top, over the 'null:'
+# tiles we added at the very beginning.
+title = Draw.new
+title.annotate(montage, 0,0,0,20, 'Named Colors') {
+    self.fill = 'white'
+    self.stroke = 'transparent'
+    self.pointsize = 32
+    self.font_weight = BoldWeight
+    self.gravity = NorthGravity
+}
+
+puts("\tWriting ./colors.miff")
+montage.each { |f| f.compression = ZipCompression }
+montage.write('colors.miff')
+
+# Make a small sample of the full montage to display in the HTML file.
+sample = montage[8].crop(55, 325, 495, 110)
+sample.page = Rectangle.new(495,110)
+sample.write('colors.gif')
+
+exit

data/doc/ex/compose_mask.rb

@@ -0,0 +1,23 @@
+require 'RMagick'
+
+background = Magick::Image.read('images/Flower_Hat.jpg').first
+source = Magick::Image.read('pattern:checkerboard') {self.size = "#{background.columns}x#{background.rows}"}.first
+mask = Magick::Image.new(background.columns, background.rows) {self.background_color = "black"}
+
+# Make a mask
+gc = Magick::Draw.new
+gc.annotate(mask, 0, 0, 0, 0, "Ruby") do
+  gc.gravity = Magick::CenterGravity
+  gc.pointsize = 100
+  gc.rotation = 90
+  gc.font_weight = Magick::BoldWeight
+  gc.fill = "white"
+  gc.stroke = "none"
+end
+
+background.add_compose_mask(mask)
+result = background.composite(source, Magick::CenterGravity, Magick::OverCompositeOp)
+result.write "compose_mask_example.jpg"
+source.write "compose_mask_source.gif"
+mask.write "compose_mask.gif"
+

data/doc/ex/composite.rb

@@ -0,0 +1,135 @@
+#! /usr/local/bin/ruby -w
+
+# Demonstrate the effects of various composite operators.
+# Based on ImageMagick's composite test.
+
+require 'RMagick'
+include Magick
+
+ROWS = 70
+COLS = 70
+COLOR_A = "#999966"
+COLOR_B = "#990066"
+
+img = Image.new(COLS, ROWS)
+triangle = Draw.new
+triangle.fill(COLOR_A)
+triangle.stroke('transparent')
+triangle.polygon(0,0, COLS,0, 0,ROWS, 0,0)
+triangle.draw(img)
+image_A = img.transparent('white', TransparentOpacity)
+image_A['Label'] = 'A'
+
+img = Image.new(COLS, ROWS)
+triangle = Draw.new
+triangle.fill(COLOR_B)
+triangle.stroke('transparent')
+triangle.polygon(0,0, COLS,ROWS, COLS,0, 0,0)
+triangle.draw(img)
+image_B = img.transparent('white', TransparentOpacity)
+image_B['Label'] = 'B'
+
+list = ImageList.new
+null = Image.read("xc:white") { self.size = Geometry.new(COLS,ROWS) }
+null = null.first.transparent('white', TransparentOpacity)
+null.border_color = 'transparent'
+granite =  Image.read("granite:")
+
+list << null.copy
+list << image_A
+list << image_B
+list << null.copy
+
+
+list << image_B.composite(image_A, CenterGravity, OverCompositeOp)
+list.cur_image['Label'] = 'A over B'
+list << image_A.composite(image_B, CenterGravity, OverCompositeOp)
+list.cur_image['Label'] = 'B over A'
+
+list << image_B.composite(image_A, CenterGravity, InCompositeOp)
+list.cur_image['Label'] = 'A in B'
+list << image_A.composite(image_B, CenterGravity, InCompositeOp)
+list.cur_image['Label'] = 'B in A'
+
+list << image_B.composite(image_A, CenterGravity, OutCompositeOp)
+list.cur_image['Label'] = 'A out B'
+list << image_A.composite(image_B, CenterGravity, OutCompositeOp)
+list.cur_image['Label'] = 'B out A'
+
+list << image_B.composite(image_A, CenterGravity, AtopCompositeOp)
+list.cur_image['Label'] = 'A atop B'
+list << image_A.composite(image_B, CenterGravity, AtopCompositeOp)
+list.cur_image['Label'] = 'B atop A'
+
+list << image_B.composite(image_A, CenterGravity, XorCompositeOp)
+list.cur_image['Label'] = 'A xor B'
+
+list << image_B.composite(image_A, CenterGravity, MultiplyCompositeOp)
+list.cur_image['Label'] = 'A multiply B'
+
+list << image_B.composite(image_A, CenterGravity, ScreenCompositeOp)
+list.cur_image['Label'] = 'A screen B'
+
+list << image_B.composite(image_A, CenterGravity, DarkenCompositeOp)
+list.cur_image['Label'] = 'A darken B'
+
+list << image_B.composite(image_A, CenterGravity, LightenCompositeOp)
+list.cur_image['Label'] = 'A lighten B'
+
+list << image_B.composite(image_A, CenterGravity, PlusCompositeOp)
+list.cur_image['Label'] = 'A plus B'
+
+list << image_B.composite(image_A, CenterGravity, MinusCompositeOp)
+list.cur_image['Label'] = 'A minus B'
+
+list << image_B.composite(image_A, CenterGravity, AddCompositeOp)
+list.cur_image['Label'] = 'A add B'
+
+list << image_B.composite(image_A, CenterGravity, SubtractCompositeOp)
+list.cur_image['Label'] = 'A subtract B'
+
+list << image_B.composite(image_A, CenterGravity, DifferenceCompositeOp)
+list.cur_image['Label'] = 'A difference B'
+
+list << image_B.composite(image_A, CenterGravity, HueCompositeOp)
+list.cur_image['Label'] = 'A hue B'
+
+list << image_B.composite(image_A, CenterGravity, SaturateCompositeOp)
+list.cur_image['Label'] = 'A saturate B'
+
+list << image_B.composite(image_A, CenterGravity, LuminizeCompositeOp)
+list.cur_image['Label'] = 'A luminize B'
+
+list << image_B.composite(image_A, CenterGravity, ColorizeCompositeOp)
+list.cur_image['Label'] = 'A colorize B'
+
+list << image_B.composite(image_A, CenterGravity, BumpmapCompositeOp)
+list.cur_image['Label'] = 'A bumpmap B'
+
+list << image_B.composite(image_A, CenterGravity, DissolveCompositeOp)
+list.cur_image['Label'] = 'A dissolve B'
+
+list << image_B.composite(image_A, CenterGravity, ThresholdCompositeOp)
+list.cur_image['Label'] = 'A threshold B'
+
+list << image_B.composite(image_A, CenterGravity, ModulateCompositeOp)
+list.cur_image['Label'] = 'A modulate B'
+
+list << image_A.composite(image_B, CenterGravity, ModulateCompositeOp)
+list.cur_image['Label'] = 'B modulate A'
+
+list << image_B.composite(image_A, CenterGravity, OverlayCompositeOp)
+list.cur_image['Label'] = 'A overlay B'
+
+montage = list.montage {
+    self.geometry = Geometry.new(COLS, ROWS, 3, 3)
+    rows = (list.size+3) / 4
+    self.tile = Geometry.new(4, rows)
+    self.texture = granite[0]
+    self.fill = 'white'
+    self.stroke = 'transparent'
+}
+
+montage.write('composite.gif')
+exit
+

data/doc/ex/composite_layers.rb

@@ -0,0 +1,53 @@
+#! /usr/local/bin/ruby -w
+require 'RMagick'
+
+class Magick::ImageList
+  # Create a shadow image for each image in the list
+  def shadow(x_offset = 4, y_offset = 4, sigma = 4.0, opacity = 1.0)
+    return collect { |frame| frame.shadow(x_offset, y_offset, sigma, opacity) }
+  end
+end
+
+ruby = Magick::ImageList.new
+
+# Draw a rotating "Ruby" animation
+gc = Magick::Draw.new
+gc.gravity = Magick::CenterGravity
+gc.pointsize = 24
+gc.font_weight = Magick::BoldWeight
+gc.fill = "darkred"
+gc.stroke = "black"
+gc.stroke_width = 1
+
+23.times do
+  ruby << Magick::Image.new(100, 100) {self.background_color = "none"}
+  gc.annotate(ruby, 0, 0, 0, 0, "Ruby")
+  gc.rotation = 15
+end
+
+# Create a gradient background
+bg = Magick::ImageList.new
+bg.new_image(99, 99, Magick::GradientFill.new(50, 50, 50, 50, "white", "tan"))
+bg.border!(1, 1, "black")
+
+# Create the animated shadows of the rotating "Ruby" animation
+shadows = ruby.shadow(2, 5, 3)
+
+# Composite the shadow animation over the background. Since there is only one
+# background image, it will replicated for each frame in the shadow animation.
+begin
+  result = bg.composite_layers(shadows)
+
+  # Composite the "Ruby" animation over the previous composite
+  result = result.composite_layers(ruby)
+  result.delay = 10
+  result.write("composite_layers.gif")
+  result[0].write("composite_layers1.gif")
+
+rescue NotImplementedError
+    result = Magick::Image.read('images/notimplemented.gif').first
+    result.resize!(100, 100)
+    result.write("composite_layers.gif")
+    result.write("composite_layers1.gif")
+end
+exit