rszr 0.5.2 → 1.0.0

data/lib/rszr/image.rb

@@ -1,20 +1,50 @@
 module Rszr
   class Image
-
+    GRAVITIES = [true, :center, :n, :nw, :w, :sw, :s, :se, :e, :ne].freeze
+    
+    extend Identification
+    include Buffered
+    include Orientation
+    
     class << self
-      
-      def load(path, options = {})
+
+      def load(path, autorotate: Rszr.autorotate, **opts)
         path = path.to_s
         raise FileNotFound unless File.exist?(path)
-        _load(path)
+        image = _load(path)
+        autorotate(image, path) if autorotate
+        image
       end
       alias :open :load
       
+      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 dimensions
       [width, height]
     end
+    
+    def format
+      fmt = _format
+      fmt == 'jpg' ? 'jpeg' : fmt
+    end
+    
+    def format=(fmt)
+      fmt = fmt.to_s if fmt.is_a?(Symbol)
+      self._format = fmt
+    end
+    
+    def [](x, y)
+      if x >= 0 && x <= width - 1 && y >= 0 && y <= height - 1
+        Color::RGBA.new(*_pixel(x, y))
+      end
+    end
 
     def inspect
       fmt = format
@@ -22,30 +52,116 @@ module Rszr
       "#<#{self.class.name}:0x#{object_id.to_s(16)} #{width}x#{height}#{fmt}>"
     end
 
-    def resize(*args)
-      _resize(false, *calculate_size(*args))
-    end
+    module Transformations
+      def resize(*args, **opts)
+        _resize(false, *calculate_size(*args,  **opts))
+      end
 
-    def resize!(*args)
-      _resize(true, *calculate_size(*args))
-    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(false, x, y, width, height)
+      end
 
-    def crop!(x, y, width, height)
-      _crop(true, 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)
+      def turn!(orientation)
+        orientation = orientation.abs + 2 if orientation.negative?
+        _turn!(orientation % 4)
+      end
+    
+      def rotate(deg)
+        _rotate(false, deg.to_f * Math::PI / 180.0)
+      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 sharpen(radius)
+        dup.sharpen!(radius)
+      end
+    
+      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)
-      format ||= format_from_filename(path) || 'jpg'
-      _save(path.to_s, format.to_s)
+    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
@@ -56,53 +172,115 @@ 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 calculate_size(*args)
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      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
+    def calculate_size(*args, crop: nil, skew: nil, inflate: true)
+      #options = args.last.is_a?(Hash) ? args.pop : {}
+      #assert_valid_keys options, :crop, :background, :skew  #:extend, :width, :height, :max_width, :max_height, :box
       if args.size == 1
-        scale = args.first
-        raise ArgumentError, "scale #{scale.inspect} out of range" unless scale > 0 && scale < 1
-        new_width = original_width.to_f * scale
-        new_height = original_height.to_f * scale
+        calculate_size_for_scale(args.first)
       elsif args.size == 2
         box_width, box_height = args
-        if :auto == box_width && box_height.is_a?(Numeric)
-          new_height = box_height
-          new_width = box_height.to_f / original_height.to_f * original_width.to_f
-        elsif box_width.is_a?(Numeric) && :auto == box_height
-          new_width = box_width
-          new_height = box_width.to_f / original_width.to_f * original_height.to_f
+        if args.include?(:auto)
+          calculate_size_for_auto(box_width, box_height)
         elsif box_width.is_a?(Numeric) && box_height.is_a?(Numeric)
-          if options[:skew]
-            new_width, new_height = box_width, box_height
-          elsif options[:crop]
-            # TODO: calculate x, y offset if crop
+          if not inflate and width <= box_width and height <= box_height
+            [0, 0, width, height, width, height]
+          elsif skew
+            calculate_size_for_skew(box_width, box_height)
+          elsif crop
+            calculate_size_for_crop(box_width, box_height, crop)
           else
-            scale = original_width.to_f / original_height.to_f
-            box_scale = box_width.to_f / box_height.to_f
-            if scale >= box_scale # wider
-              new_width = box_width
-              new_height = original_height.to_f * box_width.to_f / original_width.to_f
-            else # narrower
-              new_height = box_height
-              new_width = original_width.to_f * box_height.to_f / original_height.to_f
-            end
+            calculate_size_for_limit(box_width, box_height)
           end
-        else
-          raise ArgumentError, "unconclusive arguments #{args.inspect} #{options.inspect}"
         end
       else
         raise ArgumentError, "wrong number of arguments (#{args.size} for 1..2)"
       end
-      [x, y, original_width, original_height, new_width.round, new_height.round]
     end
     
+    def calculate_size_for_scale(factor)
+      raise ArgumentError, "scale factor #{factor.inspect} out of range" unless factor > 0 && factor < 1
+      [0, 0, width, height, (width.to_f * factor).round, (height.to_f * factor).round]
+    end
+    
+    def calculate_size_for_skew(box_width, box_height)
+      [0, 0, width, height, box_width, box_height]
+    end
+
+    def calculate_size_for_auto(box_width, box_height)
+      if :auto == box_width && box_height.is_a?(Numeric)
+        new_height = box_height
+        new_width = (box_height.to_f / height.to_f * width.to_f).round
+      elsif box_width.is_a?(Numeric) && :auto == box_height
+        new_width = box_width
+        new_height = (box_width.to_f / width.to_f * height.to_f).round
+      else
+        raise ArgumentError, "unconclusive arguments #{box_width.inspect}, #{box_height.inspect}"
+      end
+      [0, 0, width, height, new_width, new_height]
+    end
+
+    def calculate_size_for_crop(box_width, box_height, crop)
+      raise ArgumentError, "invalid crop gravity" unless GRAVITIES.include?(crop)
+      aspect = width.to_f / height.to_f
+      box_aspect = box_width.to_f / box_height.to_f
+      if aspect >= box_aspect # wider than box
+        src_width = (box_width.to_f * height.to_f / box_height.to_f).round
+        src_height = height
+        x = crop_horizontally(src_width, crop)
+        y = 0
+      else # narrower than box
+        src_width = width
+        src_height = (box_height.to_f * width.to_f / box_width.to_f).round
+        x = 0
+        y = crop_vertically(src_height, crop)
+      end
+      [x, y, src_width, src_height, box_width, box_height]
+    end
+    
+    def crop_horizontally(src_width, crop)
+      case crop
+      when :nw, :w, :sw then 0
+      when :ne, :e, :se then width - src_width
+      else
+        ((width - src_width).to_f / 2.to_f).round
+      end
+    end
+    
+    def crop_vertically(src_height, crop)
+      case crop
+      when :nw, :n, :ne then 0
+      when :sw, :s, :se then height - src_height
+      else
+        ((height - src_height).to_f / 2.to_f).round
+      end
+    end
+    
+    def calculate_size_for_limit(box_width, box_height)
+      scale = width.to_f / height.to_f
+      box_scale = box_width.to_f / box_height.to_f
+      if scale >= box_scale # wider
+        new_width = box_width
+        new_height = (height.to_f * box_width.to_f / width.to_f).round
+      else # narrower
+        new_height = box_height
+        new_width = (width.to_f * box_height.to_f / height.to_f).round
+      end
+      [0, 0, width, height, new_width, new_height]
+    end
+
     def format_from_filename(path)
-      File.extname(path)[1..-1]
+      File.extname(path)[1..-1].to_s.downcase
+    end
+    
+    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 assert_valid_keys(hsh, *valid_keys)

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, inflate: false, **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, gravity: :center, **options)
+        thumbnail(width, height, crop: gravity, **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)
+      @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, @data.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.5.2"
+  VERSION = '1.0.0'
 end

data/lib/rszr.rb

@@ -1,6 +1,27 @@
 require 'rbconfig'
 require 'pathname'
+require 'tempfile'
+require 'stringio'
 
 require 'rszr/rszr'
 require 'rszr/version'
+require 'rszr/stream'
+require 'rszr/identification'
+require 'rszr/orientation'
+require 'rszr/buffered'
+require 'rszr/color'
 require 'rszr/image'
+
+module Rszr
+  class << self
+    @@autorotate = nil
+    
+    def autorotate
+      @@autorotate
+    end
+  
+    def autorotate=(value)
+      @@autorotate = !!value
+    end
+  end
+end