rmagick 4.1.0.rc2 → 4.1.0

data/examples/histogram.rb

@@ -1,312 +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.alpha = bg.alpha
-    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) do
-        self.background_color = bg
-        self.border_color = fg
-      end
-
-      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'
-
-      histogram
-    end
-
-    def channel_histograms(red, green, blue, int, scale, fg, bg)
-      rgb_histogram = Image.new(HISTOGRAM_COLS, HISTOGRAM_ROWS) do
-        self.background_color = bg
-        self.border_color = fg
-      end
-      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.alpha(Magick::ActivateAlphaChannel)
-
-      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
-          int_column[y].alpha = TransparentAlpha if yf >= HISTOGRAM_ROWS - (int[x] * scale)
-        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
-
-      [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
-        warn '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) do
-          self.background_color = bg
-          self.border_color = fg
-        end
-
-        x = 0
-        pixels.each do |pixel|
-          column = Array.new(HISTOGRAM_ROWS).fill { Pixel.new }
-          HISTOGRAM_ROWS.times do |y|
-            column[y] = pixel if y >= HISTOGRAM_ROWS - (hist[pixel] * scale)
-          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) do
-        self.background_color = bg
-        self.border_color = fg
-      end
-
-      gc = Draw.new
-
-      gc.annotate(info, 0, 0, 0, 0, text) do
-        self.stroke = 'transparent'
-        self.fill = fg
-        self.gravity = CenterGravity
-      end
-      info['Label'] = 'Info'
-
-      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'
-
-      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.
-          alpha[pixel.opacity & MAX_QUANTUM] += 1 unless opaque?
-          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
-      charts << if !opaque?
-                  alpha_hist(alpha, scale, fg, bg)
-                else
-                  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 do
-        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"
-      end
-
-      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]
-  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)
-puts 'Charting 1st image' if image.length > 1
-image = image.first
-
-# Give the user something to look at while we're working.
-name = File.basename(filename).sub(/\..*?$/, '')
-$stdout.sync = true
-printf "Creating #{name}_Histogram.png"
-
-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.png")
-
-Thread.kill(timer)
-puts 'Done!'
-exit

data/examples/identify.rb

@@ -1,174 +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}\n"
-      puts "\tType: #{image_type}\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 alpha
-      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 alpha
-      when Magick::GRAYColorspace
-        puts "\t\tGray: #{channel_depth(Magick::GrayChannel)}-bits\n"
-        puts "\t\tOpacity: #{channel_depth(Magick::OpacityChannel)}-bits\n" if alpha
-      end
-      scale = Magick::QuantumRange / (Magick::QuantumRange >> (Magick::MAGICKCORE_QUANTUM_DEPTH - 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 alpha
-        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"
-      elsif total_colors <= colors
-        puts "\tColors: #{colors}\n"
-      else
-        puts "\tColors: #{total_colors}=>#{colors}\n"
-      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}\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
-      puts "\tTile geometry: #{ex_info.width}x#{ex_info.height}+#{ex_info.x}+#{ex_info.y}\n" if ex_info.width * ex_info.height != 0.0
-      puts "\tResolution: #{sprintf('%gx%g', x_resolution, y_resolution)}\n" if x_resolution != 0.0 && y_resolution != 0.0
-      puts "\tUnits: #{units}\n"
-      size = filesize
-      if size >= 1_048_576
-        puts "\tFilesize: #{sprintf('%.1f', (size / 1_048_576.0))}mb\n"
-      elsif size >= 1024
-        puts "\tFilesize: #{sprintf('%.0f', (size / 1024.0))}kb\n"
-      else
-        puts "\tFilesize: #{size}b\n"
-      end
-      puts "\tInterlace: #{interlace}\n"
-      puts "\tBackground Color: #{background_color}\n"
-      puts "\tBorder Color: #{border_color}\n"
-      puts "\tMatte Color: #{matte_color}\n"
-      pg = page
-      puts "\tPage geometry: #{pg.width}x#{pg.height}+#{pg.x}+#{pg.y}\n" if pg.width != 0 || pg.height != 0 || pg.x != 0 || pg.y != 0
-      puts "\tDispose: #{dispose}\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}\n"
-      puts "\tQuality: #{quality}\n" unless quality.zero?
-      puts "\tOrientation: #{orientation}\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']
-      puts "\tClipping path: #{clip_path}\n" if clip_path
-      each_profile do |name, value|
-        puts "\tProfile-#{name}: #{value.length}\n"
-        next unless name == 'exif'
-
-        exif_attrs = get_exif_by_entry
-        exif_attrs.each do |attr|
-          puts "\t\t#{attr[0]}: #{attr[1]}\n"
-        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.zero?
-  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(&:identify)
-
-exit