quick_magick 0.4.0 → 0.5.0

data/Manifest

@@ -6,8 +6,8 @@ lib/quick_magick.rb
 Manifest
 quick_magick.gemspec
 test/image_test.rb
-test/logo-small.jpg
 test/badfile.xxx
 test/multipage.tif
 test/image_list_test.rb
-test/imagemagick-logo.png
+test/test_magick.rb
+test/9.gif

data/README

@@ -1,72 +1,125 @@
-== QuickMagick
+= Quick Magick
 
+== What is QuickMagick
 QuickMagick is a gem for easily accessing ImageMagick command line tools from Ruby programs.
 
-== What is different?
+== When to use QuickMagick
+QuickMagick is a library that allows you to create and manipulate images.
+When you are faced with a problem that requires high quality manipulation of images you can use QuickMagick.
+These are some situation when QuickMagick will be useful for you:
+* Suppose you built an image gallery site that allows users to upload images. You can use QuickMagick to check uploaded images dimensions and make thumbnails for them.
+* Generate captchas to check whether the user is a robot or a human.
+* Generate graphical reports and charts to the user based on some calculations.
+* Convert uploaded images to a format usable by your application. For example, you can transform .pdf files to .jpg so that you can display them at your web site.
+
+== Features
+* Open an existing image from disk and determine basic info like width, height.
+* Open an image from blob. For example, an image read from an upload form.
+* Do basic and advanced operations on images like resize, rotate, shear, motion blur and other.
+* Create an image from scratch and draw basic elements on it like line, circle and text. This allows making captchas for example.
+* Combine images using ImageList to make a multipage or animated images.
+* API is very simple and powerful.
+* Minimizes disk access by calling command line tools only when required.
+
+== How to install
+First, you should install ImageMagick (http://www.imagemagick.org/) on your machine.
+Command lines of ImageMagick must be in your system path.
+You can check this by running the command:
+  identify --version
+Now to install QuickMagick just type at your command line:
+  gem install quick_magick
+... and it's done.
+You don't have to install any libraries or compile code from source.
 
+== What is different?
 But what's different from other gems like RMagick and mini-magick?
-RMagick is a very good gem and QuickMagick is not a replacement of it.
-RMagick mainpulates images in memory.
-This is sometimes preferable but not in all cases.
-It uses a huge amonut of memory when manipulating images of large sizes.
-QuickMagick allows you to access all the powerful commands of ImageMagick that are accessible from command line.
-When you need more advanced options like reading pixel values, you should go to RMagick.
-Another good point in QuickMagick is that it's very easy to install.
-It doesn't require any Magick libraries or compile something from source to be installed.
-A running copy of ImageMagick is enough.
-
-The idea of this gem came from MiniMagick.
-I used MiniMagick for a little time but I found that some advanced options are missing.
-For example, you cannot manipulate multipage images.
-Also, it uses "mogrify" and creates temporary files to simulate the "convert" command which makes it slower as it accesses the disk multiple times.
-Another small stuff is that it relies on method_missing to set command line arguments which is slow and not preferable.
-
-In QuickMagick I tried to solve the above problems while keeping the API as easy as possible.
 
-== Comparison
+The story begins when I was working on a project at BadrIT (http://www.badrit.com) using Ruby on Rails.
+In this projects users were uploading images in many formats like pdf, tiff and png.
+We were using Flex as a front end to display and annotate these images.
+Flex has a limitation in that it can open images up to 8192x8192.
+Unfortunately, users were uploading images much larger than this.
+Another issue is that Flex can only open .jpg, .png and .gif files.
+The solution was to convert all images uploaded to one of these formats and resizing them down to at most 8192x8192.
+
+First, I used ImageMagick as a command line tool and was calling it using system calls.
+This accomplished the work perfectly buy my source code was a rubbish.
+It has many lines of code to handle creating temporary files and accessing multipage tiff and pdf files.
+I found RMagick at that time and decided to use it.
+It caused the code to be much simple without affecting performance notably.
+It worked with me well while I was using my application with test images.
+Once I decided to test it with real images it failed.
+For example, when I transform a tiff image from 14400x9600 to 8192x8192 while transforming it to gif, my machine runs out of memory (2GB RAM).
+When I tried to make the same operation from command line using (convert) it was working much better.
+It did not finish in a second but at least it worked correctly.
+The solution was to return back to command line.
+
+I searched for alternatives and found MiniMagick.
+MiniMagick is a gem that allows you to perform basic operations using ImageMagick through command line tools.
+I tried to use it but it was not good enough.
+First, it writes temporary images and files as it is working which makes it slow for nothing.
+Second, it doesn't handle multipage images.
+I tried it with a .pdf file and I found that it handled the first page only.
+Third, it doesn't give an API to draw images from scratch.
+Actually, I didn't need this feature, but I may need it in the future.
+
+At this point I decided to make my own gem and QuickMagick was born.
+I addressed the problems of MiniMagick while using the same main idea.
+First, QuickMagick doesn't write any temporary images to disk.
+It doesn't issue any command line commands till the very end when you are saving the image.
+Second, I made an API similar to RMagick which allows for accessing multipage images.
+Third, I added API commands to create images from scratch and drawing simple primitives on images.
+I tested my gem, compared it to MiniMagick and RMagick and it pleased me.
 
+== Comparison
 I've made some test benches to compare the speed of QuickMagick, MiniMagick and RMagick.
+All denoted numbers are in seconds.
 Here are the results:
 
-Test 1: resize a normal image (20 times)
+===Test 1: resize a normal image
                   user     system      total        real
-mini          0.010000   0.070000   3.730000 (  3.693978)
-quick         0.010000   0.040000   3.270000 (  3.124558)
-rmagick       1.740000   1.610000   3.350000 (  3.283624)
+  mini          0.030000   0.040000   3.640000 (  3.585617)
+  quick         0.010000   0.030000   3.330000 (  3.295369)
+  rmagick       1.680000   1.660000   3.340000 (  3.150202)
 
-It's clear that QuickMagick is faster that MiniMagick.
-In this run RMagick was a little bit slower than QuickMagick.
-Actually, this is not always the case.
-Sometimes It's faster than QuickMagick.
-On average, we can say that they both take the same time.
+It's clear that QuickMagick is faster than MiniMagick.
+RMagick was the fastest as it accesses the requested operations directly without the need to load an executable file or parse a command line.
 
-Test 2: resize a large image
+===Test 2: resize a large image
                   user     system      total        real
-mini          0.000000   0.030000  58.090000 ( 33.852697)
-quick         0.000000   0.000000  55.820000 ( 31.492870)
+  mini          0.000000   0.040000  57.150000 (130.609229)
+  quick         0.010000   0.010000  56.510000 ( 58.426361)
 
 Again QuickMagick is faster than MiniMagick.
 However, RMagick has failed to pass this test.
 It kept working and eating memory, cpu and harddisk till I had to unplug my computer to stop it.
 So, I removed it from this test bench.
 
-Test 3: generate random captchas (20)
+===Test 3: generate random captchas
                   user     system      total        real
-quick         0.010000   0.020000   3.610000 (  4.952026)
-rmagick       1.320000   1.640000   2.960000 (  3.058445)
+  quick         0.000000   0.000000   0.290000 (  3.623418)
+  rmagick       0.150000   0.120000   0.270000 (  3.171975)
 
-In this last test, RMagick was 38% faster than QuickMagick.
+In this last test, RMagick was about 12% faster than QuickMagick.
 This is normal because it works in memory and doesn't have to parse a command line string to know what to draw.
 I couldn't test MiniMagick for this because it doesn't support an API for drawing functions.
 
-== Examples
+== Conclusion
+QuickMagick is very easy to install, very easy to use and allows you to access most features of ImageMagick.
+RMagick is a bit faster and has an advantage of allowing you to access single pixels but it's a bit hard to install.
+Also RMagick sometimes fail when it tries to handle large images.
+MiniMagick is proved to be a bit slower than QuickMagick with no advantage.
+So, it's better to use QuickMagick when your application is not image-centric.
+This means, you're not going to build an image manipulation tool or something like this.
+For normal operations like resize, rotate, generating captchas ... etc, QuickMagick will be a good friend of you.
 
+== Examples
 Determine image information
 	i = QuickMagick::Image.read('test.jpg').first
 	i.width # Retrieves width in pixels
 	i.height # Retrieves height in pixels
 
-Resize and image
+Resize an image
 	i = QuickMagick::Image.read('test.jpg').first
 	i.resize "300x300!"
 	i.save "resized_image.jpg"
@@ -80,7 +133,7 @@ Resize and image
 
 Access multipage image
 	i = QuickMagick::Image.read("multipage.pdf") {|image| image.density = 300}
-	i.size % number of pages
+	i.size # number of pages
 	i.each_with_index do |page, i|
 		i.save "page_#{i}.jpg"
 	end
@@ -99,14 +152,15 @@ You can also display an image to Xserver
 	i = QuickMagick::Image.read('test.jpg')
 	i.display
 
-QuickMagick supports also ImageLists
+QuickMagick supports also ImageList s
+	# Batch generate a list of jpg files to gif while resizing them
 	il = QuickMagick::ImageList.new('test.jpg', 'test2.jpg')
 	il << QuickMagick::Image.read('test3.jpg')
 	il.format = 'gif'
 	il.resize "300x300>"
 	il.save!
 
-You can also create images from scratch
+(new) You can also create images from scratch
 	# Create a 300x300 gradient image from yellow to red
 	i1 = QuickMagick::Image::gradient(300, 300, QuickMagick::RadialGradient, :yellow, :red)
 	i1.save 'gradient.png'
@@ -121,5 +175,8 @@ You can also create images from scratch
 	i.draw_text(30, 30, "Hello world!", :rotate=>45)
 	i.save 'hello.jpg'
 
-Check all command line options of ImageMagick at
+For more information on drawing API visit:
+http://www.imagemagick.org/Usage/draw/
+
+Check all command line options of ImageMagick at:
 http://www.imagemagick.org/script/convert.php

data/Rakefile

@@ -2,7 +2,7 @@ require 'rubygems'
 require 'rake'
 require 'echoe'
  
-Echoe.new('quick_magick', '0.4.0') do |p|
+Echoe.new('quick_magick', '0.5.0') do |p|
   p.description    = "QuickMagick allows you to access ImageMagick command line functions using Ruby interface."
   p.url            = "http://quickmagick.rubyforge.org/"
   p.author         = "Ahmed ElDawy"

data/lib/quick_magick/image.rb

@@ -42,7 +42,7 @@ module QuickMagick
         template_name << color1.to_s if color1
         template_name << '-' << color2.to_s if color2
         i = self.new(template_name, nil, true)
-        i.size = QuickMagick::Image::retrieve_geometry(width, height)
+        i.size = QuickMagick::geometry(width, height)
         i
       end
       
@@ -51,7 +51,7 @@ module QuickMagick
         template_name = QuickMagick::SolidColor+":"
         template_name << color.to_s if color
         i = self.new(template_name, nil, true)
-        i.size = QuickMagick::Image::retrieve_geometry(width, height)
+        i.size = QuickMagick::geometry(width, height)
         i
       end
       
@@ -60,7 +60,7 @@ module QuickMagick
         raise QuickMagick::QuickMagickError, "Invalid pattern '#{pattern.to_s}'" unless QuickMagick::Patterns.include?(pattern.to_s)
         template_name = "pattern:#{pattern.to_s}"
         i = self.new(template_name, nil, true)
-        i.size = QuickMagick::Image::retrieve_geometry(width, height)
+        i.size = QuickMagick::geometry(width, height)
         i
       end
 
@@ -69,26 +69,12 @@ module QuickMagick
         `identify #{filename} 2>&1`
       end
 
-      # Encodes a geometry string with the given options
-      def retrieve_geometry(width, height=nil, x=nil, y=nil, flag=nil)
-        geometry_string = ""
-        geometry_string << width.to_s if width
-        geometry_string << 'x' << height.to_s if height
-        geometry_string << '+' << x.to_s if x
-        geometry_string << '+' << y.to_s if y
-        geometry_string << flag if flag
-        geometry_string
-      end
-    end
-
-    # append the given option, value pair to the args for the current image
-    def append_to_operators(arg, value="")
-      @operators << %Q<-#{arg} "#{value}" >
     end
 
     # append the given option, value pair to the settings of the current image
     def append_to_settings(arg, value="")
-      @settings << %Q<-#{arg} "#{value}" >
+      @arguments << %Q<-#{arg} "#{value}" >
+      self
     end
 
     # Image settings supported by ImageMagick
@@ -104,10 +90,28 @@ module QuickMagick
       density page sampling-factor size tile-offset
     }
 
+    # append the given option, value pair to the args for the current image
+    def append_to_operators(arg, value="")
+      if @last_is_draw
+        @arguments.insert(@arguments.rindex('"'), " #{value}")
+      else
+        @arguments << %Q<-#{arg} "#{value}" >
+      end
+      @last_is_draw = arg == 'draw'
+      self
+    end
+    
+    # Reverts this image to its last saved state.
+    # Note that you cannot revert an image created from scratch.
+    def revert!
+      raise QuickMagick::QuickMagickError, "Cannot revert a pseudo image" if @pseudo_image
+      @arguments = ""
+    end
+
     # Image operators supported by ImageMagick
     IMAGE_OPERATORS_METHODS = %w{
       alpha auto-orient bench black-threshold bordercolor charcoal clip clip-mask clip-path colorize
-      contrast convolve cycle decipher deskew despeckle distort draw edge encipher emboss enhance equalize
+      contrast convolve cycle decipher deskew despeckle distort edge encipher emboss enhance equalize
       evaluate flip flop function gamma identify implode layers level level-colors median modulate monochrome
       negate noise normalize opaque ordered-dither NxN paint polaroid posterize print profile quantize
       radial-blur Raise random-threshold recolor render rotate segment sepia-tone set shade solarize
@@ -123,11 +127,6 @@ module QuickMagick
       crop
       }
 
-    # fills a rectangle with a solid color
-    def floodfill(width, height=nil, x=nil, y=nil, flag=nil, color=nil)
-      append_to_operators "floodfill", QuickMagick::Image.retrieve_geometry(width, height, x, y, flag), color
-    end
-
     # methods that are called with (=)
     WITH_EQUAL_METHODS =
       %w{alpha antialias background bias black-point-compensation blue-primary border bordercolor caption
@@ -151,7 +150,7 @@ module QuickMagick
         end
       elsif WITH_GEOMETRY_METHODS.include?(method)
         define_method((method).to_sym) do |*args|
-          append_to_settings(method, QuickMagick::Image.retrieve_geometry(*args) )
+          append_to_settings(method, QuickMagick::geometry(*args) )
         end
       else
         define_method(method.to_sym) do |*args|
@@ -167,7 +166,7 @@ module QuickMagick
         end
       elsif WITH_GEOMETRY_METHODS.include?(method)
         define_method((method).to_sym) do |*args|
-          append_to_operators(method, QuickMagick::Image.retrieve_geometry(*args) )
+          append_to_operators(method, QuickMagick::geometry(*args) )
         end
       else
         define_method(method.to_sym) do |*args|
@@ -175,6 +174,11 @@ module QuickMagick
         end
       end
     end
+
+    # Fills a rectangle with a solid color
+    def floodfill(width, height=nil, x=nil, y=nil, flag=nil, color=nil)
+      append_to_operators "floodfill", QuickMagick::geometry(width, height, x, y, flag), color
+    end
     
     # define attribute readers (getters)
     attr_reader :image_filename
@@ -188,13 +192,12 @@ module QuickMagick
         @image_infoline = info_line.split
         @image_infoline[0..1] = @image_infoline[0..1].join(' ') while @image_infoline.size > 1 && !@image_infoline[0].start_with?(image_filename)
       end
-      @operators = ""
-      @settings = ""
+      @arguments = ""
     end
     
     # The command line so far that will be used to convert or save the image
     def command_line
-      %Q<#{@settings} "#{image_filename}" #{@operators}>
+      %Q< "(" #{@arguments} "#{image_filename}" ")" >
     end
     
     # An information line about the image obtained using 'identify' command line
@@ -214,6 +217,8 @@ module QuickMagick
     # * skewX           degrees
     # * skewY           degrees
     # * gravity         NorthWest, North, NorthEast, West, Center, East, SouthWest, South, or SouthEast
+    # * stroke          color
+    # * fill            color
     # The rotate primitive rotates subsequent shape primitives and text primitives about the origin of the main image.
     # If you set the region before the draw command, the origin for transformations is the upper left corner of the region.
     # The translate primitive translates subsequent shape and text primitives.
@@ -290,6 +295,7 @@ module QuickMagick
     # The polyline primitive requires three or more points to define their perimeters.
     # A polyline is simply a polygon in which the final point is not stroked to the start point.
     # When unfilled, this is a polygonal line. If the -stroke setting is none (the default), then a polyline is identical to a polygon.
+    #  points - A single array with each pair forming a coordinate in the form (x, y). e.g. [0,0,100,100,100,0] will draw a polyline between points (0,0)-(100,100)-(100,0)
     def draw_polyline(points, options={})
       append_to_operators("draw", "#{options_to_str(options)} polyline #{points_to_str(points)}")
     end
@@ -297,6 +303,7 @@ module QuickMagick
     # The polygon primitive requires three or more points to define their perimeters.
     # A polyline is simply a polygon in which the final point is not stroked to the start point.
     # When unfilled, this is a polygonal line. If the -stroke setting is none (the default), then a polyline is identical to a polygon.
+    #  points - A single array with each pair forming a coordinate in the form (x, y). e.g. [0,0,100,100,100,0] will draw a polygon between points (0,0)-(100,100)-(100,0)
     def draw_polygon(points, options={})
       append_to_operators("draw", "#{options_to_str(options)} polygon #{points_to_str(points)}")
     end
@@ -362,6 +369,8 @@ module QuickMagick
       raise QuickMagick::QuickMagickError, "Cannot mogrify a pseudo image" if @pseudo_image
       result = `mogrify #{command_line}`
       if $?.success?
+        # remove all operations to avoid duplicate operations
+        revert!
         return result 
       else
         error_message = <<-ERRORMSG
@@ -419,4 +428,4 @@ module QuickMagick
       `display #{command_line}`
     end
   end
-end
+end

data/lib/quick_magick.rb

@@ -13,12 +13,32 @@ rescue Errno::ENOENT
 end
 
 module QuickMagick
-  # Different geometry flags
+  # Normally the attributes are treated as pixels.
+  # Use this flag when the width and height attributes represent percentages.
+  # For example, 125x75 means 125% of the height and 75% of the width.
+  # The x and y attributes are not affected by this flag.  
   PercentGeometry = "%"
+  
+  # Use this flag when you want to force the new image to have exactly the size specified by the the width and height attributes.
   AspectGeometry  = "!"
+  
+  # Use this flag when you want to change the size of the image only if both its width and height
+  # are smaller the values specified by those attributes. The image size is changed proportionally.
   LessGeometry = "<"
+  
+  # Use this flag when you want to change the size of the image if either its width and height
+  # exceed the values specified by those attributes. The image size is changed proportionally.
   GreaterGeometry = ">"
+  
+  # This flag is useful only with a single width attribute.
+  # When present, it means the width attribute represents the total area of the image in pixels.
   AreaGeometry = "@"
+  
+  # Use ^ to set a minimum image size limit.
+  # The geometry 640x480^, for example, means the image width will not be less than 640 and
+  # the image height will not be less than 480 pixels after the resize.
+  # One of those dimensions will match the requested size,
+  # but the image will likely overflow the space requested to preserve its aspect ratio.
   MinimumGeometry = "^"
   
   # Command for solid color
@@ -35,11 +55,96 @@ module QuickMagick
     hs_vertical left30 left45 leftshingle octagons right30 right45 rightshingle smallfishscales
     vertical verticalbricks verticalleftshingle verticalrightshingle verticalsaw}
   
-  # Generate a random string of specified length.
-  # Used to generate random names for temp files
-  def self.random_string(length=10)
-    @@CHARS ||= ("a".."z").to_a + ("1".."9").to_a 
-    Array.new(length, '').collect{@@CHARS[rand(@@CHARS.size)]}.join
+  
+  class <<self
+    # Generate a random string of specified length.
+    # Used to generate random names for temp files
+    def random_string(length=10)
+      @@CHARS ||= ("a".."z").to_a + ("1".."9").to_a 
+      Array.new(length, '').collect{@@CHARS[rand(@@CHARS.size)]}.join
+    end
+    
+    # Encodes a geometry string with the given options
+    def geometry(width, height=nil, x=nil, y=nil, flag=nil)
+      geometry_string = ""
+      geometry_string << width.to_s if width
+      geometry_string << 'x' << height.to_s if height
+      geometry_string << '+' << x.to_s if x
+      geometry_string << '+' << y.to_s if y
+      geometry_string << flag if flag
+      geometry_string
+    end
+    
+    # Returns a formatted string for the color with the given components
+    # each component could take one of the following values
+    # * an integer from 0 to 255
+    # * a float from 0.0 to 1.0
+    # * a string showing percentage from "0%" to "100%"
+    def rgba_color(red, green, blue, alpha=255)
+      "#%02x%02x%02x%02x" % [red, green, blue, alpha].collect do |component|
+        case component
+          when Integer then component
+          when Float then Integer(component*255)
+          when String then Integer(component.sub('%', '')) * 255 / 100
+        end
+      end
+    end
+    
+    alias rgb_color rgba_color
+    
+    # Returns a formatted string for a gray color with the given level and alpha.
+    # level and alpha could take one of the following values
+    # * an integer from 0 to 255
+    # * a float from 0.0 to 1.0
+    # * a string showing percentage from "0%" to "100%"
+    def graya_color(level, alpha=255)
+      rgba_color(level, level, level, alpha)
+    end
+    
+    alias gray_color graya_color
+    
+    # HSL colors are encoding as a triple (hue, saturation, lightness).
+    # Hue is represented as an angle of the color circle (i.e. the rainbow represented in a circle).
+    # This angle is so typically measured in degrees that the unit is implicit in CSS;
+    # syntactically, only a number is given. By definition red=0=360,
+    # and the other colors are spread around the circle, so green=120, blue=240, etc.
+    # As an angle, it implicitly wraps around such that -120=240 and 480=120, for instance.
+    # (Students of trigonometry would say that "coterminal angles are equivalent" here;
+    # an angle (theta) can be standardized by computing the equivalent angle, (theta) mod 360.)
+    #
+    # Saturation and lightness are represented as percentages.
+    # 100% is full saturation, and 0% is a shade of grey.
+    # 0% lightness is black, 100% lightness is white, and 50% lightness is 'normal'.
+    #
+    # Hue can take one of the following values:
+    # * an integer from 0...360 representing angle in degrees
+    # * a float value from 0...2*PI represeting angle in radians
+    #
+    # saturation, lightness and alpha can take one of the following values:
+    # * an integer from 0 to 255
+    # * a float from 0.0 to 1.0
+    # * a string showing percentage from "0%" to "100%"
+    def hsla_color(hue, saturation, lightness, alpha=1.0)
+      components = [case hue
+        when Integer then hue
+        when Float then Integer(hue * 360 / 2 / Math::PI)
+      end]
+      components += [saturation, lightness].collect do |component|
+        case component
+          when Integer then (component * 100.0 / 255).round
+          when Float then Integer(component*100)
+          when String then Integer(component.sub('%', ''))
+        end
+      end
+      components << case alpha
+        when Integer then alpha * 100.0 / 255
+        when Float then alpha
+        when String then Float(alpha.sub('%', '')) / 100.0
+      end
+      "hsla(%d,%d%%,%d%%,%g)" % components
+    end
+    
+    alias hsl_color hsla_color
   end
 end
 
@@ -52,5 +157,13 @@ unless "".respond_to? :start_with?
   end
 end
 
+unless "".respond_to? :end_with?
+  class String
+    def end_with?(x)
+      self.index(x) == self.length - 1
+    end
+  end
+end
+
 require 'quick_magick/image'
 require 'quick_magick/image_list'

data/quick_magick.gemspec

@@ -2,15 +2,15 @@
 
 Gem::Specification.new do |s|
   s.name = %q{quick_magick}
-  s.version = "0.4.0"
+  s.version = "0.5.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ahmed ElDawy"]
-  s.date = %q{2009-08-05}
+  s.date = %q{2009-08-12}
   s.description = %q{QuickMagick allows you to access ImageMagick command line functions using Ruby interface.}
   s.email = %q{ahmed.eldawy@badrit.com}
   s.extra_rdoc_files = ["README", "lib/quick_magick/image.rb", "lib/quick_magick/image_list.rb", "lib/quick_magick.rb"]
-  s.files = ["README", "Rakefile", "lib/quick_magick/image.rb", "lib/quick_magick/image_list.rb", "lib/quick_magick.rb", "Manifest", "quick_magick.gemspec", "test/image_test.rb", "test/logo-small.jpg", "test/badfile.xxx", "test/multipage.tif", "test/image_list_test.rb", "test/imagemagick-logo.png"]
+  s.files = ["README", "Rakefile", "lib/quick_magick/image.rb", "lib/quick_magick/image_list.rb", "lib/quick_magick.rb", "Manifest", "quick_magick.gemspec", "test/image_test.rb", "test/badfile.xxx", "test/multipage.tif", "test/image_list_test.rb", "test/test_magick.rb", "test/9.gif"]
   s.has_rdoc = true
   s.homepage = %q{http://quickmagick.rubyforge.org/}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Quick_magick", "--main", "README"]
@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   s.rubyforge_project = %q{quickmagick}
   s.rubygems_version = %q{1.3.1}
   s.summary = %q{QuickMagick allows you to access ImageMagick command line functions using Ruby interface.}
-  s.test_files = ["test/image_test.rb", "test/image_list_test.rb"]
+  s.test_files = ["test/image_test.rb", "test/image_list_test.rb", "test/test_magick.rb"]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION

data/test/image_list_test.rb

@@ -5,16 +5,25 @@ require 'ftools'
 $base_dir = File.dirname(File.expand_path(__FILE__))
 
 class ImageTest < Test::Unit::TestCase
+  def setup
+    @logo_filename = File.join($base_dir, "imagemagick-logo.png")
+    `convert magick:logo #{@logo_filename}`
+    @small_logo_filename = File.join($base_dir, "logo-small.jpg")
+    `convert magick:logo -resize 100x100! #{@small_logo_filename}`
+  end
+  
+  def teardown
+    File.delete(@logo_filename) if File.exists?(@logo_filename)
+    File.delete(@small_logo_filename) if File.exists?(@small_logo_filename)
+  end
+
   def test_open_file
-    image_filename = File.join($base_dir, "imagemagick-logo.png")
-    i = QuickMagick::ImageList.new(image_filename)
+    i = QuickMagick::ImageList.new(@logo_filename)
     assert_equal 1, i.length
   end
   
   def test_save_multipage
-    image_filename = File.join($base_dir, "imagemagick-logo.png")
-    image_filename2 = File.join($base_dir, "logo-small.jpg")
-    i = QuickMagick::ImageList.new(image_filename, image_filename2)
+    i = QuickMagick::ImageList.new(@logo_filename, @small_logo_filename)
     assert_equal 2, i.length
     out_filename = File.join($base_dir, "out.tif")
     i.save out_filename
@@ -27,9 +36,7 @@ class ImageTest < Test::Unit::TestCase
   end
   
   def test_bulk_resize
-    image_filename1 = File.join($base_dir, "imagemagick-logo.png")
-    image_filename2 = File.join($base_dir, "logo-small.jpg")
-    i = QuickMagick::ImageList.new(image_filename1, image_filename2)
+    i = QuickMagick::ImageList.new(@logo_filename, @small_logo_filename)
     i.resize "50x50!"
     out_filename = File.join($base_dir, "out.tif")
     i.save out_filename
@@ -43,11 +50,9 @@ class ImageTest < Test::Unit::TestCase
   end
   
   def test_append_image
-    image_filename1 = File.join($base_dir, "imagemagick-logo.png")
-    image_filename2 = File.join($base_dir, "logo-small.jpg")
     i = QuickMagick::ImageList.new
-    i << QuickMagick::Image.read(image_filename1)
-    i << QuickMagick::Image.read(image_filename2)
+    i << QuickMagick::Image.read(@logo_filename)
+    i << QuickMagick::Image.read(@small_logo_filename)
     i.resize "50x50!"
     out_filename = File.join($base_dir, "out.tif")
     i.save out_filename
@@ -60,24 +65,49 @@ class ImageTest < Test::Unit::TestCase
     File.delete(out_filename) if out_filename && File.exists?(out_filename)
   end
   
+  def test_different_operators
+    i = QuickMagick::ImageList.new
+    i << QuickMagick::Image.read(@logo_filename)
+    i << QuickMagick::Image.read(@small_logo_filename)
+    i[0].resize "50x50!"
+    i[1].resize "75x75!"
+    out_filename = File.join($base_dir, "out.tif")
+    i.save out_filename
+    
+    i = QuickMagick::Image.read(out_filename)
+    assert_equal 2, i.length
+    assert_equal 50, i[0].width
+    assert_equal 75, i[1].width
+  ensure
+    File.delete(out_filename) if out_filename && File.exists?(out_filename)
+  end
+  
+  def test_resize_one_image_in_a_list
+    i = QuickMagick::ImageList.new
+    i << QuickMagick::Image.read(@logo_filename)
+    i << QuickMagick::Image.read(@small_logo_filename)
+    i[0].resize "50x50!"
+    out_filename = File.join($base_dir, "out.tif")
+    i.save out_filename
+    
+    i = QuickMagick::Image.read(out_filename)
+    assert_equal 2, i.length
+    assert_equal 50, i[0].width
+    assert_equal 100, i[1].width
+  ensure
+    File.delete(out_filename) if out_filename && File.exists?(out_filename)
+  end
+  
   def test_bulk_convert
-    image_filename1 = File.join($base_dir, "imagemagick-logo.png")
-    image_filename2 = File.join($base_dir, "logo-small.jpg")
-    new_image_filename1 = File.join($base_dir, "temp1.png")
-    new_image_filename2 = File.join($base_dir, "temp2.jpg")
-    File.copy(image_filename1, new_image_filename1)
-    File.copy(image_filename2, new_image_filename2)
-    i = QuickMagick::ImageList.new(new_image_filename1, new_image_filename2)
+    i = QuickMagick::ImageList.new(@logo_filename, @small_logo_filename)
     i.format = 'gif'
     i.save!
     
-    out_filename1 = new_image_filename1.sub('.png', '.gif')
-    out_filename2 = new_image_filename2.sub('.jpg', '.gif')
+    out_filename1 = @logo_filename.sub('.png', '.gif')
+    out_filename2 = @small_logo_filename.sub('.jpg', '.gif')
     assert File.exists?(out_filename1)
     assert File.exists?(out_filename2)
   ensure
-    File.delete(new_image_filename1) if new_image_filename1 && File.exists?(new_image_filename1)
-    File.delete(new_image_filename2) if new_image_filename2 && File.exists?(new_image_filename2)
     File.delete(out_filename1) if out_filename1 && File.exists?(out_filename1)
     File.delete(out_filename2) if out_filename2 && File.exists?(out_filename2)
   end

data/test/image_test.rb

@@ -4,16 +4,27 @@ require 'quick_magick'
 $base_dir = File.dirname(File.expand_path(__FILE__))
 
 class ImageTest < Test::Unit::TestCase
+  
+  def setup
+    @logo_filename = File.join($base_dir, "imagemagick-logo.png")
+    `convert magick:logo #{@logo_filename}`
+    @small_logo_filename = File.join($base_dir, "logo-small.jpg")
+    `convert magick:logo -resize 100x100! #{@small_logo_filename}`
+  end
+  
+  def teardown
+    File.delete(@logo_filename) if File.exists?(@logo_filename)
+    File.delete(@small_logo_filename) if File.exists?(@small_logo_filename)
+  end
+  
   def test_open_existing_image
-    image_filename = File.join($base_dir, "imagemagick-logo.png")
-    i = QuickMagick::Image.read(image_filename)
+    i = QuickMagick::Image.read(@logo_filename)
     assert_equal 1, i.size
   end
   
   def test_create_from_blob
-    image_filename = File.join($base_dir, "imagemagick-logo.png")
     blob = nil
-    File.open(image_filename, "rb") do |f|
+    File.open(@logo_filename, "rb") do |f|
       blob = f.read
     end
     i = QuickMagick::Image.from_blob(blob)
@@ -21,10 +32,9 @@ class ImageTest < Test::Unit::TestCase
   end
   
   def test_image_info
-    image_filename = File.join($base_dir, "imagemagick-logo.png")
-    i = QuickMagick::Image.read(image_filename).first
-    assert_equal 464, i.width
-    assert_equal 479, i.height
+    i = QuickMagick::Image.read(@logo_filename).first
+    assert_equal 640, i.width
+    assert_equal 480, i.height
   end
   
   def test_open_non_existing_file
@@ -50,8 +60,7 @@ class ImageTest < Test::Unit::TestCase
   end
 
   def test_resize_image
-    image_filename = File.join($base_dir, "imagemagick-logo.png")
-    i = QuickMagick::Image.read(image_filename).first
+    i = QuickMagick::Image.read(@logo_filename).first
     i.resize("300x300!")
     out_filename = File.join($base_dir, "imagemagick-resized.png")
     File.delete out_filename if File.exists?(out_filename)
@@ -66,8 +75,7 @@ class ImageTest < Test::Unit::TestCase
   end
   
   def test_crop_image
-    image_filename = File.join($base_dir, "imagemagick-logo.png")
-    i = QuickMagick::Image.read(image_filename).first
+    i = QuickMagick::Image.read(@logo_filename).first
     i.crop("300x200+0+0")
     out_filename = File.join($base_dir, "imagemagick-cropped.png")
     File.delete out_filename if File.exists?(out_filename)
@@ -82,8 +90,7 @@ class ImageTest < Test::Unit::TestCase
   end
   
   def test_resize_with_geometry_options
-    image_filename = File.join($base_dir, "imagemagick-logo.png")
-    i = QuickMagick::Image.read(image_filename).first
+    i = QuickMagick::Image.read(@logo_filename).first
     i.resize(300, 300, nil, nil, QuickMagick::AspectGeometry)
     out_filename = File.join($base_dir, "imagemagick-resized.png")
     File.delete out_filename if File.exists?(out_filename)
@@ -98,8 +105,7 @@ class ImageTest < Test::Unit::TestCase
   end
   
   def test_resize_with_append_to_operators
-    image_filename = File.join($base_dir, "imagemagick-logo.png")
-    i = QuickMagick::Image.read(image_filename).first
+    i = QuickMagick::Image.read(@logo_filename).first
     i.append_to_operators 'resize', '300x300!'
     out_filename = File.join($base_dir, "imagemagick-resized.png")
     File.delete out_filename if File.exists?(out_filename)
@@ -142,4 +148,41 @@ class ImageTest < Test::Unit::TestCase
     # clean up
     File.delete(out_filename) if out_filename && File.exists?(out_filename)
   end
+  
+  def test_line_and_circle
+    i = QuickMagick::Image.solid(100, 100, :white)
+    i.draw_line(0,0,20,20)
+    i.draw_circle(30,30,20,20)
+    out_filename = File.join($base_dir, "draw_test.gif")
+    i.save out_filename
+  ensure
+    # clean up
+    File.delete(out_filename) if out_filename && File.exists?(out_filename)
+  end
+  
+  def test_colors
+    assert_equal "#00ff00ff", QuickMagick::rgb_color(0, 255, 0)
+    assert_equal "#00007fff", QuickMagick::rgb_color(0, 0, 0.5)
+    assert_equal "#3f0000ff", QuickMagick::rgb_color("25%" ,0 , 0)
+    
+    assert_equal "#ff00007f", QuickMagick::rgba_color(1.0, 0, 0, 0.5)
+
+    assert_equal "#7f7f7f7f", QuickMagick::graya_color(0.5, 0.5)
+    
+    assert_equal "hsla(30,50%,50%,1)", QuickMagick::hsl_color(30, 127, 127)
+    assert_equal "hsla(180,50%,50%,0.5)", QuickMagick::hsla_color(Math::PI, 0.5, "50%", 0.5)
+  end
+  
+  def test_revert
+    i = QuickMagick::Image.read(@logo_filename).first
+    i.resize("300x300!")
+    i.revert!
+    out_filename = File.join($base_dir, "imagemagick-resized.png")
+    File.delete out_filename if File.exists?(out_filename)
+    i.save(out_filename)
+    assert File.exists?(out_filename)
+    i2 = QuickMagick::Image.read(out_filename).first
+    assert_equal 640, i2.width
+    assert_equal 480, i2.height
+  end
 end

data/test/test_magick.rb

@@ -0,0 +1,169 @@
+if __FILE__ == $0
+  require 'rubygems'
+  require 'mini_magick'
+  require 'quick_magick'
+  require 'RMagick'
+  require 'benchmark'
+  require 'ftools'
+  
+  begin
+    include Benchmark
+    
+    $base_dir = File.dirname(File.expand_path(__FILE__))
+    
+    # Generate a test file
+    in_file = File.join($base_dir, 'logo.png')
+    out_file = File.join($base_dir, 'testout.gif')
+    
+    `convert magick:logo #{in_file}`
+    
+    test_quick = lambda {
+      image_filename = 
+      20.times {
+      	i = QuickMagick::Image.read(in_file).first
+      	i.resize "100x100!"
+      	i.save out_file
+      }
+    }
+    
+    test_mini = lambda {
+      20.times {
+      	i = MiniMagick::Image.from_file(in_file)
+        i.combine_options do |c|
+          c.resize "100x100!"
+          c.format "gif"
+        end
+      	i.write out_file
+      }
+    }
+    
+    test_r = lambda {
+      20.times {
+      	i = Magick::Image.read(in_file).first
+      	i = i.change_geometry!('100x100!') { |cols, rows, img|
+      	  img.resize!(cols, rows)
+      	}
+      	i.write out_file
+      }
+    }
+    
+    puts "Test 1: resize a normal image"
+    bm(12) { |x|
+    	x.report("mini", &test_mini)
+    	x.report("quick", &test_quick)
+    	x.report("rmagick", &test_r)
+    }
+    
+    ##################################################
+    
+    in_file = File.join($base_dir, '9.gif')
+    out_file = File.join($base_dir, 'testout.gif')
+    
+    test_quick = lambda {
+    	i = QuickMagick::Image.read(in_file).first
+    	i.resize "8190x8190>"
+    	i.save out_file
+    }
+    
+    test_mini = lambda {
+    	i = MiniMagick::Image.from_file(in_file)
+      i.combine_options do |c|
+        c.resize "8190x8190>"
+        c.format "gif"
+      end
+    	i.write out_file
+    }
+    
+    test_r = lambda {
+    	i = Magick::Image.read(in_file).first
+    	i = i.change_geometry!('8190x8190>') { |cols, rows, img|
+    	  img.resize!(cols, rows)
+    	}
+    	i.write out_file
+    }
+    
+    puts "Test 2: resize a large image"
+    bm(12) { |x|
+    	x.report("mini", &test_mini)
+    	x.report("quick", &test_quick)
+      # Don't try RMagick! You'll regret that ... a lot :'(
+    #	x.report("rmagick", &test_r)
+    }
+    
+    ##################################################
+    
+    class String
+      CHARS = ("a".."z").to_a + ("1".."9").to_a 
+      def self.random(length)
+        Array.new(length, '').collect{CHARS[rand(CHARS.size)]}.join
+      end
+    end
+    
+    def generate_captcha(length, width, height)
+    	captcha = []
+    	String.random(6).chars.each_with_index do |c, i|
+    	  letter = {}
+    	  letter[:char] = c
+    	  letter[:x] = width * i / length + (rand - 0.5) * width / length / 8
+    	  letter[:y] = height / 5 + (rand - 0.5) * height / 2
+    	  letter[:sx] = rand * 90 - 45
+    	  letter[:bx] = width * i / length + (rand - 0.5) * width / length / 2
+    	  letter[:by] = height / 2 + (rand - 0.5) * height
+    	  captcha << letter
+    	end
+    	captcha
+    end
+    
+    out_file = File.join($base_dir, 'captcha.gif')
+    
+    test_quick = lambda {
+    	i = QuickMagick::Image.solid(290, 70, :white)
+    	i.bordercolor = :black
+    	i.border = 5
+    	i.fill = :black
+    	i.stroke = :black
+    	i.strokewidth =  1
+    	i.pointsize = 40
+    	i.gravity = :northwest
+    	captcha = generate_captcha(6, 290, 70)
+    	captcha.each do |letter|
+    		i.draw_text letter[:x], letter[:y], letter[:char], :skewx=>letter[:sx]
+    	end
+    	i.save out_file
+    }
+    
+    test_mini = lambda {
+    }
+    
+    test_r = lambda {
+    	i = Magick::Image.new(290, 70)
+    	gc = Magick::Draw.new
+    	i.border! 5, 5, "black"
+    	gc.stroke "black"
+    	gc.stroke_width 1
+    	gc.pointsize 40
+    	gc.gravity = Magick::NorthWestGravity
+    	captcha = generate_captcha(6, 290, 70)
+    	captcha.each do |letter|
+    		gc.skewx letter[:sx]
+    		gc.text letter[:x], letter[:y], letter[:char]
+    	end
+    	gc.fill "none"
+    	gc.draw i
+    	i.write out_file
+    }
+    
+    puts "Test 3: generate random captchas"
+    bm(12) { |x|
+    #	x.report("mini", &test_mini)
+    	x.report("quick", &test_quick)
+    	x.report("rmagick", &test_r)
+    }
+    # Cleanup temp files
+  ensure
+    %w{captcha.gif testout.gif logo.png}.each do |filename|
+      fullname = File.join($base_dir, filename)
+      File.delete(fullname) if File.exists?(fullname)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: quick_magick
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Ahmed ElDawy
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-05 00:00:00 +03:00
+date: 2009-08-12 00:00:00 +03:00
 default_executable: 
 dependencies: []
 
@@ -33,11 +33,11 @@ files:
 - Manifest
 - quick_magick.gemspec
 - test/image_test.rb
-- test/logo-small.jpg
 - test/badfile.xxx
 - test/multipage.tif
 - test/image_list_test.rb
-- test/imagemagick-logo.png
+- test/test_magick.rb
+- test/9.gif
 has_rdoc: true
 homepage: http://quickmagick.rubyforge.org/
 post_install_message: 
@@ -72,3 +72,4 @@ summary: QuickMagick allows you to access ImageMagick command line functions usi
 test_files: 
 - test/image_test.rb
 - test/image_list_test.rb
+- test/test_magick.rb