morandi 0.99.4 → 0.100.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72cf19456503d11e3729ece721a4f8cf542ec674d5c35497d53efc8d333ebbd4
-  data.tar.gz: 3d05af03a553609b7bb4901071b675273127a329b323fb45bd1d7c071fe8aed5
+  metadata.gz: 0ca1f4a637e59ee90de4f309dfecc40eae27b103f416ea301af36e8bd04c555f
+  data.tar.gz: 8ebeda3024e6275ea7e8b75c8357339523a59a24987e1ebd07142cba445edce7
 SHA512:
-  metadata.gz: fa60e3b5ccefa7a76fa8e4f70d28f3ef1ad80e81a8f1d07c35a258e6748e9a4ce4e5923f82be682456a74c5ca8acc185030a783f925246bf04fad5776d20aed1
-  data.tar.gz: 9bfff0edf6d1d52d2be6f836138b60d35c22a788fc337c46c7837a9b719f91ca6347ff746bd79f757737d6f6abba5615dd9f480e79ed07a8e9d67085cf6e3ad2
+  metadata.gz: 55308d1a2ae4626a81bf1faa9a6ae0535f816d777e31d25266e36e563bdc1dc60c55ef588ade477ce113a13bd20f80aefd046a52c1e4aaccffdc103e48d75cac
+  data.tar.gz: c10ab8cbe21121d50a2c0a10cdb6c0fefe595962d11cf936adeaef78e8291bd4688b37bb464577c7f455d8aa02e04def65d46930a86fb3cbf9c1aed4e9abf972

data/CHANGELOG.md

@@ -4,7 +4,22 @@ 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).
 
-## [0.99.4] 18.11.2024
+## [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

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/operation/image_border.rb

@@ -7,7 +7,7 @@ module Morandi
   module Operation
     # Image Border operation
     # Supports retro (rounded) and square borders
-    # Background colour (ie. border colour) can be white, black, dominant (ie. from image)
+    # 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
@@ -26,7 +26,7 @@ module Morandi
 
           @border_scale = [img_width, img_height].max.to_f / print_size.max.to_i
 
-          draw_background(cr, img_height, img_width, pixbuf)
+          draw_background(cr, img_height, img_width)
 
           x = border_width
           y = border_width
@@ -75,7 +75,7 @@ module Morandi
         cr.paint(1.0)
       end
 
-      def draw_background(cr, img_height, img_width, pixbuf)
+      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?)
 
@@ -86,12 +86,6 @@ module Morandi
 
             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'

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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Morandi
-  VERSION = '0.99.4'
+  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

@@ -7,6 +7,7 @@ require 'morandi/cairo_ext'
 require 'morandi/pixbuf_ext'
 require 'morandi/errors'
 require 'morandi/image_processor'
+require 'morandi/vips_image_processor'
 require 'morandi/redeye'
 require 'morandi/crop_utils'
 
@@ -22,12 +23,13 @@ module Morandi
   # @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 (0, 90, 180, 270)
+  # @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', 'dominant')
+  # @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
@@ -42,9 +44,24 @@ module Morandi
   # @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 = {})
-    pro = ImageProcessor.new(source, options, local_options)
-    pro.result
-    pro.write_to_jpeg(target_path)
+    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.4
+  version: 0.100.0
 platform: ruby
 authors:
 - |+
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-22 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
@@ -128,11 +142,13 @@ files:
 - 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: