morandi 0.99.03 → 0.100.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a794ac03476df828589c8239af24558daba1b32c4db9052f1dcf3704442eae43
-  data.tar.gz: 71fb0af31081d29907392d57ceb7adda9fc6b277835fd7540a9c91a6b1b9c90c
+  metadata.gz: 0ca1f4a637e59ee90de4f309dfecc40eae27b103f416ea301af36e8bd04c555f
+  data.tar.gz: 8ebeda3024e6275ea7e8b75c8357339523a59a24987e1ebd07142cba445edce7
 SHA512:
-  metadata.gz: be85f2a459dad73012fe696f285f1eae17b098e48002f5da9cf868ed876854b915115e1e6f85929948427208d2b3363abe3d7b492b6187e729bf408ad6fccb95
-  data.tar.gz: 78beadc94f1387ff9af6d9c00d2f518f17d71f241880a5d2a828568dfaa2eb1b2aade57b198fc7f8ceeae429c1445d1c9c36c9fd461c84b3516e88964c32bf19
+  metadata.gz: 55308d1a2ae4626a81bf1faa9a6ae0535f816d777e31d25266e36e563bdc1dc60c55ef588ade477ce113a13bd20f80aefd046a52c1e4aaccffdc103e48d75cac
+  data.tar.gz: c10ab8cbe21121d50a2c0a10cdb6c0fefe595962d11cf936adeaef78e8291bd4688b37bb464577c7f455d8aa02e04def65d46930a86fb3cbf9c1aed4e9abf972

data/CHANGELOG.md

@@ -4,7 +4,40 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-## Unreleased
+## [0.100.0] 17.01.2024
+### Added
+- Vips image processor (resizing)
+- Vips colour filters
+- Vips crop
+- Vips rotate
+- Vips straighten
+- Vips gamma
+- Vips stripping alpha
+- Explicit error when trying to use VipsProcessor with unsupported options
+- Vips cast to srgb when image uses a different colourspace
+
+### Removed
+- [BREAKING] dropped support for a broken 'dominant' border colour
+
+## [0.99.4] 22.11.2024
+### Added
+- Better test coverage for straighten operation
+- Support for visual image comparison in specs
+- Automated visual comparison of images in specs, also serving as a record of exact rendering behaviour
+- Development scripts for performing benchmarks
+- Basic test coverage for transparency support
+
+### Changed
+- Extracted image operations to separate files within a dedicated module
+- [BREAKING] Introduced raising Morandi's own errors instead of bubbling Pixbuf's
+
+### Fixed
+- Updated required ruby version in gemspec to reflect dropping Ruby 2.3 support
+
+### Removed
+- [BREAKING] `config` accessor in ImageProcessor removed in favour of `user_options` supplied in constructor
+
+## [0.99.03] 19.09.2024
 ### Added
 - Copied pixbufutils and redeye gems into main gem
 - Added gdk_pixbuf_cairo C extension to convert between GdkPixbufs and ImageSurfaces
@@ -12,15 +45,15 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - Bumped version to 0.99.01 in preparation for a 1.0 release
 
 ### Removed
-- support for Ruby 2.0 (and illusion of it being tested by CI)
-- support for Ruby 2.3
+- [BREAKING] support for Ruby 2.0 (and illusion of it being tested by CI)
+- [BREAKING] support for Ruby 2.3
 - gtk2 dependency
 
 ## [0.13.0] 16.12.2020
 ### Fixed
 - Refactored test suite
 - Fixed most rubocop offenses
-### Aded
+### Added
 - CI pipeline
 - rubocop
 - Development image
@@ -32,7 +65,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 ## [0.12.0] 10.12.2020
 ### Fixed
 - Compatability with gdk_pixbuf v3.4.0+ [TECH-14001]
-### Aded
+### Added
 - .ruby-version file
 
 

data/README.md

@@ -1,11 +1,10 @@
 # Morandi
 
-Library of simple image manipulations - replicating the behaviour of
-morandi-js.
+Library of simple image manipulations - replicating the behaviour of morandi-js.
 
 ## Installation
 
-Install `liblcms2-utils` to provide the `jpgicc` command used by `Morandi::ProfiledPixbuf`. Also ensure that your host system has `imagemagick` installed, which is required bi the `colorscore` gem.
+Install `liblcms2-utils` to provide the `jpgicc` command used by `Morandi::ProfiledPixbuf`. Also ensure that your host system has `imagemagick` installed, which is required by the `colorscore` gem.
 
 Add this line to your application's Gemfile:
 
@@ -22,26 +21,10 @@ Or install it yourself as:
 ## Usage
 
 ````
-   Morandi.process(in_file, settings, out_file)
+   Morandi.process(source, options, target_path)
 ````
-- in_file is a string
-- settings is a hash
-- out_file is a string
-
-Settings Key | Values | Description
--------------|--------|---------------
-brighten     | Integer -20..20 | Change image brightness
-gamma        | Float  | Gamma correct image
-contrast     | Integer -20..20  | Change image contrast
-sharpen      | Integer -5..5  | Sharpen / Blur (negative value)
-redeye       | Array[[Integer,Integer],...]  | Apply redeye correction at point
-angle        | Integer 0,90,180,270  | Rotate image
-straighten   | Float | Rotate by N degrees and zoom
-crop         | Array[Integer,Integer,Integer,Integer] | Crop image
-fx           | String greyscale,sepia,bluetone | Apply colour filters
-border-style  | String square,retro | Set border style
-background-style  | String retro,black,white | Set border colour
-quality       | String '1'..'100' | Set JPG compression value, defaults to 97%
+
+For the detailed documentation of options see `lib/morandi.rb`
 
 ## Contributing
 
@@ -53,4 +36,4 @@ quality       | String '1'..'100' | Set JPG compression value, defaults to 97%
 
 ### Development
 
-Since this gem depends on the `liblcms2-utils` library, which can be awkward to install on some operating systems, we also provide a development docker image. A Makefile is also provided as a simple CLI. To build the image and run the container, type `make` from the project root. The container itself runs `guard` as its main process. Running the container via `make` will drop you into the guard  prompt, which will run the test suite whenever any of the source code or tests are changed. The tests can be kicked-off manually via the `all` command at the guard prompt. Individual test can be run using the `focus: true` annotation on an example or describe block. If you need to access a bash shell in the container (for example, to run rubocop), use the command `make shell`.
+Since this gem depends on the `liblcms2-utils` library, which can be awkward to install on some operating systems, we also provide a development docker image. A Makefile is also provided as a simple CLI. To build the image and run the container, type `make` from the project root. The container itself runs `guard` as its main process. Running the container via `make` will drop you into the guard prompt, which will run the test suite whenever any of the source code or tests are changed. The tests can be kicked-off manually via the `all` command at the guard prompt. Individual test can be run using the `focus: true` annotation on an example or describe block. If you need to access a bash shell in the container (for example, to run rubocop), use the command `make shell`.

data/lib/morandi/crop_utils.rb

@@ -91,5 +91,39 @@ module Morandi
       end
       pixbuf
     end
+
+    def apply_crop_vips(img, x_coord, y_coord, width, height)
+      if x_coord.negative? ||
+         y_coord.negative? ||
+         ((x_coord + width) > img.width) ||
+         ((y_coord + height) > img.height)
+
+        extract_area_x = [0, x_coord].max
+        extract_area_y = [0, y_coord].max
+        area_to_copy = img.extract_area(extract_area_x, extract_area_y, img.width - extract_area_x,
+                                        img.height - extract_area_y)
+
+        fill_colour = [255, 255, 255]
+        pixel = (Vips::Image.black(1, 1).colourspace(:srgb) + fill_colour).cast(img.format)
+        canvas = pixel.embed 0, 0, width, height, extend: :copy
+
+        cropped = canvas.composite(area_to_copy, :over, x: [-x_coord, 0].max,
+                                                        y: [-y_coord, 0].max,
+                                                        compositing_space: area_to_copy.interpretation)
+
+        # Because image is drawn on an opaque white, alpha doesn't matter at this point anyway, so let's strip the
+        # alpha channel from the output. According to #composite docs, the resulting image always has alpha channel,
+        # but I added a guard to avoid regressions if that ever changes.
+        cropped = cropped.extract_band(0, n: cropped.bands - 1) if cropped.has_alpha?
+        cropped
+      else
+        x_coord = x_coord.clamp(0, img.width)
+        y_coord = y_coord.clamp(0, img.height)
+        width = width.clamp(1, img.width - x_coord)
+        height = height.clamp(1, img.height - y_coord)
+
+        img.crop(x_coord, y_coord, width, height)
+      end
+    end
   end
 end

data/lib/morandi/errors.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Morandi
+  class Error < StandardError
+  end
+
+  class CorruptImageError < Error
+  end
+
+  class UnknownTypeError < Error
+  end
+end

data/lib/morandi/image_operation.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'colorscore'
-
 module Morandi
   # Base Image Op class
   # @!visibility private
@@ -30,176 +28,4 @@ module Morandi
       final_pb
     end
   end
-
-  # Straighten operation
-  # Does a small (ie. not 90,180,270 deg) rotation and zooms to avoid cropping
-  # @!visibility private
-  class Straighten < ImageOperation
-    attr_accessor :angle
-
-    def call(_image, pixbuf)
-      return pixbuf if angle.zero?
-
-      rotation_value_rad = angle * (Math::PI / 180)
-
-      ratio = pixbuf.width.to_f / pixbuf.height
-      rh = pixbuf.height / ((ratio * Math.sin(rotation_value_rad.abs)) + Math.cos(rotation_value_rad.abs))
-      scale = pixbuf.height / rh.to_f.abs
-
-      a_ratio = pixbuf.height.to_f / pixbuf.width
-      a_rh = pixbuf.width / ((a_ratio * Math.sin(rotation_value_rad.abs)) + Math.cos(rotation_value_rad.abs))
-      a_scale = pixbuf.width / a_rh.to_f.abs
-
-      scale = a_scale if a_scale > scale
-
-      create_pixbuf_from_image_surface(:rgb24, pixbuf.width, pixbuf.height) do |cr|
-        cr.translate(pixbuf.width / 2.0, pixbuf.height / 2.0)
-        cr.rotate(rotation_value_rad)
-        cr.scale(scale, scale)
-        cr.translate(pixbuf.width / -2.0, pixbuf.height / - 2.0)
-        cr.set_source_pixbuf(pixbuf)
-
-        cr.rectangle(0, 0, pixbuf.width, pixbuf.height)
-        cr.paint(1.0)
-      end
-    end
-  end
-
-  # Image Border operation
-  # Supports retro (rounded) and square borders
-  # Background colour (ie. border colour) can be white, black, dominant (ie. from image)
-  # @!visibility private
-  class ImageBorder < ImageOperation
-    attr_accessor :style, :colour, :crop, :size, :print_size, :shrink, :border_size
-
-    def call(_image, pixbuf)
-      return pixbuf unless %w[square retro].include? @style
-
-      create_pixbuf_from_image_surface(:rgb24, pixbuf.width, pixbuf.height) do |cr|
-        if @crop && ((@crop[0]).negative? || (@crop[1]).negative?)
-          img_width = size[0]
-          img_height = size[1]
-        else
-          img_width = pixbuf.width
-          img_height = pixbuf.height
-        end
-
-        @border_scale = [img_width, img_height].max.to_f / print_size.max.to_i
-
-        draw_background(cr, img_height, img_width, pixbuf)
-
-        x = border_width
-        y = border_width
-
-        # This biggest impact will be on the smallest side, so to avoid white
-        # edges between photo and border scale by the longest changed side.
-        longest_side = [pixbuf.width, pixbuf.height].max.to_f
-
-        # Should be less than 1
-        pb_scale = (longest_side - (border_width * 2)) / longest_side
-
-        if @crop && ((@crop[0]).negative? || (@crop[1]).negative?)
-          x -= @crop[0]
-          y -= @crop[1]
-        end
-
-        draw_pixbuf(pixbuf, cr, img_height, img_width, pb_scale, x, y)
-      end
-    end
-
-    private
-
-    # Width is proportional to output size
-    def border_width
-      @border_size * @border_scale
-    end
-
-    def draw_pixbuf(pixbuf, cr, img_height, img_width, pb_scale, x, y)
-      case style
-      when 'retro'
-        Morandi::CairoExt.rounded_rectangle(cr, x, y,
-                                            img_width + x - (border_width * 2),
-                                            img_height + y - (border_width * 2), border_width)
-      when 'square'
-        cr.rectangle(x, y, img_width - (border_width * 2), img_height - (border_width * 2))
-      end
-      cr.clip
-
-      if @shrink
-        cr.translate(border_width, border_width)
-        cr.scale(pb_scale, pb_scale)
-      end
-      cr.set_source_pixbuf(pixbuf)
-      cr.rectangle(0, 0, pixbuf.width, pixbuf.height)
-
-      cr.paint(1.0)
-    end
-
-    def draw_background(cr, img_height, img_width, pixbuf)
-      cr.save do
-        cr.translate(-@crop[0], -@crop[1]) if @crop && ((@crop[0]).negative? || (@crop[1]).negative?)
-
-        cr.save do
-          cr.set_operator :source
-          cr.set_source_rgb 1, 1, 1
-          cr.paint
-
-          cr.rectangle(0, 0, img_width, img_height)
-          case colour
-          when 'dominant'
-            pixbuf.scale_max(400).save(fn = "/tmp/hist-#{$PROCESS_ID}.#{Time.now.to_i}", 'jpeg')
-            histogram = Colorscore::Histogram.new(fn)
-            FileUtils.rm_f(fn)
-            col = histogram.scores.first[1]
-            cr.set_source_rgb col.red / 256.0, col.green / 256.0, col.blue / 256.0
-          when 'retro'
-            cr.set_source_rgb 1, 1, 0.8
-          when 'black'
-            cr.set_source_rgb 0, 0, 0
-          else
-            cr.set_source_rgb 1, 1, 1
-          end
-          cr.fill
-        end
-      end
-    end
-  end
-
-  # Colourify Operation
-  # Apply tint to image with variable strength
-  # Supports filter, alpha
-  class Colourify < ImageOperation
-    attr_reader :filter
-
-    def alpha
-      @alpha || 255
-    end
-
-    def sepia(pixbuf)
-      MorandiNative::PixbufUtils.tint(pixbuf, 25, 5, -25, alpha)
-    end
-
-    def bluetone(pixbuf)
-      MorandiNative::PixbufUtils.tint(pixbuf, -10, 5, 25, alpha)
-    end
-
-    def null(pixbuf)
-      pixbuf
-    end
-    alias full null # WebKiosk
-    alias colour null # WebKiosk
-
-    def greyscale(pixbuf)
-      MorandiNative::PixbufUtils.tint(pixbuf, 0, 0, 0, alpha)
-    end
-    alias bw greyscale # WebKiosk
-
-    def call(_image, pixbuf)
-      if @filter && respond_to?(@filter)
-        __send__(@filter, pixbuf)
-      else
-        pixbuf # Default is nothing
-      end
-    end
-  end
 end

data/lib/morandi/image_processor.rb

@@ -2,6 +2,9 @@
 
 require 'morandi/profiled_pixbuf'
 require 'morandi/redeye'
+require 'morandi/operation/straighten'
+require 'morandi/operation/colourify'
+require 'morandi/operation/image_border'
 
 module Morandi
   # rubocop:disable Metrics/ClassLength
@@ -9,7 +12,6 @@ module Morandi
   # ImageProcessor transforms an image.
   class ImageProcessor
     attr_reader :options, :pb
-    attr_accessor :config
 
     def initialize(file, user_options, local_options = {})
       @file = file
@@ -20,7 +22,7 @@ module Morandi
       @options = (local_options || {}).merge(user_options || {})
       @local_options = local_options
 
-      @scale_to = @options['output.max']
+      @max_size_px = @options['output.max']
       @width = @options['output.width']
       @height = @options['output.height']
     end
@@ -55,6 +57,10 @@ module Morandi
       @pb = @pb.scale_max([@width, @height].max) if @options['output.limit'] && @width && @height
 
       @pb
+    rescue GdkPixbuf::PixbufError::UnknownType => e
+      raise UnknownTypeError, e.message
+    rescue GdkPixbuf::PixbufError::CorruptImage => e
+      raise CorruptImageError, e.message
     end
 
     # Returns generated pixbuf
@@ -84,16 +90,18 @@ module Morandi
 
     def get_pixbuf
       _, width, height = GdkPixbuf::Pixbuf.get_file_info(@file)
-      @pb = Morandi::ProfiledPixbuf.new(@file, @local_options, @scale_to)
-      @actual_max = [@pb.width, @pb.height].max
-
-      @src_max = if @scale_to
-                   [width, height].max
-                 else
-                   [@pb.width, @pb.height].max
-                 end
-
-      @scale = @actual_max / @src_max.to_f
+      @pb = Morandi::ProfiledPixbuf.new(@file, @local_options, @max_size_px)
+
+      # Everything below probably could be substituted with the following:
+      # @scale = @max_size_px ? @max_size_px / [width, height].max : 1.0
+      actual_max = [@pb.width, @pb.height].max
+      src_max = if @max_size_px
+                  [width, height].max
+                else
+                  [@pb.width, @pb.height].max
+                end
+
+      @scale = actual_max / src_max.to_f
     end
 
     SHARPEN = [
@@ -159,8 +167,7 @@ module Morandi
       @pb = @pb.rotate(a) unless (a % 360).zero?
 
       unless options['straighten'].to_f.zero?
-        @pb = Morandi::Straighten.new_from_hash(angle: options['straighten'].to_f).call(nil,
-                                                                                        @pb)
+        @pb = Morandi::Operation::Straighten.new_from_hash(angle: options['straighten'].to_f).call(@pb)
       end
 
       @image_width = @pb.width
@@ -172,7 +179,6 @@ module Morandi
     }.freeze
     def config_for(key)
       return options[key] if options&.key?(key)
-      return @config[key] if @config&.key?(key)
 
       DEFAULT_CONFIG[key]
     end
@@ -203,11 +209,11 @@ module Morandi
 
       case filter
       when 'greyscale', 'sepia', 'bluetone'
-        op = Morandi::Colourify.new_from_hash('filter' => filter)
+        op = Morandi::Operation::Colourify.new_from_hash('filter' => filter)
       else
         return
       end
-      @pb = op.call(nil, @pb)
+      @pb = op.call(@pb)
     end
 
     def apply_decorations!
@@ -222,7 +228,7 @@ module Morandi
       crop = options['crop']
       crop = crop.map { |s| (s.to_f * @scale).floor } if crop && not_equal_to_one(@scale)
 
-      op = Morandi::ImageBorder.new_from_hash(
+      op = Morandi::Operation::ImageBorder.new_from_hash(
         'style' => style,
         'colour' => colour || '#000000',
         'crop' => crop,
@@ -232,7 +238,7 @@ module Morandi
         'border_size' => @scale * config_for('border-size-mm').to_i * 300 / 25.4 # 5mm at 300dpi
       )
 
-      @pb = op.call(nil, @pb)
+      @pb = op.call(@pb)
     end
 
     private

data/lib/morandi/operation/colourify.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'morandi/image_operation'
+
+module Morandi
+  module Operation
+    # Colourify Operation
+    # Apply tint to image with variable strength
+    # Supports filter, alpha
+    class Colourify < ImageOperation
+      attr_reader :filter
+
+      def alpha
+        @alpha || 255
+      end
+
+      def sepia(pixbuf)
+        MorandiNative::PixbufUtils.tint(pixbuf, 25, 5, -25, alpha)
+      end
+
+      def bluetone(pixbuf)
+        MorandiNative::PixbufUtils.tint(pixbuf, -10, 5, 25, alpha)
+      end
+
+      def null(pixbuf)
+        pixbuf
+      end
+      alias full null # WebKiosk
+      alias colour null # WebKiosk
+
+      def greyscale(pixbuf)
+        MorandiNative::PixbufUtils.tint(pixbuf, 0, 0, 0, alpha)
+      end
+      alias bw greyscale # WebKiosk
+
+      def call(pixbuf)
+        if @filter && respond_to?(@filter)
+          __send__(@filter, pixbuf)
+        else
+          pixbuf # Default is nothing
+        end
+      end
+    end
+  end
+end

data/lib/morandi/operation/image_border.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'colorscore'
+require 'morandi/image_operation'
+
+module Morandi
+  module Operation
+    # Image Border operation
+    # Supports retro (rounded) and square borders
+    # Background colour (ie. border colour) can be white, black
+    # @!visibility private
+    class ImageBorder < ImageOperation
+      attr_accessor :style, :colour, :crop, :size, :print_size, :shrink, :border_size
+
+      def call(pixbuf)
+        return pixbuf unless %w[square retro].include? @style
+
+        create_pixbuf_from_image_surface(:rgb24, pixbuf.width, pixbuf.height) do |cr|
+          if @crop && ((@crop[0]).negative? || (@crop[1]).negative?)
+            img_width = size[0]
+            img_height = size[1]
+          else
+            img_width = pixbuf.width
+            img_height = pixbuf.height
+          end
+
+          @border_scale = [img_width, img_height].max.to_f / print_size.max.to_i
+
+          draw_background(cr, img_height, img_width)
+
+          x = border_width
+          y = border_width
+
+          # This biggest impact will be on the smallest side, so to avoid white
+          # edges between photo and border scale by the longest changed side.
+          longest_side = [pixbuf.width, pixbuf.height].max.to_f
+
+          # Should be less than 1
+          pb_scale = (longest_side - (border_width * 2)) / longest_side
+
+          if @crop && ((@crop[0]).negative? || (@crop[1]).negative?)
+            x -= @crop[0]
+            y -= @crop[1]
+          end
+
+          draw_pixbuf(pixbuf, cr, img_height, img_width, pb_scale, x, y)
+        end
+      end
+
+      private
+
+      # Width is proportional to output size
+      def border_width
+        @border_size * @border_scale
+      end
+
+      def draw_pixbuf(pixbuf, cr, img_height, img_width, pb_scale, x, y)
+        case style
+        when 'retro'
+          Morandi::CairoExt.rounded_rectangle(cr, x, y,
+                                              img_width + x - (border_width * 2),
+                                              img_height + y - (border_width * 2), border_width)
+        when 'square'
+          cr.rectangle(x, y, img_width - (border_width * 2), img_height - (border_width * 2))
+        end
+        cr.clip
+
+        if @shrink
+          cr.translate(border_width, border_width)
+          cr.scale(pb_scale, pb_scale)
+        end
+        cr.set_source_pixbuf(pixbuf)
+        cr.rectangle(0, 0, pixbuf.width, pixbuf.height)
+
+        cr.paint(1.0)
+      end
+
+      def draw_background(cr, img_height, img_width)
+        cr.save do
+          cr.translate(-@crop[0], -@crop[1]) if @crop && ((@crop[0]).negative? || (@crop[1]).negative?)
+
+          cr.save do
+            cr.set_operator :source
+            cr.set_source_rgb 1, 1, 1
+            cr.paint
+
+            cr.rectangle(0, 0, img_width, img_height)
+            case colour
+            when 'retro'
+              cr.set_source_rgb 1, 1, 0.8
+            when 'black'
+              cr.set_source_rgb 0, 0, 0
+            else
+              cr.set_source_rgb 1, 1, 1
+            end
+            cr.fill
+          end
+        end
+      end
+    end
+  end
+end

data/lib/morandi/operation/straighten.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'morandi/image_operation'
+
+module Morandi
+  module Operation
+    # Straighten operation
+    # Does a small (ie. not 90,180,270 deg) rotation and zooms to avoid cropping
+    # @!visibility private
+    class Straighten < ImageOperation
+      attr_accessor :angle
+
+      def call(pixbuf)
+        return pixbuf if angle.zero?
+
+        rotation_value_rad = angle * (Math::PI / 180)
+
+        ratio = pixbuf.width.to_f / pixbuf.height
+        rh = pixbuf.height / ((ratio * Math.sin(rotation_value_rad.abs)) + Math.cos(rotation_value_rad.abs))
+        scale = pixbuf.height / rh.to_f.abs
+
+        a_ratio = pixbuf.height.to_f / pixbuf.width
+        a_rh = pixbuf.width / ((a_ratio * Math.sin(rotation_value_rad.abs)) + Math.cos(rotation_value_rad.abs))
+        a_scale = pixbuf.width / a_rh.to_f.abs
+
+        scale = a_scale if a_scale > scale
+
+        create_pixbuf_from_image_surface(:rgb24, pixbuf.width, pixbuf.height) do |cr|
+          cr.translate(pixbuf.width / 2.0, pixbuf.height / 2.0)
+          cr.rotate(rotation_value_rad)
+          cr.scale(scale, scale)
+          cr.translate(pixbuf.width / -2.0, pixbuf.height / - 2.0)
+          cr.set_source_pixbuf(pixbuf)
+
+          cr.rectangle(0, 0, pixbuf.width, pixbuf.height)
+          cr.paint(1.0)
+        end
+      end
+    end
+  end
+end

data/lib/morandi/operation/vips_straighten.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Morandi
+  module Operation
+    # Straighten operation
+    # Does a small (ie. not 90,180,270 deg) rotation and zooms to avoid cropping
+    # @!visibility private
+    class VipsStraighten < ImageOperation
+      # Colour for filling background post-rotation. It can bleed into the edge pixels during resize.
+      # Setting it to gray minimises the average impact
+      ROTATION_BACKGROUND_FILL_COLOUR = 127
+      ROTATION_BACKGROUND_FILL_ALPHA = 255
+
+      def self.rotation_background_fill_colour(channels_count:, alpha:)
+        return [ROTATION_BACKGROUND_FILL_COLOUR] * channels_count unless alpha # Eg [127, 127, 127] for RGB
+
+        # Eg [127, 127, 127, 255] for RGBA
+        ([ROTATION_BACKGROUND_FILL_COLOUR] * (channels_count - 1)) + [ROTATION_BACKGROUND_FILL_ALPHA]
+      end
+
+      attr_accessor :angle
+
+      def call(img)
+        return img if angle.zero?
+
+        original_width = img.width
+        original_height = img.height
+
+        # It is possible to first rotate, then fetch width/height of resulting image to calculate scale,
+        # but that would make us lose precision which degrades cropping accuracy
+        rotation_value_rad = angle * (Math::PI / 180)
+        post_rotation_bounding_box_width = (img.height.to_f * Math.sin(rotation_value_rad).abs) +
+                                           (img.width.to_f * Math.cos(rotation_value_rad).abs)
+        post_rotation_bounding_box_height = (img.width.to_f * Math.sin(rotation_value_rad).abs) +
+                                            (img.height.to_f * Math.cos(rotation_value_rad).abs)
+
+        # Calculate scaling required to fit the original width/height within rotated image without including background
+        scale = [post_rotation_bounding_box_width / original_width,
+                 post_rotation_bounding_box_height / original_height].max
+
+        background_fill_colour = self.class.rotation_background_fill_colour(channels_count: img.bands,
+                                                                            alpha: img.has_alpha?)
+        img = img.similarity(angle: angle, scale: scale, background: background_fill_colour)
+
+        # Better precision than img.width/img.height due to fractions preservation
+        post_scale_bounding_box_width = post_rotation_bounding_box_width * scale
+        post_scale_bounding_box_height = post_rotation_bounding_box_height * scale
+
+        width_diff = post_scale_bounding_box_width - original_width
+        height_diff = post_scale_bounding_box_height - original_height
+
+        # Round to nearest integer to reduce risk of ROTATION_BACKGROUND_FILL_COLOUR being visible in the corner
+        crop_x = (width_diff / 2).round
+        crop_y = (height_diff / 2).round
+
+        img.crop(crop_x, crop_y, original_width, original_height)
+      end
+    end
+  end
+end

data/lib/morandi/pixbuf_ext.rb

@@ -10,6 +10,7 @@ module GdkPixbuf
       GdkPixbufCairo.pixbuf_to_surface(self)
     end
 
+    # Proportionally scales down the image so that it fits within max_size*max_size square
     def scale_max(max_size, interp = GdkPixbuf::InterpType::BILINEAR, _max_scale = 1.0)
       mul = (max_size / [width, height].max.to_f)
       mul = [1.0, mul].min

data/lib/morandi/profiled_pixbuf.rb

@@ -1,61 +1,29 @@
 # frozen_string_literal: true
 
 require 'gdk_pixbuf2'
+require 'morandi/srgb_conversion'
 
 module Morandi
   # ProfiledPixbuf is a descendent of GdkPixbuf::Pixbuf with ICC support.
   # It attempts to load an image using jpegicc/littlecms to ensure that it is sRGB.
+  # NOTE: pixbuf supports colour profiles, but it requires an explicit icc-profile option to embed it when saving file
   class ProfiledPixbuf < GdkPixbuf::Pixbuf
-    def valid_jpeg?(filename)
-      return false unless File.exist?(filename)
-      return false unless File.size(filename).positive?
-
-      type, = GdkPixbuf::Pixbuf.get_file_info(filename)
-
-      type && type.name.eql?('jpeg')
-    rescue StandardError
-      false
-    end
-
-    # TODO: this doesn't use lcms
-    def self.from_string(string, loader: nil, chunk_size: 4096)
-      loader ||= GdkPixbuf::PixbufLoader.new
-      ((string.bytesize + chunk_size - 1) / chunk_size).times do |i|
-        loader.write(string.byteslice(i * chunk_size, chunk_size))
-      end
-      loader.close
-      loader.pixbuf
-    end
-
-    def self.default_icc_path(path)
-      "#{path}.icc.jpg"
-    end
-
-    def initialize(file, local_options, scale_to = nil)
+    def initialize(path, local_options, max_size_px = nil)
       @local_options = local_options
-      @file = file
 
-      if suitable_for_jpegicc?
-        icc_file = icc_cache_path
-        valid_jpeg?(icc_file) || system('jpgicc', '-q97', @file, icc_file)
-        file = icc_file if valid_jpeg?(icc_file)
-      end
+      path = srgb_path(path) || path
 
-      if scale_to
-        super(file: file, width: scale_to, height: scale_to)
+      if max_size_px
+        super(file: path, width: max_size_px, height: max_size_px)
       else
-        super(file: file)
+        super(file: path)
       end
     end
 
     private
 
-    def suitable_for_jpegicc?
-      valid_jpeg?(@file)
-    end
-
-    def icc_cache_path
-      @local_options['path.icc'] || Morandi::ProfiledPixbuf.default_icc_path(@file)
+    def srgb_path(original_path)
+      Morandi::SrgbConversion.perform(original_path, target_path: @local_options['path.icc'])
     end
   end
 end

data/lib/morandi/srgb_conversion.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'gdk_pixbuf2'
+
+module Morandi
+  # Converts the file under `path` to sRGB colour space
+  class SrgbConversion
+    # Performs a conversion to srgb colour space if possible
+    # Returns a path to converted file on success or nil on failure
+    def self.perform(path, target_path: nil)
+      return unless suitable_for_jpegicc?(path)
+
+      icc_file_path = target_path || default_icc_path(path)
+      return icc_file_path if valid_jpeg?(icc_file_path)
+
+      system('jpgicc', '-q97', path, icc_file_path, out: '/dev/null', err: '/dev/null')
+
+      return unless valid_jpeg?(icc_file_path)
+
+      icc_file_path
+    end
+
+    def self.default_icc_path(path)
+      "#{path}.icc.jpg"
+    end
+
+    def self.valid_jpeg?(path)
+      return false unless File.exist?(path)
+      return false unless File.size(path).positive?
+
+      type, = GdkPixbuf::Pixbuf.get_file_info(path)
+
+      type && type.name.eql?('jpeg')
+    rescue StandardError
+      false
+    end
+
+    def self.suitable_for_jpegicc?(path)
+      valid_jpeg?(path)
+    end
+  end
+end

data/lib/morandi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Morandi
-  VERSION = '0.99.03'
+  VERSION = '0.100.0'
 end

data/lib/morandi/vips_image_processor.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require 'vips'
+
+require 'morandi/srgb_conversion'
+require 'morandi/operation/vips_straighten'
+
+module Morandi
+  # An alternative to ImageProcessor which is based on libvips for concurrent and less memory-intensive processing
+  class VipsImageProcessor
+    # Colour filter related constants
+    RGB_LUMINANCE_EXTRACTION_FACTORS = [0.3086, 0.6094, 0.0820].freeze
+    SEPIA_MODIFIER = [25, 5, -25].freeze
+    BLUETONE_MODIFIER = [-10, 5, 25].freeze
+    COLOUR_FILTER_MODIFIERS = {
+      'sepia' => SEPIA_MODIFIER,
+      'bluetone' => BLUETONE_MODIFIER
+    }.freeze
+    SUPPORTED_FILTERS = COLOUR_FILTER_MODIFIERS.keys + ['greyscale']
+
+    def self.supports?(input, options)
+      return false unless input.is_a?(String)
+      return false if options['brighten'].to_f != 0
+      return false if options['contrast'].to_f != 0
+      return false if options['sharpen'].to_f != 0
+      return false if options['redeye']&.any?
+      return false if options['border-style']
+      return false if options['background-style']
+
+      true
+    end
+
+    # Vips options are global, this method sets them for yielding, then restores to original
+    def self.with_global_options(cache_max:, concurrency:)
+      previous_cache_max = Vips.cache_max
+      previous_concurrency = Vips.concurrency
+
+      Vips.cache_set_max(cache_max)
+      Vips.concurrency_set(concurrency)
+
+      yield
+    ensure
+      Vips.cache_set_max(previous_cache_max)
+      Vips.concurrency_set(previous_concurrency)
+    end
+
+    def initialize(path, user_options)
+      @path = path
+
+      @options = user_options
+
+      @size_limit_on_load_px = @options['output.max']
+      @output_width = @options['output.width']
+      @output_height = @options['output.height']
+    end
+
+    def process!
+      source_file_path = Morandi::SrgbConversion.perform(@path) || @path
+      begin
+        @img = Vips::Image.new_from_file(source_file_path)
+      rescue Vips::Error => e
+        # Match the known errors
+        raise UnknownTypeError if /is not a known file format/.match?(e.message)
+        raise CorruptImageError if /Premature end of JPEG file/.match?(e.message)
+
+        # Re-raise generic Error when unknown
+        raise Error, e.message
+      end
+      if @size_limit_on_load_px
+        @scale = @size_limit_on_load_px.to_f / [@img.width, @img.height].max
+        @img = @img.resize(@scale) if not_equal_to_one(@scale)
+      else
+        @scale = 1.0
+      end
+
+      apply_gamma!
+      apply_rotate!
+      apply_crop!
+      apply_filters!
+
+      if @options['output.limit'] && @output_width && @output_height
+        scale_factor = [@output_width, @output_height].max.to_f / [@img.width, @img.height].max
+        @img = @img.resize(scale_factor) if scale_factor < 1.0
+      end
+
+      strip_alpha!
+      ensure_srgb!
+    end
+
+    def write_to_png(_write_to, _orientation = :any)
+      raise 'not implemented'
+    end
+
+    def write_to_jpeg(target_path, quality = nil)
+      process!
+
+      quality ||= @options.fetch('quality', 97)
+
+      target_path_jpg = "#{target_path}.jpg" # Vips chooses format based on file extension, this ensures jpg
+      @img.write_to_file(target_path_jpg, Q: quality)
+      FileUtils.mv(target_path_jpg, target_path)
+    end
+
+    private
+
+    # Remove the alpha channel if present. Vips supports alpha, but the current Pixbuf processor happens to strip it in
+    # most cases (straighten and cropping beyond image bounds are exceptions)
+    #
+    # Alternatively, alpha can be left intact for more accurate processing and transparent output or merged into an
+    # image using Vips::Image#flatten for less resource-intensive processing
+    def strip_alpha!
+      @img = @img.extract_band(0, n: @img.bands - 1) if @img.has_alpha?
+    end
+
+    def apply_gamma!
+      return unless @options['gamma'] && not_equal_to_one(@options['gamma'])
+
+      @img = @img.gamma(exponent: @options['gamma'])
+    end
+
+    def angle
+      @options['angle'].to_i % 360
+    end
+
+    def apply_rotate!
+      @img = case angle
+             when 0 then @img
+             when 90 then @img.rot90
+             when 180 then @img.rot180
+             when 270 then @img.rot270
+             else raise('"angle" option only accepts multiples of 90')
+             end
+
+      unless @options['straighten'].to_f.zero?
+        @img = Morandi::Operation::VipsStraighten.new_from_hash(angle: @options['straighten'].to_f).call(@img)
+      end
+
+      @image_width = @img.width
+      @image_height = @img.height
+    end
+
+    def apply_crop!
+      crop = @options['crop']
+
+      return if crop.nil? && @options['image.auto-crop'].eql?(false)
+
+      crop = crop.split(',').map(&:to_i) if crop.is_a?(String) && crop =~ /^\d+,\d+,\d+,\d+/
+
+      crop = nil unless crop.is_a?(Array) && crop.size.eql?(4) && crop.all? do |i|
+        i.is_a?(Numeric)
+      end
+      # can't crop, won't crop
+      return if @output_width.nil? && @output_height.nil? && crop.nil?
+
+      crop = crop.map { |s| (s.to_f * @scale).floor } if crop && not_equal_to_one(@scale)
+      crop ||= Morandi::CropUtils.autocrop_coords(@img.width, @img.height, @output_width, @output_height)
+      @img = Morandi::CropUtils.apply_crop_vips(@img, crop[0], crop[1], crop[2], crop[3])
+    end
+
+    def apply_filters!
+      filter_name = @options['fx']
+      return unless SUPPORTED_FILTERS.include?(filter_name)
+
+      # The filter-related constants assume RGB colourspace, so it requires early conversion
+      ensure_srgb!
+
+      # Convert to greyscale using weights
+      rgb_factors = RGB_LUMINANCE_EXTRACTION_FACTORS
+      recombination_matrix = [rgb_factors, rgb_factors, rgb_factors]
+      if @img.has_alpha?
+        # Add "0" multiplier for alpha to ignore it for luminance calculation
+        recombination_matrix = recombination_matrix.map { |channel_multipliers| channel_multipliers + [0] }
+        # Add fourth row in the matrix to preserve unchanged alpha channel
+        recombination_matrix << [0, 0, 0, 1]
+      end
+      @img = @img.recomb(recombination_matrix)
+
+      return unless COLOUR_FILTER_MODIFIERS[filter_name]
+
+      # Apply colour adjustment based on the modifiers setup
+      colour_filter_modifier = COLOUR_FILTER_MODIFIERS[filter_name]
+      colour_filter_modifier += [0] if @img.has_alpha?
+      @img = @img.linear(1.0, colour_filter_modifier)
+    end
+
+    def not_equal_to_one(float)
+      (float - 1.0).abs >= Float::EPSILON
+    end
+
+    def ensure_srgb!
+      @img = @img.colourspace(:srgb) unless @img.interpretation == :srgb
+    end
+  end
+end

data/lib/morandi.rb

@@ -5,8 +5,9 @@ require 'morandi_native'
 
 require 'morandi/cairo_ext'
 require 'morandi/pixbuf_ext'
+require 'morandi/errors'
 require 'morandi/image_processor'
-require 'morandi/image_operation'
+require 'morandi/vips_image_processor'
 require 'morandi/redeye'
 require 'morandi/crop_utils'
 
@@ -14,29 +15,53 @@ require 'morandi/crop_utils'
 module Morandi
   module_function
 
-  # The main entry point for the libray
+  # The main entry point for the library
   #
-  # @param in_file [String|GdkPixbuf::Pixbuf] source image
-  # @param settings [Hash]
-  # @param out_file [String] target location for image
-  # @param local_options [Hash]
-  #
-  # Settings Key | Values | Description
-  # -------------|--------|---------------
-  # brighten     | Integer -20..20 | Change image brightness
-  # gamma        | Float  | Gamma correct image
-  # contrast     | Integer -20..20  | Change image contrast
-  # sharpen      | Integer -5..5  | Sharpen / Blur (negative value)
-  # redeye       | Array[[Integer,Integer],...]  | Apply redeye correction at point
-  # angle        | Integer 0,90,180,270  | Rotate image
-  # crop         | Array[Integer,Integer,Integer,Integer] | Crop image
-  # fx           | String greyscale,sepia,bluetone | Apply colour filters
-  # border-style  | String square,retro | Set border style
-  # background-style  | String retro,black,white | Set border colour
-  # quality       | String '1'..'100' | Set JPG compression value, defaults to 97%
-  def process(file_in, options, file_out, local_options = {})
-    pro = ImageProcessor.new(file_in, options, local_options)
-    pro.result
-    pro.write_to_jpeg(file_out)
+  # @param source [String|GdkPixbuf::Pixbuf] source image
+  # @param [Hash] options The options describing expected processing to perform
+  # @option options [Integer] 'brighten' Change image brightness (-20..20)
+  # @option options [Float] 'gamma' Gamma correct image
+  # @option options [Integer] 'contrast' Change image contrast (-20..20)
+  # @option options [Integer] 'sharpen' Sharpen (1..5) / Blur (-1..-5)
+  # @option options [Integer] 'straighten' Rotate by a small angle (in degrees) and zoom in to fill the size
+  # @option options [Array[[Integer,Integer],...]] 'redeye' Apply redeye correction at point
+  # @option options [Integer] 'angle' Rotate image clockwise by multiple of 90 degrees (0, 90, 180, 270)
+  # @option options [Array[Integer,Integer,Integer,Integer]] 'crop' Crop image (x, y, width, height)
+  # @option options [String] 'fx' Apply colour filters ('greyscale', 'sepia', 'bluetone')
+  # @option options [String] 'border-style' Set border style ('square', 'retro')
+  # @option options [String] 'background-style' Set border colour ('retro', 'black', 'white')
+  # @option options [Integer] 'quality' (97) Set JPG compression value (1 to 100)
+  # @option options [Integer] 'output.max' Downscales the image to fit within the square of given size before
+  #                                        processing to limit the required resources
+  # @option options [Integer] 'output.width' Sets desired width of resulting image
+  # @option options [Integer] 'output.height' Sets desired height of resulting image
+  # @option options [TrueClass|FalseClass] 'image.auto-crop' (true) If the output dimensions are set and this is true,
+  #                                                                image is cropped automatically to the desired
+  #                                                                dimensions.
+  # @option options [TrueClass|FalseClass] 'output.limit' (false) If the output dimensions are defined and this is true,
+  #                                                              the output image is scaled down to fit within square of
+  #                                                              size of the longer edge (ignoring shorter dimension!)
+  # @param target_path [String] target location for image
+  # @param local_options [Hash] Hash of options other than desired transformations
+  # @option local_options [String] 'path.icc' A path to store the input after converting to sRGB colour space
+  # @option local_options [String] 'processor' ('pixbuf') Name of the image processing library ('pixbuf', 'vips')
+  #                                                       NOTE: vips processor only handles subset of operations,
+  #                                                       see `Morandi::VipsImageProcessor.supports?` for details
+  def process(source, options, target_path, local_options = {})
+    case local_options['processor']
+    when 'vips'
+      raise(ArgumentError, 'Requested unsupported Vips operation') unless VipsImageProcessor.supports?(source, options)
+
+      # Cache saves time in expense of RAM when performing the same processing multiple times
+      # Cache is also created for files based on their names, which can lead to leaking files data, so in terms
+      # of security it feels prudent to disable it. Latest libvips supports "revalidate" option to prevent that risk
+      cache_max = 0
+      concurrency = 2 # Hardcoding to 2 for now to maintain some balance between resource usage and performance
+      VipsImageProcessor.with_global_options(cache_max: cache_max, concurrency: concurrency) do
+        VipsImageProcessor.new(source, options).write_to_jpeg(target_path)
+      end
+    else
+      ImageProcessor.new(source, options, local_options).tap(&:result).write_to_jpeg(target_path)
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: morandi
 version: !ruby/object:Gem::Version
-  version: 0.99.03
+  version: 0.100.0
 platform: ruby
 authors:
 - |+
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-19 00:00:00.000000000 Z
+date: 2025-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: atk
@@ -97,6 +97,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: ruby-vips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Apply simple edits to images
 email:
 - git@intersect-uk.co.uk
@@ -122,12 +136,19 @@ files:
 - lib/morandi.rb
 - lib/morandi/cairo_ext.rb
 - lib/morandi/crop_utils.rb
+- lib/morandi/errors.rb
 - lib/morandi/image_operation.rb
 - lib/morandi/image_processor.rb
+- lib/morandi/operation/colourify.rb
+- lib/morandi/operation/image_border.rb
+- lib/morandi/operation/straighten.rb
+- lib/morandi/operation/vips_straighten.rb
 - lib/morandi/pixbuf_ext.rb
 - lib/morandi/profiled_pixbuf.rb
 - lib/morandi/redeye.rb
+- lib/morandi/srgb_conversion.rb
 - lib/morandi/version.rb
+- lib/morandi/vips_image_processor.rb
 - lib/morandi_native.so
 homepage: https://github.com/livelink/morandi-rb
 licenses:
@@ -143,7 +164,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.0'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="