rmagick 2.13.2 → 4.2.2

data/examples/histogram.rb

@@ -1,325 +0,0 @@
-# This routine needs the color_histogram method
-# from either ImageMagick 6.0.0 or GraphicsMagick 1.1
-# Specify an image filename as an argument.
-
-require 'RMagick'
-
-class PixelColumn < Array
-    def initialize(size)
-        super
-        fill {Magick::Pixel.new}
-    end
-
-    def reset(bg)
-        each {|pixel| pixel.reset(bg)}
-    end
-end
-
-module Magick
-
-    class Pixel
-        def reset(bg)
-            self.red = bg.red
-            self.green = bg.green
-            self.blue = bg.blue
-            self.opacity = bg.opacity
-        end
-    end
-
-    class Image
-
-      private
-        HISTOGRAM_COLS = 256
-        HISTOGRAM_ROWS = 200
-        MAX_QUANTUM = 255
-        AIR_FACTOR = 1.025
-
-        # The alpha frequencies are shown as white dots.
-        def alpha_hist(freqs, scale, fg, bg)
-            histogram = Image.new(HISTOGRAM_COLS, HISTOGRAM_ROWS) {
-                self.background_color = bg
-                self.border_color = fg
-            }
-
-            gc = Draw.new
-            gc.affine(1, 0, 0, -scale, 0, HISTOGRAM_ROWS)
-            gc.fill('white')
-
-            HISTOGRAM_COLS.times do |x|
-                gc.point(x, freqs[x])
-            end
-
-            gc.draw(histogram)
-            histogram['Label'] = 'Alpha'
-
-            return histogram
-        end
-
-        def channel_histograms(red, green, blue, int, scale, fg, bg)
-            rgb_histogram = Image.new(HISTOGRAM_COLS, HISTOGRAM_ROWS) {
-                self.background_color = bg
-                self.border_color = fg
-            }
-            rgb_histogram['Label'] = 'RGB'
-            red_histogram   = rgb_histogram.copy
-            red_histogram['Label'] = 'Red'
-            green_histogram = rgb_histogram.copy
-            green_histogram['Label'] = 'Green'
-            blue_histogram  = rgb_histogram.copy
-            blue_histogram['Label'] = 'Blue'
-            int_histogram = rgb_histogram.copy
-            int_histogram['Label'] = 'Intensity'
-            int_histogram.matte = true
-
-            rgb_column   = PixelColumn.new(HISTOGRAM_ROWS)
-            red_column   = PixelColumn.new(HISTOGRAM_ROWS)
-            green_column = PixelColumn.new(HISTOGRAM_ROWS)
-            blue_column  = PixelColumn.new(HISTOGRAM_ROWS)
-            int_column   = PixelColumn.new(HISTOGRAM_ROWS)
-
-            HISTOGRAM_COLS.times do |x|
-                HISTOGRAM_ROWS.times do |y|
-
-                    yf = Float(y)
-                    if yf >= HISTOGRAM_ROWS - (red[x] * scale)
-                        red_column[y].red = QuantumRange
-                        red_column[y].green = 0
-                        red_column[y].blue = 0
-                        rgb_column[y].red = QuantumRange
-                    end
-                    if yf >= HISTOGRAM_ROWS - (green[x] * scale)
-                        green_column[y].green = QuantumRange
-                        green_column[y].red = 0
-                        green_column[y].blue = 0
-                        rgb_column[y].green = QuantumRange
-                    end
-                    if yf >= HISTOGRAM_ROWS - (blue[x] * scale)
-                        blue_column[y].blue = QuantumRange
-                        blue_column[y].red = 0
-                        blue_column[y].green = 0
-                        rgb_column[y].blue = QuantumRange
-                    end
-                    if yf >= HISTOGRAM_ROWS - (int[x] * scale)
-                        int_column[y].opacity = TransparentOpacity
-                    end
-                end
-
-                rgb_histogram.store_pixels(  x, 0, 1, HISTOGRAM_ROWS, rgb_column)
-                red_histogram.store_pixels(  x, 0, 1, HISTOGRAM_ROWS, red_column)
-                green_histogram.store_pixels(x, 0, 1, HISTOGRAM_ROWS, green_column)
-                blue_histogram.store_pixels( x, 0, 1, HISTOGRAM_ROWS, blue_column)
-                int_histogram.store_pixels(  x, 0, 1, HISTOGRAM_ROWS, int_column)
-                rgb_column.reset(bg)
-                red_column.reset(bg)
-                green_column.reset(bg)
-                blue_column.reset(bg)
-                int_column.reset(bg)
-            end
-
-           return red_histogram, green_histogram, blue_histogram, rgb_histogram, int_histogram
-        end
-
-        # Make the color histogram. Quantize the image to 256 colors if necessary.
-        def color_hist(fg, bg)
-            img = number_colors > 256 ? quantize(256) : self
-
-            begin
-                hist = img.color_histogram
-            rescue NotImplementedError
-                $stderr.puts "The color_histogram method is not supported by this version "+
-                             "of ImageMagick/GraphicsMagick"
-
-            else
-                pixels = hist.keys.sort_by {|pixel| hist[pixel] }
-                scale = HISTOGRAM_ROWS / (hist.values.max*AIR_FACTOR)
-
-                histogram = Image.new(HISTOGRAM_COLS, HISTOGRAM_ROWS) {
-                    self.background_color = bg
-                    self.border_color = fg
-                    }
-
-                x = 0
-                pixels.each do |pixel|
-                    column = Array.new(HISTOGRAM_ROWS).fill {Pixel.new}
-                    HISTOGRAM_ROWS.times do |y|
-                        if y >= HISTOGRAM_ROWS - (hist[pixel] * scale)
-                            column[y] = pixel;
-                        end
-                    end
-                    histogram.store_pixels(x, 0, 1, HISTOGRAM_ROWS, column)
-                    x = x.succ
-                end
-
-                histogram['Label'] = 'Color Frequency'
-                return histogram
-            end
-        end
-
-        # Use AnnotateImage to write the stats.
-        def info_text(fg, bg)
-            klass = class_type == DirectClass ? "DirectClass" : "PsuedoClass"
-
-            text = <<-END_TEXT
-Format: #{format}
-Geometry: #{columns}x#{rows}
-Class: #{klass}
-Depth: #{depth} bits-per-pixel component
-Colors: #{number_colors}
-            END_TEXT
-
-            info = Image.new(HISTOGRAM_COLS, HISTOGRAM_ROWS) {
-                self.background_color = bg
-                self.border_color = fg
-                }
-
-            gc = Draw.new
-
-            gc.annotate(info, 0, 0, 0, 0, text) {
-                self.stroke = 'transparent'
-                self.fill = fg
-                self.gravity = CenterGravity
-                }
-            info['Label'] = 'Info'
-
-            return info
-        end
-
-        def intensity_hist(int_histogram)
-
-            gradient = (Image.read("gradient:#ffff80-#ff9000") { self.size="#{HISTOGRAM_COLS}x#{HISTOGRAM_ROWS}" }).first
-            int_histogram = gradient.composite(int_histogram, CenterGravity, OverCompositeOp)
-
-            int_histogram['Label'] = 'Intensity'
-
-            return int_histogram
-        end
-
-        # Returns a value between 0 and MAX_QUANTUM. Same as the PixelIntensity macro.
-        def pixel_intensity(pixel)
-            (306*(pixel.red & MAX_QUANTUM) + 601*(pixel.green & MAX_QUANTUM) + 117*(pixel.blue & MAX_QUANTUM))/1024
-        end
-
-      public
-        # Create the histogram montage.
-        def histogram(fg='white', bg='black')
-
-            red   = Array.new(HISTOGRAM_COLS, 0)
-            green = Array.new(HISTOGRAM_COLS, 0)
-            blue  = Array.new(HISTOGRAM_COLS, 0)
-            alpha = Array.new(HISTOGRAM_COLS, 0)
-            int   = Array.new(HISTOGRAM_COLS, 0)
-
-            rows.times do |row|
-                pixels = get_pixels(0, row, columns, 1)
-                pixels.each do |pixel|
-                    red[pixel.red & MAX_QUANTUM] += 1
-                    green[pixel.green & MAX_QUANTUM] += 1
-                    blue[pixel.blue & MAX_QUANTUM] += 1
-
-                    # Only count opacity channel if some pixels are not opaque.
-                    if !opaque?
-                        alpha[pixel.opacity & MAX_QUANTUM] += 1
-                    end
-                    v = pixel_intensity(pixel)
-                    int[v] += 1
-                end
-            end
-
-            # Scale to chart size. When computing the scale, add some "air" between
-            # the max frequency and the top of the histogram. This makes a prettier chart.
-            # The RGBA and intensity histograms are all drawn to the same scale.
-
-            max = [red.max, green.max, blue.max, alpha.max, int.max].max
-            scale = HISTOGRAM_ROWS / (max*AIR_FACTOR)
-
-            charts = ImageList.new
-
-            # Add the thumbnail.
-            thumb = copy
-            thumb['Label'] = File.basename(filename)
-            charts << thumb
-
-            # Compute the channel and intensity histograms.
-            channel_hists = channel_histograms(red, green, blue, int, scale, fg, bg)
-
-            # Add the red, green, and blue histograms to the list
-            charts << channel_hists.shift
-            charts << channel_hists.shift
-            charts << channel_hists.shift
-
-            # Add Alpha channel or image stats
-            if !opaque?
-                charts << alpha_hist(alpha, scale, fg, bg)
-            else
-                charts << info_text(fg, bg)
-            end
-
-            # Add the RGB histogram
-            charts << channel_hists.shift
-
-            # Add the intensity histogram.
-            charts << intensity_hist(channel_hists.shift)
-
-            # Add the color frequency histogram.
-            charts << color_hist(fg, bg)
-
-            # Make a montage.
-            histogram = charts.montage {
-                self.background_color = bg
-                self.stroke = 'transparent'
-                self.fill = fg
-                self.border_width = 1
-                self.tile         = "4x2"
-                self.geometry     = "#{HISTOGRAM_COLS}x#{HISTOGRAM_ROWS}+10+10"
-            }
-
-            return histogram
-        end
-    end
-end
-
-puts <<END_INFO
-
-This example shows how to get pixel-level access to an image.
-Usage: histogram.rb <image-filename>
-
-END_INFO
-
-# Get filename from command line.
-if !ARGV[0] then
-    puts "No filename argument. Defaulting to Flower_Hat.jpg"
-    filename = '../doc/ex/images/Flower_Hat.jpg'
-else
-    filename = ARGV[0]
-end
-
-# Only process first frame if multi-frame image
-image = Magick::Image.read(filename)
-if image.length > 1
-    puts "Charting 1st image"
-end
-image = image.first
-
-# Give the user something to look at while we're working.
-name = File.basename(filename).sub(/\..*?$/,'')
-$defout.sync = true
-printf "Creating #{name}_Histogram.miff"
-
-timer = Thread.new do
-    loop do
-        sleep(1)
-        printf "."
-    end
-end
-
-# Generate the histograms
-histogram = image.histogram(Magick::Pixel.from_color('white'), Magick::Pixel.from_color('black'))
-
-# Write output file
-histogram.compression = Magick::ZipCompression
-histogram.write("./#{name}_Histogram.miff")
-
-Thread.kill(timer)
-puts "Done!"
-exit
-

data/examples/identify.rb

@@ -1,187 +0,0 @@
-require 'RMagick'
-
-module Magick
-    class Image
-
-        # Print information similar to the identify -verbose command
-        def identify
-            printf "Image: "
-            puts "#{base_filename}=>" if base_filename != filename
-            puts filename + "\n"
-            puts "\tFormat: #{format}\n"
-            puts "\tGeometry: #{columns}x#{rows}\n"
-            puts "\tClass: #{class_type.to_s}\n"
-            puts "\tType: #{image_type.to_s}\n"
-            puts "\tEndianess: #{endian}\n"
-            puts "\tColorspace: #{colorspace}\n"
-            puts "\tChannelDepth:\n"
-            color_space = gray? ? Magick::GrayColorspace : colorspace
-            case color_space
-            when Magick::RGBColorspace
-                puts "\t\tRed: #{channel_depth(Magick::RedChannel)}-bits\n"
-                puts "\t\tGreen: #{channel_depth(Magick::GreenChannel)}-bits\n"
-                puts "\t\tBlue: #{channel_depth(Magick::BlueChannel)}-bits\n"
-                puts "\t\tOpacity: #{channel_depth(Magick::OpacityChannel)}-bits\n" if matte
-            when Magick::CMYKColorspace
-                puts "\t\tCyan : #{channel_depth(Magick::CyanChannel)}-bits\n"
-                puts "\t\tMagenta: #{channel_depth(Magick::MagentaChannel)}-bits\n"
-                puts "\t\tYellow: #{channel_depth(Magick::YellowChannel)}-bits\n"
-                puts "\t\tBlack: #{channel_depth(Magick::BlackChannel)}-bits\n"
-                puts "\t\tOpacity: #{channel_depth(Magick::OpacityChannel)}-bits\n" if matte
-            when Magick::GrayColorspace
-                puts "\t\tGray: #{channel_depth(Magick::GrayChannel)}-bits\n"
-                puts "\t\tOpacity: #{channel_depth(Magick::OpacityChannel)}-bits\n" if matte
-            end
-            scale = Magick::QuantumRange / (Magick::QuantumRange >> (Magick::QuantumDepth-channel_depth))
-            puts "\tChannel statistics:\n"
-            case color_space
-            when Magick::RGBColorspace
-                puts "\t\tRed:\n"
-                puts "\t\t\tMin: " + sprintf("%u (%g)\n", channel_extrema(Magick::RedChannel)[0]/scale, channel_extrema(Magick::RedChannel)[0]/Magick::QuantumRange)
-                puts "\t\t\tMax: " + sprintf("%u (%g)\n", channel_extrema(Magick::RedChannel)[1]/scale, channel_extrema(Magick::RedChannel)[1]/Magick::QuantumRange)
-                puts "\t\t\tMean: " + sprintf("%g (%g)\n", channel_mean(Magick::RedChannel)[0]/scale, channel_mean(Magick::RedChannel)[0]/Magick::QuantumRange)
-                puts "\t\t\tStandard deviation: " + sprintf("%g (%g)\n", channel_mean(Magick::RedChannel)[1]/scale, channel_mean(Magick::RedChannel)[1]/Magick::QuantumRange)
-                puts "\t\tGreen:\n"
-                puts "\t\t\tMin: " + sprintf("%u (%g)\n", channel_extrema(Magick::GreenChannel)[0]/scale, channel_extrema(Magick::GreenChannel)[0]/Magick::QuantumRange)
-                puts "\t\t\tMax: " + sprintf("%u (%g)\n", channel_extrema(Magick::GreenChannel)[1]/scale, channel_extrema(Magick::GreenChannel)[1]/Magick::QuantumRange)
-                puts "\t\t\tMean: " + sprintf("%g (%g)\n", channel_mean(Magick::GreenChannel)[0]/scale, channel_mean(Magick::GreenChannel)[0]/Magick::QuantumRange)
-                puts "\t\t\tStandard deviation: " + sprintf("%g (%g)\n", channel_mean(Magick::GreenChannel)[1]/scale, channel_mean(Magick::GreenChannel)[1]/Magick::QuantumRange)
-                puts "\t\tBlue:\n"
-                puts "\t\t\tMin: " + sprintf("%u (%g)\n", channel_extrema(Magick::BlueChannel)[0]/scale, channel_extrema(Magick::BlueChannel)[0]/Magick::QuantumRange)
-                puts "\t\t\tMax: " + sprintf("%u (%g)\n", channel_extrema(Magick::BlueChannel)[1]/scale, channel_extrema(Magick::BlueChannel)[1]/Magick::QuantumRange)
-                puts "\t\t\tMean: " + sprintf("%g (%g)\n", channel_mean(Magick::BlueChannel)[0]/scale, channel_mean(Magick::BlueChannel)[0]/Magick::QuantumRange)
-                puts "\t\t\tStandard deviation: " + sprintf("%g (%g)\n", channel_mean(Magick::BlueChannel)[1]/scale, channel_mean(Magick::BlueChannel)[1]/Magick::QuantumRange)
-            when Magick::CMYKColorspace
-                puts "\t\tCyan:\n"
-                puts "\t\t\tMin: " + sprintf("%u (%g)\n", channel_extrema(Magick::CyanChannel)[0]/scale, channel_extrema(Magick::CyanChannel)[0]/Magick::QuantumRange)
-                puts "\t\t\tMax: " + sprintf("%u (%g)\n", channel_extrema(Magick::CyanChannel)[1]/scale, channel_extrema(Magick::CyanChannel)[1]/Magick::QuantumRange)
-                puts "\t\t\tMean: " + sprintf("%g (%g)\n", channel_mean(Magick::CyanChannel)[0]/scale, channel_mean(Magick::CyanChannel)[0]/Magick::QuantumRange)
-                puts "\t\t\tStandard deviation: " + sprintf("%g (%g)\n", channel_mean(Magick::CyanChannel)[1]/scale, channel_mean(Magick::CyanChannel)[1]/Magick::QuantumRange)
-                puts "\t\tMagenta:\n"
-                puts "\t\t\tMin: " + sprintf("%u (%g)\n", channel_extrema(Magick::MagentaChannel)[0]/scale, channel_extrema(Magick::MagentaChannel)[0]/Magick::QuantumRange)
-                puts "\t\t\tMax: " + sprintf("%u (%g)\n", channel_extrema(Magick::MagentaChannel)[1]/scale, channel_extrema(Magick::MagentaChannel)[1]/Magick::QuantumRange)
-                puts "\t\t\tMean: " + sprintf("%g (%g)\n", channel_mean(Magick::MagentaChannel)[0]/scale, channel_mean(Magick::MagentaChannel)[0]/Magick::QuantumRange)
-                puts "\t\t\tStandard deviation: " + sprintf("%g (%g)\n", channel_mean(Magick::MagentaChannel)[1]/scale, channel_mean(Magick::MagentaChannel)[1]/Magick::QuantumRange)
-                puts "\t\tYellow:\n"
-                puts "\t\t\tMin: " + sprintf("%u (%g)\n", channel_extrema(Magick::YellowChannel)[0]/scale, channel_extrema(Magick::YellowChannel)[0]/Magick::QuantumRange)
-                puts "\t\t\tMax: " + sprintf("%u (%g)\n", channel_extrema(Magick::YellowChannel)[1]/scale, channel_extrema(Magick::YellowChannel)[1]/Magick::QuantumRange)
-                puts "\t\t\tMean: " + sprintf("%g (%g)\n", channel_mean(Magick::YellowChannel)[0]/scale, channel_mean(Magick::YellowChannel)[0]/Magick::QuantumRange)
-                puts "\t\t\tStandard deviation: " + sprintf("%g (%g)\n", channel_mean(Magick::YellowChannel)[1]/scale, channel_mean(Magick::YellowChannel)[1]/Magick::QuantumRange)
-                puts "\t\tBlack:\n"
-                puts "\t\t\tMin: " + sprintf("%u (%g)\n", channel_extrema(Magick::BlackChannel)[0]/scale, channel_extrema(Magick::BlackChannel)[0]/Magick::QuantumRange)
-                puts "\t\t\tMax: " + sprintf("%u (%g)\n", channel_extrema(Magick::BlackChannel)[1]/scale, channel_extrema(Magick::BlackChannel)[1]/Magick::QuantumRange)
-                puts "\t\t\tMean: " + sprintf("%g (%g)\n", channel_mean(Magick::BlackChannel)[0]/scale, channel_mean(Magick::BlackChannel)[0]/Magick::QuantumRange)
-                puts "\t\t\tStandard deviation: " + sprintf("%g (%g)\n", channel_mean(Magick::BlackChannel)[1]/scale, channel_mean(Magick::BlackChannel)[1]/Magick::QuantumRange)
-            when Magick::GrayColorspace
-                puts "\t\tGray:\n"
-                puts "\t\t\tMin: " + sprintf("%u (%g)\n", channel_extrema(Magick::GrayChannel)[0]/scale, channel_extrema(Magick::GrayChannel)[0]/Magick::QuantumRange)
-                puts "\t\t\tMax: " + sprintf("%u (%g)\n", channel_extrema(Magick::GrayChannel)[1]/scale, channel_extrema(Magick::GrayChannel)[1]/Magick::QuantumRange)
-                puts "\t\t\tMean: " + sprintf("%g (%g)\n", channel_mean(Magick::GrayChannel)[0]/scale, channel_mean(Magick::GrayChannel)[0]/Magick::QuantumRange)
-                puts "\t\t\tStandard deviation: " + sprintf("%g (%g)\n", channel_mean(Magick::GrayChannel)[1]/scale, channel_mean(Magick::GrayChannel)[1]/Magick::QuantumRange)
-            end
-            if matte
-                puts "\t\tOpacity:\n"
-                puts "\t\t\tMin: " + sprintf("%u (%g)\n", channel_extrema(Magick::OpacityChannel)[0]/scale, channel_extrema(Magick::OpacityChannel)[0]/Magick::QuantumRange)
-                puts "\t\t\tMax: " + sprintf("%u (%g)\n", channel_extrema(Magick::OpacityChannel)[1]/scale, channel_extrema(Magick::OpacityChannel)[1]/Magick::QuantumRange)
-                puts "\t\t\tMean:" + sprintf("%u (%g)\n", channel_mean(Magick::OpacityChannel)[0]/scale, channel_mean(Magick::OpacityChannel)[0]/Magick::QuantumRange)
-                puts "\t\t\tStandard deviation:" + sprintf("%u (%g)\n", channel_mean(Magick::OpacityChannel)[1]/scale, channel_mean(Magick::OpacityChannel)[1]/Magick::QuantumRange)
-            end
-            if class_type == Magick::DirectClass
-                puts "\tColors: #{total_colors}\n"
-            else
-                if total_colors <= colors
-                    puts "\tColors: #{colors}\n"
-                else
-                    puts "\tColors: #{total_colors}=>#{colors}\n"
-                end
-            end
-            # Histogram goes here
-            puts "\tMean error per pixel: #{mean_error_per_pixel}\n" if mean_error_per_pixel != 0.0
-            puts "\tNormalized mean error: #{normalized_mean_error}\n" if normalized_mean_error != 0.0
-            puts "\tNormalized maximum error: #{normalized_maximum_error}\n" if normalized_maximum_error != 0.0
-            puts "\tRendering-intent: #{rendering_intent.to_s}\n"
-            puts "\tGamma: #{gamma}\n" if gamma != 0.0
-            chrom = chromaticity
-            if chrom.red_primary.x != 0.0 || chrom.green_primary.x != 0.0 || chrom.blue_primary.x != 0.0 || chrom.white_point.x != 0.0
-                puts "\tChromaticity:\n"
-                puts "\t\tred primary: (#{sprintf("%g,%g", chrom.red_primary.x, chrom.red_primary.y)})\n"
-                puts "\t\tgreen primary: (#{sprintf("%g,%g", chrom.green_primary.x, chrom.green_primary.y)})\n"
-                puts "\t\tblue primary: (#{sprintf("%g,%g", chrom.blue_primary.x, chrom.blue_primary.y)})\n"
-                puts "\t\twhite point: (#{sprintf("%g,%g", chrom.white_point.x, chrom.white_point.y)})\n"
-            end
-            ex_info = extract_info
-            if ex_info.width * ex_info.height != 0.0
-                puts "\tTile geometry: #{ex_info.width}x#{ex_info.height}+#{ex_info.x}+#{ex_info.y}\n"
-            end
-            if x_resolution != 0.0 && y_resolution != 0.0
-                puts "\tResolution: #{sprintf("%gx%g", x_resolution, y_resolution)}\n"
-            end
-            puts "\tUnits: #{units.to_s}\n"
-            size = filesize
-            if size >= 1048576
-                puts "\tFilesize: #{"%.1f" % (size/1048576.0)}mb\n"
-            elsif size >= 1024
-                puts "\tFilesize: #{"%.0f" % (size/1024.0)}kb\n"
-            else
-                puts "\tFilesize: #{size}b\n"
-            end
-            puts "\tInterlace: #{interlace.to_s}\n"
-            puts "\tBackground Color: #{background_color}\n"
-            puts "\tBorder Color: #{border_color}\n"
-            puts "\tMatte Color: #{matte_color}\n"
-            pg = page
-            if pg.width != 0 || pg.height != 0 || pg.x != 0 || pg.y != 0
-                puts "\tPage geometry: #{pg.width}x#{pg.height}+#{pg.x}+#{pg.y}\n"
-            end
-            puts "\tDispose: #{dispose.to_s}\n"
-            puts "\tDelay: #{delay}\n" if delay != 0
-            puts "\tIterations: #{iterations}\n" unless iterations == 1
-            puts "\tScene: #{scene}\n" if scene != 0
-            puts "\tCompression: #{compression.to_s}\n"
-            puts "\tQuality: #{quality}\n" unless quality == 0
-            puts "\tOrientation: #{orientation.to_s}\n"
-            puts "\tMontage: #{montage}\n" if montage
-            signature # compute but ignore - will be displayed along with the other properties
-            properties.each do |prop, value|
-                next if prop[0,1] == '['
-                puts "\t#{prop}: #{value}\n"
-            end
-            clip_path = self["8BIM:1999,2998:#1"]
-            if clip_path
-                puts "\tClipping path: #{clip_path}\n"
-            end
-            each_profile do |name, value|
-                puts "\tProfile-#{name}: #{value.length}\n"
-                if name == 'exif'
-                    exif_attrs = get_exif_by_entry
-                    exif_attrs.each do |attr|
-                        puts "\t\t#{attr[0]}: #{attr[1]}\n"
-                    end
-                end
-            end
-            puts "\tTainted: True\n" if changed?
-            puts "\tTainted: False\n" unless changed?
-            puts "\tVersion: #{Magick::Version}\n"
-            puts "\t         #{Magick::Magick_version}\n"
-        end
-    end
-end
-
-if ARGV.length == 0
-    puts <<-'END_USAGE'
-    This example displays information about the specified image file(s)
-    that is similar to ImageMagick/GraphicsMagick's identify command.
-
-    Usage:
-    ruby identify.rb filename [filename...]
-    END_USAGE
-    exit
-end
-
-ilist = Magick::ImageList.new(*ARGV)
-ilist.each do |img|
-    img.identify
-end
-
-exit
-

data/examples/image_opacity.rb

@@ -1,29 +0,0 @@
-
-# Ccreate a semi-transparent title for an image.
-
-require 'RMagick'
-include Magick
-
-puts <<END_INFO
-
-This example uses a semi-transparent background color to create a title.
-View the resulting image by entering the command: display image_opacity.miff
-
-END_INFO
-
-balloons = Image.read('../doc/ex/images/Hot_Air_Balloons_H.jpg').first
-legend = Image.new(160, 50) { self.background_color = '#ffffffc0' }
-
-gc = Draw.new
-gc.annotate(legend, 0, 0, 0, 0, "Balloon Day!\\nFri May 2 2003") {
-  self.gravity = CenterGravity
-  self.stroke = 'transparent'
-  self.fill = 'white'
-  self.pointsize = 18
-}
-
-result = balloons.composite(legend, SouthGravity, OverCompositeOp)
-
-puts "...Writing image_opacity.miff"
-result.write 'image_opacity.miff'
-exit

data/examples/import_export.rb

@@ -1,31 +0,0 @@
-#
-# Demonstrate the export_pixels and import_pixels methods.
-#
-
-require 'RMagick'
-include Magick
-
-puts <<END_INFO
-
-This example demonstrates the export_pixels and import_pixels methods
-by copying an image one row at a time. The result is an copy that
-is identical to the original.
-
-END_INFO
-
-img = Image.read('../doc/ex/images/Gold_Statue.jpg').first
-copy = Image.new(img.columns, img.rows);
-
-begin
-    img.rows.times { |r|
-        scanline = img.export_pixels(0, r, img.columns, 1, "RGB");
-        copy.import_pixels(0, r, img.columns, 1, "RGB", scanline);
-        }
-rescue NotImplementedError
-    $stderr.puts "The export_pixels and import_pixels methods are not supported" +
-                 " by this version of ImageMagick/GraphicsMagick"
-    exit
-end
-
-copy.write("copy.gif")
-exit

data/examples/pattern_fill.rb

@@ -1,38 +0,0 @@
-
-# Demonstrate ImageMagick's new (5.5.7-3 and later) built-in patterns.
-# Create a Fill class that can be reused to fill in new Image backgrounds.
-
-# Usage: pattern_fill.rb <name-of-pattern>
-# Try 'checkerboard' or 'verticalsaw'
-
-require 'RMagick'
-include Magick
-
-puts <<END_INFO
-
-This example demonstrates the PATTERN: image format, which is
-new in ImageMagick 5.5.7. Specify the name of any of the
-supported patterns as an argument. For example, try "checkerboard".
-
-END_INFO
-
-class PatternFill < Magick::TextureFill
-    def initialize(name='bricks')
-        @pat_img = Magick::Image.read("pattern:#{name}").first
-        super(@pat_img)
-    end
-end
-
-if ARGV[0]
-    pattern = ARGV[0]
-else
-    $stderr.puts "Defaulting to checkerboard pattern."
-    pattern = 'checkerboard'
-end
-
-# Create a sample image that is 100x bigger than the pattern.
-attrs = Image.ping("pattern:#{pattern}").first
-
-tryit = Image.new(10*attrs.columns, 10*attrs.rows, PatternFill.new(pattern))
-tryit.write("pattern_fill.gif")
-exit

data/examples/rotating_text.rb

@@ -1,45 +0,0 @@
-# Demonstrate the Draw#rotation= method by producing
-# an animated MIFF file showing a rotating text string.
-
-
-require 'RMagick'
-include Magick
-
-puts <<END_INFO
-Demonstrate the rotation= attribute in the Draw class
-by producing an animated image. View the output image
-by entering the command: animate rotating_text.miff
-END_INFO
-
-text = Draw.new
-text.pointsize = 28
-text.font_weight = BoldWeight
-text.font_style = ItalicStyle
-text.gravity = CenterGravity
-
-# Let's make it interesting. Composite the
-# rotated text over a gradient fill background.
-fill = GradientFill.new(100,100,100,100,"yellow","red")
-bg = Image.new(200, 200, fill)
-
-# The "none" color is transparent.
-fg = Image.new(bg.columns, bg.rows) { self.background_color = "none" }
-
-# Here's where we'll collect the individual frames.
-animation = ImageList.new
-
-0.step(345,15) { |degrees|
-    frame = fg.copy
-    text.annotate(frame, 0,0,0,0, "Rotating Text") {
-        self.rotation = degrees
-    }
-    # Composite the text over the gradient filled background frame.
-    animation << bg.composite(frame, CenterGravity, DisplaceCompositeOp)
-}
-
-animation.delay = 8
-
-#animation.animate
-puts "...Writing rotating_text.gif"
-animation.write("rotating_text.gif")
-exit