fleximage 1.0.0

data/lib/fleximage/operator/resize.rb

@@ -0,0 +1,92 @@
+module Fleximage
+  module Operator
+        
+    # Resize this image, constraining proportions.  Options allow cropping, stretching, upsampling and
+    # padding.
+    # 
+    #   image.resize(size, options = {})
+    # 
+    # +size+ is size of the output image after the resize operation.  Accepts either <tt>'123x456'</tt>
+    # format or <tt>[123, 456]</tt> format.
+    #
+    # Use the following keys in the +options+ hash:
+    #   
+    # * +crop+: pass true to this option to make the ouput image exactly 
+    #   the same dimensions as +size+.  The default behaviour will resize the image without
+    #   cropping any part meaning the image will be no bigger than the +size+.  When <tt>:crop</tt>
+    #   is true the final image is resized to fit as much as possible in the frame, and then crops it 
+    #   to make it exactly the dimensions declared by the +size+ argument.
+    #  
+    # * +upsample+: By default the image will never display larger than its original dimensions, 
+    #   no matter how large the +size+ argument is.  Pass +true+ to use this option to allow
+    #   upsampling, disabling the default behaviour.
+    #
+    # * +padding+: This option will pad the space around your image with a solid color to make it exactly the requested
+    #   size.  Pass +true+, for the default of +white+, or give it a text or pixel color like <tt>"red"</tt> or 
+    #   <tt>color(255, 127, 0)</tt>.  This is like the opposite of the +crop+ option.  Instead of trimming the 
+    #   image to make it exactly the requested size, it will make sure the entire image is visible, but adds space 
+    #   around the edges to make it the right dimensions.
+    #
+    # * +stretch+: Set this option to true and the image will not preserve its aspect ratio.  The final image will
+    #   stretch to fit the requested +size+.  The resulting image is exactly the size you ask for.
+    # 
+    # Example:
+    # 
+    #   @photo.operate do |image|
+    #     image.resize '200x200', :crop => true
+    #   end
+    class Resize < Operator::Base
+      def operate(size, options = {})
+        options = options.symbolize_keys
+        
+        # Find dimensions
+        x, y = size_to_xy(size)
+
+        # prevent upscaling unless :usample param exists.
+        unless options[:upsample]
+          x = @image.columns if x > @image.columns
+          y = @image.rows    if y > @image.rows
+        end
+
+        # Perform image resize
+        case
+        when options[:crop] && !options[:crop].is_a?(Hash) && @image.respond_to?(:crop_resized!)
+          # perform resize and crop
+          scale_and_crop([x, y])
+
+        when options[:stretch]
+          # stretch the image, ignoring aspect ratio
+          stretch([x, y])
+
+        else
+          # perform the resize without crop
+          scale([x, y])
+
+        end
+
+        # apply padding if necesary
+        if padding_color = options[:padding]
+          # get color
+          padding_color = 'white' if padding_color == true
+
+          # get original x and y.  This makes it play nice if the requested size is larger 
+          # than the image and upsampling is not allowed.
+          x, y = size_to_xy(size)
+
+          # get proper border sizes
+          x_border = [0, (x - @image.columns + 1) / 2].max
+          y_border = [0, (y - @image.rows    + 1) / 2].max
+
+          # apply padding
+          @image.border!(x_border, y_border, padding_color)
+
+          # crop to remove possible extra pixel
+          @image.crop!(0, 0, x, y, true)
+        end
+        
+        return @image
+      end
+    end
+    
+  end
+end

data/lib/fleximage/operator/shadow.rb

@@ -0,0 +1,87 @@
+module Fleximage
+  module Operator
+        
+    # Add a drop shadow to the image.
+    #
+    #   image.shadow(options = {})
+    # 
+    # Use the following keys in the +options+ hash:
+    #
+    # * +offset+: distance of the dropsahdow form the image, in FlexImage *size* format.  Positive
+    #   number move it down and right, negative numbers move it up and left.
+    #   
+    # * +blur+: how blurry the shadow is.  Roughly corresponds to distance in pixels of the blur.
+    # 
+    # * +background+: a color for the background of the image.  What the shadow fades into.  
+    #   Use an RMagick named color or use the +color+ method in FlexImage::Controller, or a
+    #   Magick::Pixel object.
+    #   
+    # * +color+: color of the shadow itself.
+    #   Use an RMagick named color or use the +color+ method in FlexImage::Controller, or a
+    #   Magick::Pixel object.
+    #   
+    # * +opacity+: opacity of the shadow.  A value between 0.0 and 1.0, where 1 is opaque and 0 is
+    #   transparent.
+    # 
+    # Example:
+    # 
+    #   @photo.operate do |image|
+    #     # Default settings
+    #     image.shadow(
+    #       :color      => 'black',    # or color(0, 0, 0)
+    #       :background => 'white',    # or color(255, 255, 255)
+    #       :blur       => 8,
+    #       :offset     => '2x2',
+    #       :opacity    => 0.75 
+    #     )
+    #     
+    #     # Huge, red shadow
+    #     image.shadow(
+    #       :color      => color(255, 0, 0),
+    #       :background => 'black',    # or color(255, 255, 255)
+    #       :blur       => 30,
+    #       :offset     => '20x10',
+    #       :opacity    => 1
+    #     )
+    #   end
+    class Shadow < Operator::Base
+      def operate(options = {})
+        options = options.symbolize_keys if options.respond_to?(:symbolize_keys)
+        defaults = {
+          :offset     => 2,
+          :blur       => 8,
+          :background => 'white',
+          :color      => 'black',
+          :opacity    => 0.75
+        }
+        options = options.is_a?(Hash) ? defaults.update(options) : defaults
+
+        # verify options
+        options[:offset] = size_to_xy(options[:offset])
+        options[:blur]   = options[:blur].to_i
+
+        options[:background]    = Magick::Pixel.from_color(options[:background]) unless options[:background].is_a?(Magick::Pixel)
+        options[:color]         = Magick::Pixel.from_color(options[:color])      unless options[:color].is_a?(Magick::Pixel)
+        options[:color].opacity = (1 - options[:opacity]) * 255
+
+        # generate shadow image
+        shadow = @image.dup
+        shadow.background_color = options[:color]
+        shadow.erase!
+        shadow.border!(options[:offset].max + options[:blur] * 3, options[:offset].max + options[:blur] * 3, options[:background])
+        shadow = shadow.blur_image(0, options[:blur] / 2)
+
+        # apply shadow
+        @image = shadow.composite(
+          @image, 
+          symbol_to_gravity(:top_left), 
+          (shadow.columns - @image.columns) / 2 - options[:offset][0], 
+          (shadow.rows    - @image.rows)    / 2 - options[:offset][1], 
+          symbol_to_blending_mode(:over)
+        )
+        @image.trim!
+      end
+    end
+    
+  end
+end

data/lib/fleximage/operator/text.rb

@@ -0,0 +1,104 @@
+module Fleximage
+  module Operator
+    
+    # Draw text on the image.  Customize size, position, color, dropshadow, and font.
+    # 
+    #   image.text(string_to_write, options = {})
+    #
+    # Use the following keys in the +options+ hash:
+    # 
+    # * alignment: symbol like in <tt>ImageOverlay</tt>
+    # * offset: size string
+    # * antialias: true or false
+    # * color: string or <tt>color(r, g, b)</tt>
+    # * font_size: integer
+    # * font: path to a font file relative to +RAILS_ROOT+
+    # * rotate: degrees as an integer
+    # * shadow: <tt>{:blur => 1, :opacity => 1.0}</tt>
+    # * font_weight: RMagick font weight constant or value. See: http://www.imagemagick.org/RMagick/doc/draw.html#font_weight
+    # * stroke: hash that, if present, will stroke the text.  The hash should have both <tt>:width</tt> (integer) and <tt>:color</tt> (string or color object).
+    #
+    # Example:
+    #
+    #   @photo.operate do |image|
+    #     image.text('I like Cheese',
+    #       :alignment => :top_left,
+    #       :offset => '300x150',
+    #       :antialias => true,
+    #       :color => 'pink',
+    #       :font_size => 24,
+    #       :font => 'path/to/myfont.ttf',
+    #       :rotate => -15,
+    #       :shadow => {
+    #         :blur => 1,
+    #         :opacity => 0.5,
+    #       },
+    #       :stroke => {
+    #         :width => 3,
+    #         :color => color(0, 0, 0),
+    #       }
+    #     )
+    #   end
+    class Text < Operator::Base
+      def operate(string_to_write, options = {})
+        options = {
+          :alignment  => :top_left,
+          :offset     => '0x0',
+          :antialias  => true,
+          :color      => 'black',
+          :font_size  => '12',
+          :font       => nil,
+          :text_align => :left,
+          :rotate     => 0,
+          :shadow     => nil,
+          :stroke     => {
+            :width => 0,
+            :color => 'white',
+          }
+        }.merge(options)
+        options[:offset] = size_to_xy(options[:offset])
+
+        # prepare drawing surface
+        text                = Magick::Draw.new
+        text.gravity        = symbol_to_gravity(options[:alignment])
+        text.fill           = options[:color]
+        text.text_antialias = options[:antialias]
+        text.pointsize      = options[:font_size].to_i
+        text.rotation       = options[:rotate]
+        text.font_weight    = options[:font_weight] if options[:font_weight]
+        
+        if options[:stroke][:width] > 0
+          text.stroke_width   = options[:stroke][:width]
+          text.stroke         = options[:stroke][:color]
+        end
+
+        # assign font path with to rails root unless the path is absolute
+        if options[:font]
+          font = options[:font]
+          font = "#{RAILS_ROOT}/#{font}" unless font =~ %r{^(~?|[A-Za-z]:)/}
+          text.font = font
+        end
+
+        # draw text on transparent image
+        temp_image = Magick::Image.new(@image.columns, @image.rows) { self.background_color = 'none' }
+        temp_image = temp_image.annotate(text, 0, 0, options[:offset][0], options[:offset][1], string_to_write)
+
+        # add drop shadow to text image
+        if options[:shadow]
+          shadow_args = [2, 2, 1, 1]
+          if options[:shadow].is_a?(Hash)
+            #shadow_args[0], shadow_args[1] = size_to_xy(options[:shadow][:offset]) if options[:shadow][:offset]
+            shadow_args[2] = options[:shadow][:blur]                               if options[:shadow][:blur]
+            shadow_args[3] = options[:shadow][:opacity]                            if options[:shadow][:opacity]
+          end
+          shadow = temp_image.shadow(*shadow_args)
+          temp_image = shadow.composite(temp_image, 0, 0, symbol_to_blending_mode(:over))
+        end
+
+        # composite text on original image
+        @image.composite!(temp_image, 0, 0, symbol_to_blending_mode(:over))
+      end
+    end
+    
+  end
+end

data/lib/fleximage/operator/trim.rb

@@ -0,0 +1,14 @@
+module Fleximage
+  module Operator
+    
+    # Trim off all the pixels around the image border that have the same color.
+    #
+    #   image.trim
+    class Trim < Operator::Base
+      def operate()
+        @image.trim!(true)
+      end
+    end
+    
+  end
+end

data/lib/fleximage/operator/unsharp_mask.rb

@@ -0,0 +1,36 @@
+module Fleximage
+  module Operator
+    
+    # Sharpen an image using an unsharp mask filter.
+    # 
+    #   image.unsharp_mask(options = {})
+    #
+    # Use the following keys in the +options+ hash:
+    #
+    # * +radius+: The radius of the Gaussian operator. The default is 0.0.
+    # * +sigma+: The standard deviation of the Gaussian operator. A good starting value is 1.0, which is the default.
+    # * +amount+: The percentage of the blurred image to be added to the receiver, specified as a fraction between 0 and 1.0. A good starting value is 1.0, which is the default.
+    # * +threshold+: The threshold needed to apply the amount, specified as a fraction between 0 and 1.0. A good starting value is 0.05, which is the default.
+    #
+    # Example:
+    #
+    #   @photo.operate do |image|
+    #     image.unsharp_mask
+    #   end
+    class UnsharpMask < Operator::Base
+      def operate(options = {})
+        options = options.symbolize_keys if options.respond_to?(:symbolize_keys)
+        options = {
+          :radius    => 0.0,
+          :sigma     => 1.0,
+          :amount    => 1.0,
+          :threshold => 0.05
+        }.merge(options)
+
+        # sharpen image
+        @image = @image.unsharp_mask(options[:radius], options[:sigma], options[:amount], options[:threshold])
+      end
+    end
+    
+  end
+end

data/lib/fleximage/rmagick_image_patch.rb

@@ -0,0 +1,5 @@
+class Magick::Image
+  def dispose!
+    destroy! if respond_to?(:destroy!)
+  end
+end

data/lib/fleximage/string_patch.rb

@@ -0,0 +1,5 @@
+unless "string".respond_to?(:present?)
+  class String
+    alias_method :present?, :present?
+  end
+end

data/lib/fleximage/view.rb

@@ -0,0 +1,57 @@
+module Fleximage
+  
+  # Renders a .flexi template
+  class View < ActionView::TemplateHandler #:nodoc:
+    class TemplateDidNotReturnImage < RuntimeError #:nodoc:
+    end
+    
+    def self.call(template)
+      "Fleximage::View.new(self).render(template)"
+    end
+
+    def initialize(action_view)
+      @view = action_view
+    end
+    
+    def render(template)
+      # process the view
+      result = @view.instance_eval do
+        
+        # Shorthand color creation
+        def color(*args)
+          Fleximage::Operator::Base.color(*args)
+        end
+        
+        #execute the template
+        eval(template.source)
+      end
+      
+      # Raise an error if object returned from template is not an image record
+      unless result.class.include?(Fleximage::Model::InstanceMethods)
+        raise TemplateDidNotReturnImage, 
+                ".flexi template was expected to return a model instance that acts_as_fleximage, but got an instance of <#{result.class}> instead."
+      end
+      
+      # Figure out the proper format
+      requested_format = (@view.params[:format] || :jpg).to_sym
+      unless [:jpg, :gif, :png].include?(requested_format)
+        raise 'Image must be requested with an image type format.  jpg, gif and png only are supported.'
+      end
+      
+      # Set proper content type
+      @view.controller.response.content_type = Mime::Type.lookup_by_extension(requested_format.to_s).to_s
+      
+      # Set proper caching headers
+      if defined?(Rails) && Rails.env == 'production'
+        @view.controller.response.headers['Cache-Control'] = 'public, max-age=86400'
+      end
+      
+      # return rendered result
+      return result.output_image(:format => requested_format)
+    ensure
+    
+      # ensure garbage collection happens after every flex image render
+      GC.start
+    end
+  end
+end

data/tasks/fleximage_tasks.rake

@@ -0,0 +1,154 @@
+namespace :fleximage do
+  
+  # Find the model class
+  def model_class
+    raise 'You must specify a FLEXIMAGE_CLASS=MyClass' unless ENV['FLEXIMAGE_CLASS']
+    @model_class ||= ENV['FLEXIMAGE_CLASS'].camelcase.constantize
+  end
+  
+  desc "Populate width and height magic columns from the current image store.  Useful when migrating from on old installation."
+  task :dimensions => :environment do
+    model_class.find(:all).each do |obj|
+      if obj.has_image?
+        img = obj.load_image
+        obj.update_attribute :image_width,  img.columns if obj.respond_to?(:image_width=)
+        obj.update_attribute :image_height, img.rows    if obj.respond_to?(:image_height=)
+      end
+    end
+  end
+  
+  namespace :convert do
+        
+    def convert_directory_format(to_format)
+      model_class.find(:all).each do |obj|
+        
+        # Get the creation date
+        creation = obj[:created_at] || obj[:created_on]
+        
+        # Generate both types of file paths
+        flat_path   = "#{RAILS_ROOT}/#{model_class.image_directory}/#{obj.id}.#{model_class.image_storage_format}"
+        nested_path = "#{RAILS_ROOT}/#{model_class.image_directory}/#{creation.year}/#{creation.month}/#{creation.day}/#{obj.id}.#{model_class.image_storage_format}" 
+        
+        # Assign old path and new path based on desired directory format
+        if to_format == :nested
+          old_path = flat_path
+          new_path = nested_path
+        else
+          old_path = nested_path
+          new_path = flat_path
+        end
+        
+        # Move the files
+        if old_path != new_path && File.exists?(old_path)
+          FileUtils.mkdir_p(File.dirname(new_path))
+          FileUtils.move old_path, new_path
+          puts "#{old_path} -> #{new_path}"
+        end
+      end
+    end
+    
+    def convert_image_format(to_format)
+      model_class.find(:all).each do |obj|
+        
+        # convert DB stored images
+        if model_class.db_store?
+          if obj.image_file_data && obj.image_file_data.any?
+            begin
+              image = Magick::Image.from_blob(obj.image_file_data).first
+              image.format = to_format.to_s.upcase
+              obj.image_file_data = image.to_blob
+              obj.save
+            rescue Exception => e
+              puts "Could not convert image for #{model_class} with id #{obj.id}\n  #{e.class} #{e}\n"
+            end
+          end
+        
+        # Convert file system stored images
+        else        
+          # Generate both types of file paths
+          png_path = obj.file_path.gsub(/\.jpg$/, '.png')
+          jpg_path = obj.file_path.gsub(/\.png$/, '.jpg')
+        
+          # Output stub
+          output = (to_format == :jpg) ? 'PNG -> JPG' : 'JPG -> PNG'
+        
+          # Assign old path and new path based on desired image format
+          if to_format == :jpg
+            old_path = png_path
+            new_path = jpg_path
+          else
+            old_path = jpg_path
+            new_path = png_path
+          end
+        
+          # Perform conversion
+          if File.exists?(old_path)
+            image = Magick::Image.read(old_path).first
+            image.format = to_format.to_s.upcase
+            image.write(new_path)
+            File.delete(old_path)
+          
+            puts "#{output} : Image #{obj.id}"
+          end
+        end
+      end
+    end
+    
+    def ensure_db_store
+      col = model_class.columns.find {|c| c.name == 'image_file_data'}
+      unless col && col.type == :binary
+        raise "No image_file_data field of type :binary for this model!"
+      end
+    end
+    
+    desc "Convert a flat images/123.png style image store to a images/2007/11/12/123.png style.  Requires FLEXIMAGE_CLASS=ModelName"
+    task :to_nested => :environment do
+      convert_directory_format :nested
+    end
+    
+    desc "Convert a nested images/2007/11/12/123.png style image store to a images/123.png style.  Requires FLEXIMAGE_CLASS=ModelName"
+    task :to_flat => :environment do
+      convert_directory_format :flat
+    end
+    
+    desc "Convert master images stored as JPGs to PNGs"
+    task :to_png => :environment do
+      convert_image_format :png
+    end
+    
+    desc "Convert master images stored as PNGs to JPGs"
+    task :to_jpg => :environment do
+      convert_image_format :jpg
+    end
+    
+    desc "Convert master image storage to use the database.  Loads all file-stored images into the database."
+    task :to_db => :environment do
+      ensure_db_store
+      model_class.find(:all).each do |obj|
+        if File.exists?(obj.file_path)
+          File.open(obj.file_path, 'rb') do |f|
+            obj.image_file_data = f.read
+            obj.save
+          end
+        end
+      end
+      
+      puts "--- All images successfully moved to the database.  Check to make sure the transfer worked cleanly before deleting your file system image store."
+    end
+    
+    desc "Convert master image storage to use the file system.  Loads all database images into files."
+    task :to_filestore => :environment do
+      ensure_db_store
+      model_class.find(:all).each do |obj|
+        if obj.image_file_data && obj.image_file_data.any?
+          File.open(obj.file_path, 'wb+') do |f|
+            f.write obj.image_file_data
+          end
+        end
+      end
+      
+      puts "--- All images successfully moved to the file system.  Remember to remove your image_file_data field from your models database table."
+    end
+    
+  end
+end