rszr 0.7.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfbe455a6a95a6fc5161b65c03450e66e3e7165794556abd90cfef22da5a1f32
-  data.tar.gz: 1ced66bb5a143f23d55dd1496fc79cf29d58b529138405741f93ba6379e62ba5
+  metadata.gz: 453bbac498bb376737ac50b776a9d1824cbb0f2338753b82c09c36ef08bc152b
+  data.tar.gz: 66941eca0be0d49922627be9329ca6c623686809094be55b80fc490f8dd59290
 SHA512:
-  metadata.gz: 007c4d61f001ec86a6be7db860a68edf61f1eac63dfbf1b55afc24e51aa4033248b9224a3706b53c2887555812c0eeaac1d7e62ef66c40e0dd0544c8d67642a3
-  data.tar.gz: ef41050b95a085ba6d1fd87c26596e3387a9eb6b248e1d0f741c079dcabaa381912e9c07f28916ff8739df29c903513c0cf78e22384396f5a16384428f6b8014
+  metadata.gz: ed7559dfe4f2a754f9f4b46fe0cf3b88f1003d8c055dc38d5eb9335f49ff8656689464fbb8f0c0756466ab9dd6af775e9bb12add63f29d167a20e832354d3adc
+  data.tar.gz: 49b195f7d27005a81175ae467e0f7f05d974b020db07a90a1f34999df2dd69cd96591d2a96d7ae07872886074dbc937e8d53bf99380fa0bf5d94181065461682

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.
@@ -12,29 +12,32 @@ In your Gemfile:
 gem 'rszr'
 ```
 
-### Imlib2 and libexif
+### Imlib2
 
 Rszr requires the `Imlib2` library to do the heavy lifting.
-`libexif` is required for EXIF auto orientation.
 
 #### OS X
 
 Using homebrew:
 
 ```bash
-brew install imlib2 libexif
+brew install imlib2
 ```
 
 #### Linux
 
 Using your favourite package manager:
 
+##### RedHat-based
+
 ```bash
-yum install imlib2 imlib2-devel libexif libexif-devel
+yum install imlib2 imlib2-devel
 ```
 
+##### Debian-based
+
 ```bash
-apt-get install libimlib2 libimlib2-dev libexif libexif-dev
+apt-get install libimlib2 libimlib2-dev
 ```
 
 ## Usage
@@ -51,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)
@@ -67,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)
 
@@ -79,45 +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)
 
-### Image info
-```ruby
-image.width => 400
-image.height => 300
-image.dimensions => [400, 300]
-image.format => "jpeg"
+# contrast
+image.contrast(0.5)
+
+# gamma
+image.gamma(1.1)
 ```
 
 ### Image auto orientation
 
+Auto-rotation is supported for JPEG and TIFF files that include the necessary
+EXIF metadata.
+
 ```ruby
 # 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
@@ -133,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 = RSZR_MAX_ERROR_INDEX;
-  VALUE rb_error = rb_exc_new2(rb_error_class, sRszrErrorMessages[error_index]);
+  
+  rb_error = rb_exc_new2(rb_error_class, sRszrErrorMessages[error_index]);
   rb_exc_raise(rb_error);
 }
 

data/ext/rszr/extconf.rb

@@ -1,10 +1,9 @@
 require 'mkmf'
 require 'rbconfig'
 
-imlib2_config = with_config('imlib2-config', 'imlib2-config')
+pkg_config('imlib2')
 
-$CFLAGS << ' -DX_DISPLAY_MISSING ' << `#{imlib2_config} --cflags`.chomp
-$LDFLAGS << ' ' << `#{imlib2_config} --libs`.chomp
+$CFLAGS << ' -DX_DISPLAY_MISSING'
 $LDFLAGS.gsub!(/\ -lX11\ -lXext/, '') if RUBY_PLATFORM =~ /darwin/
 
 unless find_header('Imlib2.h')
@@ -15,11 +14,4 @@ unless find_library('Imlib2', 'imlib_set_cache_size')
   abort 'Imlib2 is missing'
 end
 
-unless find_library('exif', 'exif_data_new_from_file')
-  abort 'libexif is missing'
-end
-
-have_library('exif')
-have_header('libexif/exif-data.h')
-
 create_makefile 'rszr/rszr'

data/ext/rszr/image.c

@@ -27,43 +27,6 @@ static void rszr_image_deallocate(rszr_image_handle * handle)
   // fprintf(stderr, "\n");
 }
 
-
-static void rszr_image_autorotate(Imlib_Image image, char * path)
-{
-  ExifData * exifData;
-  ExifByteOrder byteOrder;
-  ExifEntry * exifEntry;
-  int orientation = 0;
-  int turns = 0;
-  
-  exifData = exif_data_new_from_file(path);
-  
-  if (exifData) {
-    byteOrder = exif_data_get_byte_order(exifData);
-    exifEntry = exif_data_get_entry(exifData, EXIF_TAG_ORIENTATION);
-    if (exifEntry) {
-      orientation = exif_get_short(exifEntry->data, byteOrder);
-    }
-  }
-
-  if (orientation < 2 || orientation > 8) return;
-  
-  imlib_context_set_image(image);
-  
-  if (orientation == 2 || orientation == 4 || orientation == 5 || orientation == 7) {
-    imlib_image_flip_horizontal();
-  }
-  
-  if (orientation == 5 || orientation == 6) {
-    imlib_image_orientate(1);
-  } else if (orientation == 3 || orientation == 4) {
-    imlib_image_orientate(2);
-  } else if (orientation == 7 || orientation == 8) {
-    imlib_image_orientate(3);
-  }
-}
-
-
 static VALUE rszr_image_s_allocate(VALUE klass)
 {
   rszr_image_handle * handle = calloc(1, sizeof(rszr_image_handle));
@@ -86,7 +49,7 @@ static VALUE rszr_image_initialize(VALUE self, VALUE rb_width, VALUE rb_height)
 }
 
 
-static VALUE rszr_image_s__load(VALUE klass, VALUE rb_path, VALUE autorotate)
+static VALUE rszr_image_s__load(VALUE klass, VALUE rb_path)
 {
   rszr_image_handle * handle;
   Imlib_Image image;
@@ -97,14 +60,19 @@ static VALUE rszr_image_s__load(VALUE klass, VALUE rb_path, VALUE autorotate)
   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;
+    }
   }
   
-  if (RTEST(autorotate)) rszr_image_autorotate(image, path);
+  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);
@@ -113,7 +81,7 @@ static VALUE rszr_image_s__load(VALUE klass, VALUE rb_path, VALUE autorotate)
 }
 
 
-static VALUE rszr_image_format_get(VALUE self)
+static VALUE rszr_image__format_get(VALUE self)
 {
   rszr_image_handle * handle;
   char * format;
@@ -172,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)
 {
@@ -249,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;
@@ -288,7 +308,6 @@ static VALUE rszr_image__rotate(VALUE self, VALUE bang, VALUE rb_angle)
 static VALUE rszr_image_filter_bang(VALUE self, VALUE rb_filter_expr)
 {
   rszr_image_handle * handle;
-  Imlib_Image image;
   char * filter_expr;
   
   filter_expr = StringValueCStr(rb_filter_expr);
@@ -302,22 +321,6 @@ static VALUE rszr_image_filter_bang(VALUE self, VALUE rb_filter_expr)
 }
 
 
-static VALUE rszr_image__brighten_bang(VALUE self, VALUE rb_brightness)
-{
-  rszr_image_handle * handle;
-  double brightness;
-  
-  brightness = NUM2DBL(rb_brightness);
-  
-  Data_Get_Struct(self, rszr_image_handle, handle);
-  
-  imlib_context_set_image(handle->image);
-  imlib_apply_filter("brightness(10);");
-  
-  return self;
-}
-
-
 static VALUE rszr_image__sharpen_bang(VALUE self, VALUE rb_radius)
 {
   rszr_image_handle * handle;
@@ -332,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;
@@ -476,27 +479,29 @@ void Init_rszr_image()
   rb_define_alloc_func(cImage, rszr_image_s_allocate);
 
   // Class methods
-  rb_define_private_method(rb_singleton_class(cImage), "_load", rszr_image_s__load, 2);
+  rb_define_private_method(rb_singleton_class(cImage), "_load", rszr_image_s__load, 1);
 
   // Instance methods
   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/ext/rszr/rszr.h

@@ -3,7 +3,6 @@
 
 #include "ruby.h"
 #include <Imlib2.h>
-#include <libexif/exif-data.h>
 
 extern VALUE mRszr;
 void Init_rszr();

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, autorotate: Rszr.autorotate, **opts)
         path = path.to_s
         raise FileNotFound unless File.exist?(path)
-        _load(path, autorotate)
+        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)
@@ -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)
@@ -88,8 +123,8 @@ module Rszr
         filter!("colormod(brightness=#{value.to_f});")
       end
       
-      def brighten(*args)
-        dup.brighten!(*args)
+      def brighten(*args, **opts)
+        dup.brighten!(*args, **opts)
       end
       
       def contrast!(value, r: nil, g: nil, b: nil, a: nil)
@@ -97,8 +132,8 @@ module Rszr
         filter!("colormod(contrast=#{value.to_f});")
       end
       
-      def contrast(*args)
-        dup.contrast!(*args)
+      def contrast(*args, **opts)
+        dup.contrast!(*args, **opts)
       end
       
       def gamma!(value, r: nil, g: nil, b: nil, a: nil)
@@ -106,8 +141,8 @@ module Rszr
         filter!("colormod(gamma=#{value.to_f});")
       end
       
-      def gamma(*args)
-        dup.gamma!(*args)
+      def gamma(*args, **opts)
+        dup.gamma!(*args, **opts)
       end
     end
     
@@ -116,8 +151,18 @@ module Rszr
     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
     
@@ -129,52 +174,114 @@ 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 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
+        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].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)
       if unknown_key = (hsh.keys - valid_keys).first

data/lib/rszr/image_processing.rb

@@ -51,7 +51,7 @@ module ImageProcessing
       # 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.7.1'
+  VERSION = '1.1.0'
 end

data/lib/rszr.rb

@@ -1,8 +1,15 @@
 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

metadata

@@ -1,183 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rszr
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Matthias Grosser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-10 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: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-- !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: 2022-02-09 00:00:00.000000000 Z
+dependencies: []
 description: Fast image resizer - do one thing and do it fast.
 email:
 - mtgrosser@gmx.net
@@ -198,8 +30,13 @@ files:
 - 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:
@@ -222,7 +59,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements:
 - imlib2
-- libexif
 rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4