rszr 0.5.3 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7322db19722cd5afc93e887fabe4031fa3a3064949956dc3bac562299918f10
-  data.tar.gz: 8c03c8922f29d3f7989f427018e7baeb6f09c4c9f561fef1b6a92a80f4042ec8
+  metadata.gz: 51f96b1754949daff45bf2d18b32d2857d5b82f33c285b85bbaf5fdb25d12f0b
+  data.tar.gz: 956217311a71053dcf0a781afa306b4f27c49ff4b00487e7d470f9290b91a0c4
 SHA512:
-  metadata.gz: 82b7c3ea10061666bacd712c39319ef36f19b2aecce3fa89556c591c0ef6f2cedf10b0fb1ed4ee6ac8613cfb40904b7e42306cd08d247d2653ca3135450244ba
-  data.tar.gz: 52cac4fe43b0feb24e6fb837fdbed69bb4c91e53807ef5d5821c5ab1793d41a698632e1b342e8b14fed0219db080d05179d37eeb6fcef91e8052b66205c2ab07
+  metadata.gz: 5fd6b4f8cf30f5f0a811b802aed1ab6dcfd709bdde3c803689d700276f6c0a996d5a93ecaee2587679097cb6faddea689296788c773215ff19ac4033191ee2ea
+  data.tar.gz: 7fc2f31485281ed5ccfc2b7c679fbda4cb03baa261aee18e661331dbc71adb5f98db8015aae46bbea6f27f016bd2f641ca7e46b12f6d5cebe975e09240b25d0b

data/README.md

@@ -1,4 +1,4 @@
-[![Gem Version](https://badge.fury.io/rb/rszr.svg)](http://badge.fury.io/rb/rszr) [![Build Status](https://travis-ci.org/mtgrosser/rszr.svg)](https://travis-ci.org/mtgrosser/rszr)
+[![Gem Version](https://badge.fury.io/rb/rszr.svg)](http://badge.fury.io/rb/rszr) [![build](https://github.com/mtgrosser/rszr/actions/workflows/build.yml/badge.svg)](https://github.com/mtgrosser/rszr/actions/workflows/build.yml)
 # Rszr - fast image resizer for Ruby
 
 Rszr is an image resizer for Ruby based on the Imlib2 library.
@@ -14,7 +14,7 @@ gem 'rszr'
 
 ### Imlib2
 
-Rszr requires the Imlib2 library to do the heavy lifting.
+Rszr requires the `Imlib2` library to do the heavy lifting.
 
 #### OS X
 
@@ -28,10 +28,14 @@ brew install imlib2
 
 Using your favourite package manager:
 
+##### RedHat-based
+
 ```bash
 yum install imlib2 imlib2-devel
 ```
 
+##### Debian-based
+
 ```bash
 apt-get install libimlib2 libimlib2-dev
 ```
@@ -50,12 +54,25 @@ image.save('resized.jpg')
 image.save('resized.png')
 ```
 
+### Image info
+```ruby
+image.width => 400
+image.height => 300
+image.dimensions => [400, 300]
+image.format => "jpeg"
+image[0, 0] => <Rszr::Color::RGBA @red=38, @green=115, @blue=141, @alpha=255>
+image[0, 0].to_hex => "26738dff"
+image[0, 0].to_hex(rgb: true) => "26738d"
+```
+
 ### Transformations
 
 For each transformation, there is a bang! and non-bang method.
 The bang method changes the image in place, while the non-bang method
 creates a copy of the image in memory.
 
+#### Resizing
+
 ```ruby
 # auto height
 image.resize(400, :auto)
@@ -66,6 +83,22 @@ image.resize(:auto, 300)
 # scale factor
 image.resize(0.5)
 
+# resize to fill
+image.resize(400, 300, crop: true)
+
+# resize to fill with gravity
+# where gravity in [:n, :nw, :w, :sw, :w, :se, :e, :ne, :center]
+image.resize(400, 300, crop: gravity)
+
+# save memory, do not duplicate instance
+image.resize!(400, :auto)
+```
+
+Check out the [full list and demo of resize options](https://mtgrosser.github.io/rszr/resizing.html)!
+
+#### Other transformations
+
+```ruby
 # crop
 image.crop(200, 200, 100, 100)
 
@@ -78,35 +111,65 @@ image.turn!(-1)
 # rotate by arbitrary angle
 image.rotate(45)
 
+# flip vertically
+image.flip
+
+# flop horizontally
+image.flop
+
+# initialize copy
+image.dup
+```
+
+### Filters
+
+Filters also support bang! and non-bang methods.
+
+```ruby
 # sharpen image by pixel radius
 image.sharpen!(1)
 
 # blur image by pixel radius
 image.blur!(1)
 
-# initialize copy
-image.dup
+# brighten
+image.brighten(0.1)
 
-# save memory, do not duplicate instance
-image.resize!(400, :auto)
+# darken
+image.brighten(-0.1)
+
+# contrast
+image.contrast(0.5)
+
+# gamma
+image.gamma(1.1)
 ```
 
-### Image info
+### Image auto orientation
+
+Auto-rotation is supported for JPEG and TIFF files that include the necessary
+EXIF metadata.
+
 ```ruby
-image.width => 400
-image.height => 300
-image.dimensions => [400, 300]
-image.format => "jpeg"
+# load and autorotate
+image = Rszr::Image.load('image.jpg', autorotate: true)
+```
+
+To enable autorotation by default:
+
+```ruby
+# auto-rotate by default, for Rails apps put this into an initializer
+Rszr.autorotate = true
 ```
 
 ## Rails / ActiveStorage interface
 
-Rszr provides a drop-in interface to the `image_resizing` gem.
+Rszr provides a drop-in interface to the `image_processing` gem.
 It is faster than both `mini_magick` and `vips` and way easier to install than the latter.
 
 ```ruby
 # Gemfile
-gem 'image_resizing'
+gem 'image_processing'
 gem 'rszr'
 
 # config/initializers/rszr.rb
@@ -122,6 +185,19 @@ When creating image variants, you can use all of Rszr's transformation methods:
 <%= image_tag user.avatar.variant(resize_to_fit: [300, 200]) %>
 ```
 
+## Loading from and saving to memory
+
+The `Imlib2` library is mainly file-oriented and doesn't provide a way of loading
+the undecoded image from a memory buffer. Therefore, the functionality is
+implemented on the Ruby side of the gem, writing the memory buffer to a Tempfile.
+Currently, this local write cannot be avoided.
+
+```ruby
+image = Rszr::Image.load_data(binary_data)
+
+data = image.save_data(format: :jpeg)
+```
+
 ## Thread safety
 
 As of version 0.5.0, Rszr is thread safe through Ruby's global VM lock.

data/ext/rszr/errors.c

@@ -42,10 +42,15 @@ void Init_rszr_errors()
 
 static void rszr_raise_error_with_message(VALUE rb_error_class, Imlib_Load_Error error)
 {
-  int error_index = (int) error - 1;
+  VALUE rb_error;
+  int error_index;
+  
+  error_index = (int) error - 1;
+  
   if (error_index < 1 || error_index > RSZR_MAX_ERROR_INDEX)
-    error_index = 13;
-  VALUE rb_error = rb_exc_new2(rb_error_class, sRszrErrorMessages[error_index]);
+    error_index = RSZR_MAX_ERROR_INDEX;
+  
+  rb_error = rb_exc_new2(rb_error_class, sRszrErrorMessages[error_index]);
   rb_exc_raise(rb_error);
 }
 

data/ext/rszr/image.c

@@ -27,7 +27,6 @@ static void rszr_image_deallocate(rszr_image_handle * handle)
   // fprintf(stderr, "\n");
 }
 
-
 static VALUE rszr_image_s_allocate(VALUE klass)
 {
   rszr_image_handle * handle = calloc(1, sizeof(rszr_image_handle));
@@ -61,13 +60,20 @@ static VALUE rszr_image_s__load(VALUE klass, VALUE rb_path)
   path = StringValueCStr(rb_path);
 
   imlib_set_cache_size(0);
-  image = imlib_load_image_with_error_return(path, &error);
+  image = imlib_load_image_without_cache(path);
   
   if (!image) {
-    rszr_raise_load_error(error);
-    return Qnil;
+    image = imlib_load_image_with_error_return(path, &error);
+    
+    if (!image) {
+      rszr_raise_load_error(error);
+      return Qnil;
+    }
   }
   
+  imlib_context_set_image(image);
+  imlib_image_set_irrelevant_format(0);
+  
   oImage = rszr_image_s_allocate(cImage);
   Data_Get_Struct(oImage, rszr_image_handle, handle);
   handle->image = image;
@@ -75,7 +81,7 @@ static VALUE rszr_image_s__load(VALUE klass, VALUE rb_path)
 }
 
 
-static VALUE rszr_image_format_get(VALUE self)
+static VALUE rszr_image__format_get(VALUE self)
 {
   rszr_image_handle * handle;
   char * format;
@@ -134,6 +140,32 @@ static VALUE rszr_image_height(VALUE self)
   return INT2NUM(height);
 }
 
+
+static VALUE rszr_image__pixel_get(VALUE self, VALUE rb_x, VALUE rb_y)
+{
+  rszr_image_handle * handle;
+  Imlib_Color color_return;
+  VALUE rb_rgba;
+  int x, y;
+  
+  Check_Type(rb_x, T_FIXNUM);
+  x = FIX2INT(rb_x);
+  Check_Type(rb_y, T_FIXNUM);
+  y = FIX2INT(rb_y);
+  
+  Data_Get_Struct(self, rszr_image_handle, handle);
+  
+  imlib_context_set_image(handle->image);
+  imlib_image_query_pixel(x, y, &color_return);
+  
+  rb_rgba = rb_ary_new3(4, INT2NUM(color_return.red),
+                           INT2NUM(color_return.green),
+                           INT2NUM(color_return.blue),
+                           INT2NUM(color_return.alpha));
+  return rb_rgba;
+}
+
+
 /*
 static VALUE rszr_image_get_quality(VALUE self)
 {
@@ -211,6 +243,32 @@ static VALUE rszr_image__turn_bang(VALUE self, VALUE orientation)
 }
 
 
+static VALUE rszr_image_flop_bang(VALUE self)
+{
+  rszr_image_handle * handle;
+
+  Data_Get_Struct(self, rszr_image_handle, handle);
+  
+  imlib_context_set_image(handle->image);
+  imlib_image_flip_horizontal();
+
+  return self;
+}
+
+
+static VALUE rszr_image_flip_bang(VALUE self)
+{
+  rszr_image_handle * handle;
+
+  Data_Get_Struct(self, rszr_image_handle, handle);
+  
+  imlib_context_set_image(handle->image);
+  imlib_image_flip_vertical();
+
+  return self;
+}
+
+
 static VALUE rszr_image__rotate(VALUE self, VALUE bang, VALUE rb_angle)
 {
   rszr_image_handle * handle;
@@ -246,20 +304,22 @@ static VALUE rszr_image__rotate(VALUE self, VALUE bang, VALUE rb_angle)
   }
 }
 
-/*
-static VALUE rszr_image__brighten_bang(VALUE self, VALUE rb_brightness)
+
+static VALUE rszr_image_filter_bang(VALUE self, VALUE rb_filter_expr)
 {
   rszr_image_handle * handle;
-  double brightness;
+  char * filter_expr;
   
-  brightness = NUM2DBL(rb_brightness);
+  filter_expr = StringValueCStr(rb_filter_expr);
+  
+  Data_Get_Struct(self, rszr_image_handle, handle);
   
   imlib_context_set_image(handle->image);
-  imlib_modify_color_modifier_brightness(brightness);
+  imlib_apply_filter(filter_expr);
   
   return self;
 }
-*/
+
 
 static VALUE rszr_image__sharpen_bang(VALUE self, VALUE rb_radius)
 {
@@ -275,7 +335,7 @@ static VALUE rszr_image__sharpen_bang(VALUE self, VALUE rb_radius)
   if (radius >= 0) {
     imlib_image_sharpen(radius);
   } else {
-    imlib_image_blur(radius);
+    imlib_image_blur(-radius);
   }
   
   return self;
@@ -425,19 +485,23 @@ void Init_rszr_image()
   rb_define_method(cImage, "initialize",  rszr_image_initialize, 2);
   rb_define_method(cImage, "width",       rszr_image_width, 0);
   rb_define_method(cImage, "height",      rszr_image_height, 0);
-  rb_define_method(cImage, "format",      rszr_image_format_get, 0);
   rb_define_method(cImage, "dup",         rszr_image_dup, 0);
+  rb_define_method(cImage, "filter!",     rszr_image_filter_bang, 1);
+  rb_define_method(cImage, "flop!",       rszr_image_flop_bang, 0);
+  rb_define_method(cImage, "flip!",       rszr_image_flip_bang, 0);
+  
   // rb_define_method(cImage, "quality",     rszr_image_get_quality, 0);
   // rb_define_method(cImage, "quality=",    rszr_image_set_quality, 1);
   
+  rb_define_protected_method(cImage, "_format",  rszr_image__format_get, 0);
   rb_define_protected_method(cImage, "_format=", rszr_image__format_set, 1);
   
   rb_define_private_method(cImage, "_resize",  rszr_image__resize, 7);
   rb_define_private_method(cImage, "_crop",    rszr_image__crop, 5);
   rb_define_private_method(cImage, "_turn!",   rszr_image__turn_bang, 1);
-  rb_define_private_method(cImage, "_rotate",  rszr_image__rotate, 2);
-  rb_define_private_method(cImage, "_sharpen!",   rszr_image__sharpen_bang, 1);
-  /* rb_define_private_method(cImage, "_brighten!",  rszr_image__brighten_bang, 1); */
+  rb_define_private_method(cImage, "_rotate",    rszr_image__rotate, 2);
+  rb_define_private_method(cImage, "_sharpen!",  rszr_image__sharpen_bang, 1);
+  rb_define_private_method(cImage, "_pixel",     rszr_image__pixel_get, 2);
   
   rb_define_private_method(cImage, "_save",       rszr_image__save, 3);
 }

data/lib/rszr/batch_transformation.rb

@@ -0,0 +1,24 @@
+module Rszr
+  class BatchTransformation
+    attr_reader :transformations, :image
+    
+    def initialize(path, **opts)
+      puts "INITIALIZED BATCH for #{path}"
+      @image = path.is_a?(Image) ? path : Image.load(path, **opts)
+      @transformations = []
+    end
+    
+    Image::Transformations.instance_methods.grep(/\w\z/) do |method|
+      define_method method do |*args|
+        transformations << [method, args]
+        self
+      end
+    end
+    
+    def call
+      transformations.each { |method, args| image.public_send("#{method}!", *args) }
+      image
+    end
+  
+  end
+end

data/lib/rszr/buffered.rb

@@ -0,0 +1,25 @@
+module Rszr
+  module Buffered
+    def self.included(base)
+      base.extend Buffered
+    end
+    
+    private
+    
+    def with_tempfile(format, data = nil)
+      raise ArgumentError, 'format is required' unless format
+      result = nil
+      Tempfile.create(['rszr-buffer', ".#{format}"], encoding: 'BINARY') do |file|
+        if data
+          file.binmode
+          file << data
+          file.fsync
+          file.rewind
+        end
+        result = yield(file)
+      end
+      result
+    end
+    
+  end
+end

data/lib/rszr/color.rb

@@ -0,0 +1,25 @@
+module Rszr
+  module Color
+
+    class RGBA
+      attr_reader :red, :green, :blue, :alpha
+
+      def initialize(red, green, blue, alpha = 255)
+        if red < 0 || red > 255 || green < 0 || green > 255 || blue < 0 || blue > 255 || alpha < 0 || alpha > 255
+          raise ArgumentError, 'color out of range'
+        end
+        @red, @green, @blue, @alpha = red, green, blue, alpha
+      end
+      
+      def to_i(rgb: false)
+        i = red.to_i << 24 | green.to_i << 16 | blue.to_i << 8 | alpha.to_i
+        rgb ? i >> 8 : i
+      end
+      
+      def to_hex(rgb: false)
+        "%0#{rgb ? 6 : 8}x" % to_i(rgb: rgb)
+      end
+    end
+
+  end
+end

data/lib/rszr/identification.rb

@@ -0,0 +1,60 @@
+# Type reader adapted from fastimage
+# https://github.com/sdsykes/fastimage/
+
+module Rszr
+  module Identification
+    
+    private
+    
+    def identify(data)
+      case data[0, 2]
+      when 'BM'
+        :bmp
+      when 'GI'
+        :gif
+      when 0xff.chr + 0xd8.chr
+        :jpeg
+      when 0x89.chr + 'P'
+        :png
+      when 'II', 'MM'
+        case data[0, 11][8..10] # @stream.peek(11)[8..10]
+        when 'APC', "CR\002"
+          nil  # do not recognise CRW or CR2 as tiff
+        else
+          :tiff
+        end
+      when '8B'
+        :psd
+      when "\0\0"
+        case data[0, 3].bytes.last #@stream.peek(3).bytes.to_a.last
+        when 0
+          # http://www.ftyps.com/what.html
+          # HEIC is composed of nested "boxes". Each box has a header composed of
+          # - Size (32 bit integer)
+          # - Box type (4 chars)
+          # - Extended size: only if size === 1, the type field is followed by 64 bit integer of extended size
+          # - Payload: Type-dependent
+          case data[0, 12][4..-1] #@stream.peek(12)[4..-1]
+          when 'ftypheic'
+            :heic
+          when 'ftypmif1'
+            :heif
+          end
+        # ico has either a 1 (for ico format) or 2 (for cursor) at offset 3
+        when 1 then :ico
+        when 2 then :cur
+        end
+      when 'RI'
+        :webp if data[0, 12][8..11] == 'WEBP' #@stream.peek(12)[8..11] == "WEBP"
+      when "<s"
+        :svg if data[0, 4] == '<svg' #@stream.peek(4) == "<svg"
+      when /\s\s|\s<|<[?!]/, 0xef.chr + 0xbb.chr
+        # Peek 10 more chars each time, and if end of file is reached just raise
+        # unknown. We assume the <svg tag cannot be within 10 chars of the end of
+        # the file, and is within the first 250 chars.
+        :svg if (1..25).detect { |n| data[0, 10 * n]&.include?('<svg') }
+      end
+    end
+
+  end
+end

data/lib/rszr/image.rb

@@ -1,25 +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, **opts)
+
+      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
@@ -28,12 +53,12 @@ module Rszr
     end
 
     module Transformations
-      def resize(*args)
-        _resize(false, *calculate_size(*args))
+      def resize(*args, **opts)
+        _resize(false, *calculate_size(*args,  **opts))
       end
 
-      def resize!(*args)
-        _resize(true, *calculate_size(*args))
+      def resize!(*args, **opts)
+        _resize(true, *calculate_size(*args, **opts))
       end
 
       def crop(x, y, width, height)
@@ -43,7 +68,7 @@ module Rszr
       def crop!(x, y, width, height)
         _crop(true, x, y, width, height)
       end
-    
+      
       def turn(orientation)
         dup.turn!(orientation)
       end
@@ -60,6 +85,16 @@ module Rszr
       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)
@@ -79,11 +114,36 @@ module Rszr
         _sharpen!(-radius)
       end
       
-      # TODO
-      #def brighten!(brightness)
-      #  raise ArgumentError, 'illegal brightness' if brightness > 1 || brightness < -1
-      #  _brighten!(brightness)
-      #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
@@ -94,6 +154,15 @@ module Rszr
       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
     
@@ -105,51 +174,104 @@ module Rszr
     # 400, 300, background: rgba
     # 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)

data/lib/rszr/image_processing.rb

@@ -47,11 +47,11 @@ module ImageProcessing
         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)
+        thumbnail(width, height, inflate: false, **options)
       end
 
       # Resizes the image to fit within the specified dimensions.
@@ -62,8 +62,8 @@ module ImageProcessing
 
       # 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)
+      def resize_to_fill(width, height, gravity: :center, **options)
+        thumbnail(width, height, crop: gravity, **options)
       end
 
       private

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.3'
+  VERSION = '1.0.1'
 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

metadata

@@ -1,183 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rszr
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 1.0.1
 platform: ruby
 authors:
 - Matthias Grosser
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-13 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 12.3.3
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 12.3.3
-- !ruby/object:Gem::Dependency
-  name: rake-compiler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: byebug
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: image_processing
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: gd2-ffij
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: mini_magick
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: ruby-vips
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: memory_profiler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+date: 2021-11-10 00:00:00.000000000 Z
+dependencies: []
 description: Fast image resizer - do one thing and do it fast.
 email:
 - mtgrosser@gmx.net
@@ -197,14 +29,20 @@ files:
 - ext/rszr/rszr.c
 - ext/rszr/rszr.h
 - lib/rszr.rb
+- lib/rszr/batch_transformation.rb
+- lib/rszr/buffered.rb
+- lib/rszr/color.rb
+- lib/rszr/identification.rb
 - lib/rszr/image.rb
 - lib/rszr/image_processing.rb
+- lib/rszr/orientation.rb
+- lib/rszr/stream.rb
 - lib/rszr/version.rb
 homepage: https://github.com/mtgrosser/rszr
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -220,9 +58,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- Imlib2
+- imlib2
 rubygems_version: 3.1.4
-signing_key:
+signing_key: 
 specification_version: 4
 summary: Fast image resizer
 test_files: []