#!/usr/local/bin/ruby -w
#
# Simple demo program for RMagick
#
# Concept and algorithms lifted from Magick++ demo script written
# by Bob Friesenhahn.
#
require 'RMagick'
include Magick

#
#   RMagick version of Magick++/demo/demo.cpp
#

Font = "Helvetica"

begin
    puts "Read images..."

    model = ImageList.new("images/model.miff")
    model.border_color = "black"
    model.background_color = "black"
    model.cur_image[:Label] = "RMagick"

    smile = ImageList.new("images/smile.miff")
    smile.border_color = "black"
    smile.cur_image[:Label] = "Smile"

    #
    #   Create image stack
    #
    puts "Creating thumbnails"

    # Construct an initial list containing five copies of a null
    # image. This will give us room to fit the logo at the top.
    # Notice I specify the width and height of the images via the
    # optional "size" attribute in the parm block associated with
    # the read method. There are two more examples of this, below.
    example = ImageList.new
    5.times { example.read("NULL:black") { self.size = "70x70"} }

    puts "   add noise..."
    example << model.add_noise(LaplacianNoise)
    example.cur_image[:Label] = "Add Noise"

    puts "   annotate..."
    example << model.cur_image.copy
    example.cur_image[:Label] = "Annotate"
    draw = Draw.new
    draw.annotate(example, 0, 0, 0, 20, "RMagick") {
        self.pointsize = 18;
        self.font = Font;
        self.stroke = "gold"
        self.fill = "gold"
        self.gravity = NorthGravity
        }

    puts "   blur..."
    example << model.blur_image(0.0, 1.5)
    example.cur_image[:Label] = "Blur"

    puts "   border..."
    example << model.border(6, 6, "gold")
    example.cur_image[:Label] = "Border"

    puts "   channel..."
    example << model.channel(RedChannel)
    example.cur_image[:Label] = "Channel"

    puts "   charcoal..."
    example << model.charcoal
    example.cur_image[:Label] = "Charcoal"

    puts "   composite..."
    example << model.composite(smile, 35, 65, OverCompositeOp)
    example.cur_image[:Label] = "Composite"

    puts "   contrast..."
    example << model.contrast(false)
    example.cur_image[:Label] = "Contrast"

    puts "   convolve..."
    kernel = [ 1, 1, 1, 1, 4, 1, 1, 1, 1 ]
    example << model.convolve(3, kernel)
    example.cur_image[:Label] = "Convolve"

    puts "   crop..."
    example << model.crop(25, 50, 80, 80)
    example.cur_image[:Label] = "Crop"

    puts "   despeckle..."
    example << model.despeckle
    example.cur_image[:Label] = "Despeckle"

    puts "   draw..."
    example << model.cur_image.copy
    example.cur_image[:Label] = "Draw"
    gc = Draw.new
    gc.fill "black"
    gc.fill_opacity 0
    gc.stroke "gold"
    gc.stroke_width 2
    gc.circle 60,90, 60,120
    gc.draw(example)

    puts "   edge..."
    example << model.edge(0)
    example.cur_image[:Label] = "Detect Edges"

    puts "   emboss..."
    example << model.emboss
    example.cur_image[:Label] = "Emboss"

    puts "   equalize..."
    example << model.equalize
    example.cur_image[:Label] = "Equalize"

    puts "   explode..."
    example << model.implode(-1)
    example.background_color = "#000000ff"
    example.cur_image[:Label] = "Explode"

    puts "   flip..."
    example << model.flip
    example.cur_image[:Label] = "Flip"

    puts "   flop..."
    example << model.flop
    example.cur_image[:Label] = "Flop"

    puts "   frame..."
    example << model.frame
    example.cur_image[:Label] = "Frame"

    puts "   gamma..."
    example << model.gamma_correct(1.6)
    example.cur_image[:Label] = "Gamma"

    puts "   gaussian blur..."
    example << model.gaussian_blur(1, 1.5)
    example.cur_image[:Label] = "Gaussian Blur"

    # To add an Image in one of ImageMagick's built-in formats,
    # call the read method. The filename specifies the format and
    # any parameters it needs. The gradient format can be created in
    # any size. Specify the desired size by assigning it, in the form
    # "WxH", to the optional "size" attribute in the block associated
    # with the read method. Here we create a gradient image that is
    # the same size as the model image.
    puts "   gradient..."
    example.read("gradient:#20a0ff-#ffff00") {
        self.size = Geometry.new(model.columns, model.rows)
        }
    example.cur_image[:Label] = "Gradient"

    puts "   grayscale..."
    example << model.cur_image.quantize(256, GRAYColorspace)
    example.cur_image[:Label] = "Grayscale"

    puts "   implode..."
    example << model.implode(0.5)
    example.cur_image[:Label] = "Implode"

    puts "   median filter..."
    example << model.median_filter(0)
    example.cur_image[:Label] = "Median Filter"

    puts "   modulate..."
    example << model.modulate(1.10, 1.10, 1.10)
    example.cur_image[:Label] = "Modulate"

    puts "   monochrome..."
    example << model.cur_image.quantize(2, GRAYColorspace, false)
    example.cur_image[:Label] = "Monochrome"

    puts "   negate..."
    example << model.negate
    example.cur_image[:Label] = "Negate"

    puts "   normalize..."
    example << model.normalize
    example.cur_image[:Label] = "Normalize"

    puts "   oil paint..."
    example << model.oil_paint(3.0)
    example.cur_image[:Label] = "Oil Paint"

    # The plasma format is very similar to the gradient format, above.
    puts "   plasma..."
    example.read("plasma:fractal") {
        self.size = Geometry.new(model.columns, model.rows)
        }
    example.cur_image[:Label] = "Plasma"

    puts "   quantize..."
    example << model.cur_image.quantize
    example.cur_image[:Label] = "Quantize"

    puts "   raise..."
    example << model.raise
    example.cur_image[:Label] = "Raise"

    puts "   reduce noise..."
    example << model.reduce_noise(3.0)
    example.cur_image[:Label] = "Reduce Noise"

    puts "   resize..."
    example << model.resize(0.50)
    example.cur_image[:Label] = "Resize"

    puts "   roll..."
    example << model.roll(20, 10)
    example.cur_image[:Label] = "Roll"

    puts "   rotate..."
    example << model.rotate(45).transparent("black")
    example.cur_image[:Label] = "Rotate"

    puts "   scale..."
    example << model.scale(0.60)
    example.cur_image[:Label] = "Scale"

    puts "   segment..."
    example << model.segment
    example.cur_image[:Label] = "Segment"

    puts "   shade..."
    example << model.shade(false, 30, 30)
    example.cur_image[:Label] = "Shade"

    puts "   sharpen..."
    example << model.sharpen(0.0, 1.0)
    example.cur_image[:Label] = "Sharpen"

    puts "   shave..."
    example << model.shave(10, 10)
    example.cur_image[:Label] = "Shave"

    puts "   shear..."
    example << model.shear(45, 45).transparent("black")
    example.cur_image[:Label] = "Shear"

    puts "   spread..."
    example << model.spread(3)
    example.cur_image[:Label] = "Spread"

    puts "   solarize..."
    example << model.solarize(50.0)
    example.cur_image[:Label] = "Solarize"

    puts "   swirl..."
    temp = model.copy
    temp.background_color = "#000000ff"
    example << temp.swirl(90)
    example.cur_image[:Label] = "Swirl"

    puts "   unsharp mask..."
    example << model.unsharp_mask(0.0, 1.0, 1.0, 0.05)
    example.cur_image[:Label] = "Unsharp Mask"

    puts "   wave..."
    temp = model.copy
    temp.cur_image[:Label] = "Wave"
    temp.matte = true
    temp.background_color = "#000000ff"
    example << temp.wave(25, 150)

    #
    #   Create image montage - notice the optional
    #   montage parameters are supplied via a block
    #

    puts "Montage images..."

    montage = example.montage {
        self.geometry = "130x194+10+5>"
        self.gravity = CenterGravity
        self.border_width = 1
        rows = (example.size + 4) / 5
        self.tile = Geometry.new(5,rows)
        self.compose = OverCompositeOp

        # Use the ImageMagick built-in "granite" format
        # as the background texture.

#       self.texture = Image.read("granite:").first
        self.background_color = "white"
        self.font = Font;
        self.pointsize = 18;
        self.fill = "#600"
        self.filename = "RMagick Demo"
#       self.shadow = true
#       self.frame = "20x20+4+4"
    }

    # Add the ImageMagick logo to the top of the montage. The "logo:"
    # format is a fixed-size image, so I don't need to specify a size.
    puts "Adding logo image..."
    logo = Image.read("logo:").first
    if /GraphicsMagick/.match Magick_version then
        logo.resize!(200.0/logo.rows)
    else
        logo.crop!(98, 0, 461, 455).resize!(0.45)
    end

    # Create a new Image for the composited montage and logo
    montage_image = ImageList.new
    montage_image << montage.composite(logo, 245, 0, OverCompositeOp)

    # Write the result to a file
    montage_image.compression = RunlengthEncodedCompression
    montage_image.matte = false
    puts "Writing image ./rm_demo_out.miff"
    montage_image.write "rm_demo_out.miff"

    # Uncomment the following lines to display image to screen
    # puts "Displaying image..."
    # montage_image.display

rescue
    puts "Caught exception: #{$!}"
end

exit