rszr 0.5.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c4fc21afb848256445e310a0feebab86b2b10ee6baf464bd7e67a44b282b4d07
-  data.tar.gz: bfe92bbc780dbf03135b4b3d7296df141bee74279412b6bd3b6d2ba70362a140
+  metadata.gz: ea3437991dd4694e35653020632c3fc360f787e1d391834780fdf118991a90ce
+  data.tar.gz: 37ccc3f8693e4fe9d41939cfc2d3786ef72ed24e344059f1dd4e4492efcae862
 SHA512:
-  metadata.gz: 26d46f7b4d594da5e871d75975d99cd54358bb6585d8b18fbddcba1b4383970099891f7af6d16b51b8dcf19f5ed179b275d001b15f546c3baa58a3b6573613f9
-  data.tar.gz: 0f5866b917277c7afb518fb15ba83451fc7b448681fec26dad4321d17cfa464854e9182cff88008f7ee25b1c6df135f6a14f3980b64a145db9ef93e035de1d9e
+  metadata.gz: 35b8219e81c0f89e4b51719617c13edf71421d7e3ed4e1998f8e26fc017545da76c5164c0bbd63c16e5c617cfdd4f5cb1f07a8e0bbdc83b7bb90ea7fbbd71907
+  data.tar.gz: fd4361d89e0ff577032da1dea39686c035604d98e5b6b935ca8de8f1289bdfe6cf5678c8842406c0b9c5829cfab2c03af8350670638824a99deeb176e4675428

data/README.md

@@ -1,7 +1,8 @@
-[![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. It is faster and consumes less memory than MiniMagick, rmagick and GD2.
+Rszr is an image resizer for Ruby based on the Imlib2 library.
+It is faster and consumes less memory than MiniMagick, GD2 and VIPS, and comes with an optional drop-in interface for Rails ActiveStorage image processing.
 
 ## Installation
 
@@ -13,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
 
@@ -27,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
 ```
@@ -47,7 +52,28 @@ image.save('resized.jpg')
 
 # save it as PNG
 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)
 
@@ -57,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)
 
@@ -66,30 +108,110 @@ image.turn!(3)
 # rotate one time 90 deg counterclockwise
 image.turn!(-1)
 
+# rotate by arbitrary angle
+image.rotate(45)
+
+# flip vertically
+image.flip
+
+# flop horizontally
+image.flop
+
 # initialize copy
 image.dup
+```
 
-# save memory, do not duplicate instance
-image.resize!(400, :auto)
+### Filters
 
-# image info
-image.width => 400
-image.height => 300
-image.dimensions => [400, 300]
-image.format => "jpeg"
+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)
+
+# brighten
+image.brighten(0.1)
+
+# darken
+image.brighten(-0.1)
+
+# 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_processing` gem.
+It is faster than both `mini_magick` and `vips` and way easier to install than the latter.
+
+```ruby
+# Gemfile
+gem 'image_processing'
+gem 'rszr'
+
+# config/initializers/rszr.rb
+require 'rszr/image_processing'
+
+# config/application.rb
+config.active_storage.variant_processor = :rszr
+```
+
+When creating image variants, you can use all of Rszr's transformation methods:
+
+```erb
+<%= 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.4.0, Rszr is thread safe through the Ruby GIL.
+As of version 0.5.0, Rszr is thread safe through Ruby's global VM lock.
 Use of any previous versions in a threaded environment is discouraged.
 
 ## Speed
 
-Resizing an 1500x997 JPEG image to 800x532, 100 times:
+Resizing a 1500x997 JPEG image to 800x532, 500 times:
+![Speed](https://github.com/mtgrosser/rszr/blob/master/benchmark/speed.png)
+
 
 Library         | Time
 ----------------|-----------
-MiniMagick      | 12.9 s
-GD2             | 7.5 s
-Rszr            | 2.8 s
+MiniMagick      | 27.0 s
+GD2             | 28.2 s
+VIPS            | 13.6 s
+Rszr            |  7.9 s

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(VALUE self)
+static VALUE rszr_image__format_get(VALUE self)
 {
   rszr_image_handle * handle;
   char * format;
@@ -93,6 +99,20 @@ static VALUE rszr_image_format(VALUE self)
 }
 
 
+static VALUE rszr_image__format_set(VALUE self, VALUE rb_format)
+{
+  rszr_image_handle * handle;
+  char * format = StringValueCStr(rb_format);
+  
+  Data_Get_Struct(self, rszr_image_handle, handle);
+  
+  imlib_context_set_image(handle->image);
+  imlib_image_set_format(format);
+  
+  return self;
+}
+
+
 static VALUE rszr_image_width(VALUE self)
 {
   rszr_image_handle * handle;
@@ -121,6 +141,70 @@ static VALUE rszr_image_height(VALUE self)
 }
 
 
+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)
+{
+  rszr_image_handle * handle;
+  int quality;
+  
+  Data_Get_Struct(self, rszr_image_handle, handle);
+  
+  imlib_context_set_image(handle->image);
+  quality = imlib_image_get_attached_value("quality");
+  
+  if (quality) {
+    return INT2NUM(quality);
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE rszr_image_set_quality(VALUE self, VALUE rb_quality)
+{
+  rszr_image_handle * handle;
+  int quality;
+  
+  Check_Type(rb_quality, T_FIXNUM);
+  quality = FIX2INT(rb_quality);
+  if (quality <= 0) {
+    rb_raise(rb_eArgError, "quality must be >= 0");
+    return Qnil;
+  }
+  
+  Data_Get_Struct(self, rszr_image_handle, handle);
+  
+  imlib_context_set_image(handle->image);
+  imlib_image_attach_data_value("quality", NULL, quality, NULL);
+  
+  return INT2NUM(quality);
+}
+*/
+
 static VALUE rszr_image_dup(VALUE self)
 {
   rszr_image_handle * handle;
@@ -159,6 +243,105 @@ 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;
+  rszr_image_handle * rotated_handle;
+  Imlib_Image rotated_image;
+  VALUE oRotatedImage;
+  double angle;
+  
+  angle = NUM2DBL(rb_angle);
+  
+  Data_Get_Struct(self, rszr_image_handle, handle);
+  
+  imlib_context_set_image(handle->image);
+  rotated_image = imlib_create_rotated_image(angle);
+  
+  if (!rotated_image) {
+    rb_raise(eRszrTransformationError, "error rotating image");
+    return Qnil;
+  }
+  
+  if (RTEST(bang)) {
+    rszr_free_image(handle->image);
+    handle->image = rotated_image;
+    
+    return self;
+  }
+  else {
+    oRotatedImage = rszr_image_s_allocate(cImage);
+    Data_Get_Struct(oRotatedImage, rszr_image_handle, rotated_handle);
+    rotated_handle->image = rotated_image;
+  
+    return oRotatedImage;
+  }
+}
+
+
+static VALUE rszr_image_filter_bang(VALUE self, VALUE rb_filter_expr)
+{
+  rszr_image_handle * handle;
+  char * filter_expr;
+  
+  filter_expr = StringValueCStr(rb_filter_expr);
+  
+  Data_Get_Struct(self, rszr_image_handle, handle);
+  
+  imlib_context_set_image(handle->image);
+  imlib_apply_filter(filter_expr);
+  
+  return self;
+}
+
+
+static VALUE rszr_image__sharpen_bang(VALUE self, VALUE rb_radius)
+{
+  rszr_image_handle * handle;
+  int radius;
+  
+  radius = NUM2INT(rb_radius);
+  
+  Data_Get_Struct(self, rszr_image_handle, handle);
+  
+  imlib_context_set_image(handle->image);
+  
+  if (radius >= 0) {
+    imlib_image_sharpen(radius);
+  } else {
+    imlib_image_blur(-radius);
+  }
+  
+  return self;
+}
+
+
 static Imlib_Image rszr_create_cropped_scaled_image(const Imlib_Image image, VALUE rb_src_x, VALUE rb_src_y, VALUE rb_src_w, VALUE rb_src_h, VALUE rb_dst_w, VALUE rb_dst_h)
 {
   Imlib_Image resized_image;
@@ -262,20 +445,24 @@ static VALUE rszr_image__crop(VALUE self, VALUE bang, VALUE rb_x, VALUE rb_y, VA
 }
 
 
-static VALUE rszr_image__save(VALUE self, VALUE rb_path, VALUE rb_format)
+static VALUE rszr_image__save(VALUE self, VALUE rb_path, VALUE rb_format, VALUE rb_quality)
 {
   rszr_image_handle * handle;
   char * path;
   char * format;
+  int quality;
   Imlib_Load_Error save_error;
   
   path = StringValueCStr(rb_path);
   format = StringValueCStr(rb_format);
-  
+  quality = (NIL_P(rb_quality)) ? 0 : FIX2INT(rb_quality);
+
   Data_Get_Struct(self, rszr_image_handle, handle);
   
   imlib_context_set_image(handle->image);
   imlib_image_set_format(format);
+  if (quality)
+    imlib_image_attach_data_value("quality", NULL, quality, NULL);
   imlib_save_image_with_error_return(path, &save_error);
   
   if (save_error) {
@@ -298,12 +485,25 @@ 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, 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, "_save",    rszr_image__save, 2);
+  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);
 }
 
 #endif

data/ext/rszr/rszr.h

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

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