rszr 0.4.0 → 0.8.0

data/lib/rszr/image.rb

@@ -1,97 +1,161 @@
 module Rszr
   class Image
-    include Base
-
+    extend Identification
+    include Buffered
+    include Orientation
+    
     class << self
-      
-      alias_method :instantiate, :new
-      protected :instantiate
-      
-      def new(width, height)
-        ptr = with_lock { imlib_create_image(width, height) }
-        raise Error, 'Could not instantiate image' if ptr.null?
-        instantiate(ptr)
-      end
-            
-      def load(path, options = {})
+
+      def load(path, autorotate: Rszr.autorotate, **opts)
         path = path.to_s
         raise FileNotFound unless File.exist?(path)
-        load_error = LoadError.new
-        ptr = with_lock do
-          imlib_set_cache_size(0)
-          imlib_load_image_with_error_return(path, load_error.ptr)
-        end
-        raise load_error, load_error.message if ptr.null?
-        return instantiate(ptr)
+        image = _load(path)
+        autorotate(image, path) if autorotate
+        image
       end
       alias :open :load
       
-      protected
-      
-      def finalize(ptr)
-        with_lock do
-          imlib_context_set_image(ptr)
-          imlib_free_image
+      def load_data(data, autorotate: Rszr.autorotate, **opts)
+        raise LoadError, 'Unknown format' unless format = identify(data)
+        with_tempfile(format, data) do |file|
+          load(file.path, autorotate: autorotate, **opts)
         end
       end
-      
-    end
-    
-    def initialize(ptr)
-      @handle = Handle.new(self, ptr)
-    end
-    
-    def width
-      with_image { imlib_image_get_width }
-    end
-    
-    def height
-      with_image { imlib_image_get_height }
+
     end
-    
+
     def dimensions
       [width, height]
     end
     
     def format
-      str_ptr = with_image { imlib_image_format }
-      return if str_ptr.null?
-      str_ptr.to_s
+      fmt = _format
+      fmt == 'jpg' ? 'jpeg' : fmt
     end
     
-    def resize(*args)
-      instantiate(create_resized_image(*args))
+    def format=(fmt)
+      fmt = fmt.to_s if fmt.is_a?(Symbol)
+      self._format = fmt
     end
-    
-    def resize!(*args)
-      handle.replace!(create_resized_image(*args))
-      self
+
+    def inspect
+      fmt = format
+      fmt = " #{fmt.upcase}" if fmt
+      "#<#{self.class.name}:0x#{object_id.to_s(16)} #{width}x#{height}#{fmt}>"
     end
+
+    module Transformations
+      def resize(*args, **opts)
+        _resize(false, *calculate_size(*args,  **opts))
+      end
+
+      def resize!(*args, **opts)
+        _resize(true, *calculate_size(*args, **opts))
+      end
+
+      def crop(x, y, width, height)
+        _crop(false, x, y, width, height)
+      end
+
+      def crop!(x, y, width, height)
+        _crop(true, x, y, width, height)
+      end
+      
+      def turn(orientation)
+        dup.turn!(orientation)
+      end
+
+      def turn!(orientation)
+        orientation = orientation.abs + 2 if orientation.negative?
+        _turn!(orientation % 4)
+      end
     
-    def crop(*args)
-      instantiate(create_cropped_image(*args))
-    end
+      def rotate(deg)
+        _rotate(false, deg.to_f * Math::PI / 180.0)
+      end
     
-    def crop!(*args)
-      handle.replace!(create_cropped_image(*args))
-      self
-    end
+      def rotate!(deg)
+        _rotate(true, deg.to_f * Math::PI / 180.0)
+      end
+      
+      # horizontal
+      def flop
+        dup.flop!
+      end
+      
+      # vertical
+      def flip
+        dup.flip!
+      end
     
-    def save(path, format = nil)
-      with_image do
-        format ||= format_from_filename(path) || 'jpg'
-        imlib_image_set_format(format)
-        save_error = SaveError.new
-        imlib_save_image_with_error_return(path, save_error.ptr)
-        raise save_error, save_error.message if save_error.error?
-        true
+      def sharpen(radius)
+        dup.sharpen!(radius)
       end
-    end
     
-    def inspect
-      "#<#{self.class.name}:0x#{object_id.to_s(16)} width=#{width} height=#{height} format=#{format.inspect}>"
+      def sharpen!(radius)
+        raise ArgumentError, 'illegal radius' if radius < 0
+        _sharpen!(radius)
+      end
+    
+      def blur(radius)
+        dup.blur!(radius)
+      end
+    
+      def blur!(radius)
+        raise ArgumentError, 'illegal radius' if radius < 0
+        _sharpen!(-radius)
+      end
+      
+      def filter(filter_expr)
+        dup.filter!(filter_expr)
+      end
+      
+      def brighten!(value, r: nil, g: nil, b: nil, a: nil)
+        raise ArgumentError, 'illegal brightness' if value > 1 || value < -1
+        filter!("colormod(brightness=#{value.to_f});")
+      end
+      
+      def brighten(*args, **opts)
+        dup.brighten!(*args, **opts)
+      end
+      
+      def contrast!(value, r: nil, g: nil, b: nil, a: nil)
+        raise ArgumentError, 'illegal contrast (must be > 0)' if value < 0
+        filter!("colormod(contrast=#{value.to_f});")
+      end
+      
+      def contrast(*args, **opts)
+        dup.contrast!(*args, **opts)
+      end
+      
+      def gamma!(value, r: nil, g: nil, b: nil, a: nil)
+        #raise ArgumentError, 'illegal gamma (must be > 0)' if value < 0
+        filter!("colormod(gamma=#{value.to_f});")
+      end
+      
+      def gamma(*args, **opts)
+        dup.gamma!(*args, **opts)
+      end
     end
     
+    include Transformations
+
+    def save(path, format: nil, quality: nil)
+      format ||= format_from_filename(path) || self.format || 'jpg'
+      raise ArgumentError, "invalid quality #{quality.inspect}" if quality && !(0..100).cover?(quality)
+      ensure_path_is_writable(path)
+      _save(path.to_s, format.to_s, quality)
+    end
+    
+    def save_data(format: nil, quality: nil)
+      format ||= self.format || 'jpg'
+      with_tempfile(format) do |file|
+        save(file.path, format: format, quality: quality)
+        file.rewind
+        file.read
+      end
+    end
+
     private
     
     # 0.5               0 < scale < 1
@@ -100,16 +164,16 @@ module Rszr
     # :auto, 300        auto width, fit height
     # 400, 300, crop: :center_middle
     # 400, 300, background: rgba
-    # 400, 300, aspect: false
+    # 400, 300, skew: true
     
-    def create_resized_image(*args)
+    def calculate_size(*args, crop: nil, skew: nil)
       options = args.last.is_a?(Hash) ? args.pop : {}
-      assert_valid_keys options, :crop, :background, :skew  #:extend, :width, :height, :max_width, :max_height, :box
+      #assert_valid_keys options, :crop, :background, :skew  #:extend, :width, :height, :max_width, :max_height, :box
       original_width, original_height = width, height
       x, y, = 0, 0
       if args.size == 1
         scale = args.first
-        raise ArgumentError, "scale #{scale.inspect} out of range" unless scale > 0 && scale < 1
+        raise ArgumentError, "scale factor #{scale.inspect} out of range" unless scale > 0 && scale < 1
         new_width = original_width.to_f * scale
         new_height = original_height.to_f * scale
       elsif args.size == 2
@@ -121,9 +185,9 @@ module Rszr
           new_width = box_width
           new_height = box_width.to_f / original_width.to_f * original_height.to_f
         elsif box_width.is_a?(Numeric) && box_height.is_a?(Numeric)
-          if options[:skew]
+          if skew
             new_width, new_height = box_width, box_height
-          elsif options[:crop]
+          elsif crop
             # TODO: calculate x, y offset if crop
           else
             scale = original_width.to_f / original_height.to_f
@@ -142,38 +206,27 @@ module Rszr
       else
         raise ArgumentError, "wrong number of arguments (#{args.size} for 1..2)"
       end
-      resized_ptr = with_image do
-        imlib_context_set_anti_alias(1)
-        imlib_create_cropped_scaled_image(x, y, imlib_image_get_width, imlib_image_get_height, new_width.round, new_height.round)
-      end
-      raise TransformationError, "error resizing image" if resized_ptr.null?
-      resized_ptr
-    end
-    
-    def create_cropped_image(x, y, width, height)
-      cropped_ptr = with_image { imlib_create_cropped_image(x, y, width, height) }
-      raise TransformationError, 'error cropping image' if cropped_ptr.null?
-      cropped_ptr
+      [x, y, original_width, original_height, new_width.round, new_height.round]
     end
-    
+
     def format_from_filename(path)
-      File.extname(path)[1..-1]
+      File.extname(path)[1..-1].to_s.downcase
     end
     
-    def context_set_image
-      imlib_context_set_image(ptr)
+    def ensure_path_is_writable(path)
+      path = Pathname.new(path)
+      path.dirname.realpath.writable?
+    rescue Errno::ENOENT => e
+      raise SaveError, 'Non-existant path component'
+    rescue SystemCallError => e
+      raise SaveError, e.message
     end
-    
-    def with_image
-      with_lock do
-        context_set_image
-        yield
+
+    def assert_valid_keys(hsh, *valid_keys)
+      if unknown_key = (hsh.keys - valid_keys).first
+        raise ArgumentError.new("Unknown key: #{unknown_key.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}")
       end
     end
     
-    def instantiate(ptr)
-      self.class.send(:instantiate, ptr)
-    end
-    
   end
 end

data/lib/rszr/image_processing.rb

@@ -0,0 +1,82 @@
+require 'rszr'
+require 'image_processing'
+
+module ImageProcessing
+  module Rszr
+    extend Chainable
+
+    class << self
+      
+      # Returns whether the given image file is processable.
+      def valid_image?(file)
+        ::Rszr::Image.load(file).width
+        true
+      rescue ::Rszr::Error
+        false
+      end
+      
+    end
+
+    class Processor < ImageProcessing::Processor
+      accumulator :image, ::Rszr::Image
+
+      class << self
+
+        # Loads the image on disk into a Rszr::Image object
+        def load_image(path_or_image, **options)
+          if path_or_image.is_a?(::Rszr::Image)
+            path_or_image
+          else
+            ::Rszr::Image.load(path_or_image)
+          end
+          # TODO: image = image.autorot if autorot && !options.key?(:autorotate)
+        end
+
+        # Writes the image object to disk. 
+        # Accepts additional options (quality, format).
+        def save_image(image, destination_path, **options)
+          image.save(destination_path, **options)
+        end
+
+        # Calls the operation to perform the processing. If the operation is
+        # defined on the processor (macro), calls it. Otherwise calls the
+        # bang variant of the method directly on the Rszr image object.
+        def apply_operation(accumulator, (name, args, block))
+          return super if method_defined?(name)
+          accumulator.send("#{name}!", *args, &block)
+        end
+
+      end
+      
+      # Resizes the image to not be larger than the specified dimensions.
+      def resize_to_limit(width, height, **options)
+        width, height = default_dimensions(width, height)
+        thumbnail(width, height, **options)
+      end
+
+      # Resizes the image to fit within the specified dimensions.
+      def resize_to_fit(width, height, **options)
+        width, height = default_dimensions(width, height)
+        thumbnail(width, height, **options)
+      end
+
+      # Resizes the image to fill the specified dimensions, applying any
+      # necessary cropping.
+      def resize_to_fill(width, height, **options)
+        thumbnail(width, height, crop: :center, **options)
+      end
+
+      private
+
+      def thumbnail(width, height, **options)
+        image.resize!(width, height, **options)
+      end
+
+      def default_dimensions(width, height)
+        raise Error, 'either width or height must be specified' unless width || height
+        [width || :auto, height || :auto]
+      end
+
+    end
+  end
+end

data/lib/rszr/orientation.rb

@@ -0,0 +1,107 @@
+module Rszr
+  module Orientation
+    ROTATIONS = { 5 => 1, 6 => 1, 3 => 2, 4 => 2, 7 => 3, 8 => 3 }
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.attr_reader :original_orientation
+    end
+    
+    module ClassMethods
+    
+      private
+    
+      def autorotate(image, path)
+        return unless %w[jpeg tiff].include?(image.format)
+        File.open(path) do |file|
+          if orientation = send("parse_#{image.format}_orientation", file) and (1..8).member?(orientation)
+            image.instance_variable_set :@original_orientation, orientation
+            image.flop! if [2, 4, 5, 7].include?(orientation)
+            image.turn!(ROTATIONS[orientation]) if ROTATIONS.key?(orientation)
+          end
+        end
+      end
+    
+      def parse_tiff_orientation(data)
+        exif_parse_orientation(Stream.new(data))
+      end
+    
+      def parse_jpeg_orientation(data)
+        stream = Stream.new(data)
+        exif = nil
+        state = nil
+        loop do
+          state = case state
+          when nil
+            stream.skip(2)
+            :started
+          when :started
+            stream.read_byte == 0xFF ? :sof : :started
+          when :sof
+            case stream.read_byte
+            when 0xe1 # APP1
+              skip_chars = stream.read_int - 2
+              app1 = Stream.new(stream.read(skip_chars))
+              if app1.read(4) == 'Exif'
+                app1.skip(2)
+                orientation = exif_parse_orientation(app1.fast_forward)# rescue nil
+                return orientation
+              end
+              :started
+            when 0xe0..0xef
+              :skipframe
+            when 0xC0..0xC3, 0xC5..0xC7, 0xC9..0xCB, 0xCD..0xCF
+              :readsize
+            when 0xFF
+              :sof
+            else
+              :skipframe
+            end
+          when :skipframe
+            skip_chars = stream.read_int - 2
+            stream.skip(skip_chars)
+            :started
+          when :readsize
+            # stream.skip(3)
+            # height = stream.read_int
+            # width = stream.read_int
+            return exif&.orientation
+          end
+        end
+      end
+    
+      def exif_byte_order(stream)
+        byte_order = stream.read(2)
+        case byte_order
+        when 'II'
+          %w[v V]
+        when 'MM'
+          %w[n N]
+        else
+          raise LoadError
+        end
+      end
+
+      def exif_parse_ifd(stream, short)
+        tag_count = stream.read(2).unpack(short)[0]
+        tag_count.downto(1) do
+          type = stream.read(2).unpack(short)[0]
+          stream.read(6)
+          data = stream.read(2).unpack(short)[0]
+          return data if 0x0112 == type
+          stream.read(2)
+        end
+        nil
+      end
+
+      def exif_parse_orientation(stream)
+        short, long = exif_byte_order(stream)
+        stream.read(2) # 42
+        offset = stream.read(4).unpack(long)[0]
+        stream.skip(offset - 8)
+        exif_parse_ifd(stream, short)
+      end
+    end
+    
+  end
+end

data/lib/rszr/stream.rb

@@ -0,0 +1,61 @@
+module Rszr
+  class Stream
+    attr_reader :pos, :data
+    protected :data
+
+    def initialize(data, start: 0)
+      raise ArgumentError, 'start must be > 0' if start < 0
+      @data = case data
+        when IO then data
+        when String then StringIO.new(data)
+        when Stream then data.data
+      else
+        raise ArgumentError, "data must be File or String, got #{data.class}"
+      end
+      @data.binmode
+      @data.seek(start, IO::SEEK_CUR)
+      @pos = 0
+    end
+    
+    def read(n)
+      @data.read(n).tap { @pos += n }
+    end
+    
+    def peek(n)
+      old_pos = @data.pos
+      @data.read(n)
+    ensure
+      @data.pos = old_pos
+    end
+    
+    def skip(n)
+      @data.seek(n, IO::SEEK_CUR).tap { @pos += n }
+    end
+
+    def substream
+      self.class.new(self, pos)
+    end
+
+    def fast_forward
+      @pos = 0
+      self
+    end
+
+    def read_byte
+      read(1)[0].ord
+    end
+
+    def read_int
+      read(2).unpack('n')[0]
+    end
+
+    def read_string_int
+      value = []
+      while read(1) =~ /(\d)/
+        value << $1
+      end
+      value.join.to_i
+    end
+
+  end
+end

data/lib/rszr/version.rb

@@ -1,3 +1,3 @@
 module Rszr
-  VERSION = "0.4.0"
+  VERSION = '0.8.0'
 end

data/lib/rszr.rb

@@ -1,12 +1,26 @@
-require 'fiddle'
-require 'fiddle/import'
 require 'rbconfig'
 require 'pathname'
+require 'tempfile'
+require 'stringio'
 
+require 'rszr/rszr'
 require 'rszr/version'
-require 'rszr/errors'
-require 'rszr/lib'
-require 'rszr/lock'
-require 'rszr/handle'
-require 'rszr/base'
+require 'rszr/stream'
+require 'rszr/identification'
+require 'rszr/orientation'
+require 'rszr/buffered'
 require 'rszr/image'
+
+module Rszr
+  class << self
+    @@autorotate = nil
+    
+    def autorotate
+      @@autorotate
+    end
+  
+    def autorotate=(value)
+      @@autorotate = !!value
+    end
+  end
+end