rmagick-windows 2.16.1

data/examples/histogram.rb

@@ -0,0 +1,321 @@
+# 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) 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.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
+
+        [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) 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|
+              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) 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.
+            unless 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 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)
+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

@@ -0,0 +1,185 @@
+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 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::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 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}\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}\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}\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}\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 == 0
+      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']
+      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