image_processing 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91616e1f059395f4197125f345f097948f04bdabb08737c95155856aa267885e
-  data.tar.gz: f7d33fce924062960e4ac5dae9019df37374b6ae1ca9c0f97dc8e5fe66400860
+  metadata.gz: 5b28b25634ec49e61835850b56f7c1c46b4d0e10ea99fbb6ef05c238e307d348
+  data.tar.gz: 348ff75f2a0779c085341248ac9cf4e9a931e984a3ba2e2e016c77dd63cc04e0
 SHA512:
-  metadata.gz: 701f320524f7753255ebf6601196dc0c3c6c81bb52ae2f3c92ccb05850e1ef6ae18e9c31dd271a0d8b3d6bd8b727b9c2e8757feda2d024df957f40126ac7799f
-  data.tar.gz: 07c799fe3f6a430177ca426280181343315a7e17ba28d74b2feb3bf047f1d263fefa5c3663594daa733f7448872ba03ef64208fafd2e1b6c721f680dad02c58b
+  metadata.gz: 85f39d0e536bddda22b5a79d5a0cc95496cf8eccccb536549ac209dbad3850b83add4797420a165582c666230015a1a4f969c0846e026f950a0d4dee1c5d00a8
+  data.tar.gz: e9b452b98df5b6f96cccf89b51a17b6ea3d06197adce46549d441fbd6822bcecac58cb9bf8e8ddc8ad14c3b144f8a8d703cb4d183d615ad349337430f6da9b7c

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 1.5.0 (2018-07-10)
+
+* [minimagick, vips] Add `#composite` method (@janko-m)
+
+* [core] Allow operations to accept blocks (janko-m)
+
 ## 1.4.0 (2018-06-14)
 
 * [minimagick] Accept RGB(A) arrays for color names for `:background` (@janko-m)
@@ -8,7 +14,7 @@
 
 ## 1.3.0 (2018-06-13)
 
-* [minimagick, vips] Add `#rotate` function (@janko-m)
+* [minimagick, vips] Add `#rotate` method (@janko-m)
 
 * [vips] Use native `vips_image_hasalpha()` and `vips_addalpha()` functions in `#resize_and_pad` (@janko-m)
 

data/lib/image_processing/chainable.rb

@@ -16,10 +16,6 @@ module ImageProcessing
       branch saver: options
     end
 
-    def custom(&block)
-      operation :custom, block
-    end
-
     def apply(operations)
       operations.inject(self) do |builder, (name, argument)|
         if argument == true || argument == nil
@@ -32,15 +28,15 @@ module ImageProcessing
       end
     end
 
-    def method_missing(name, *args)
+    def method_missing(name, *args, &block)
       return super if name.to_s.end_with?("?")
-      return send(name.to_s.chomp("!"), *args).call if name.to_s.end_with?("!")
+      return send(name.to_s.chomp("!"), *args, &block).call if name.to_s.end_with?("!")
 
-      operation name, *args
+      operation(name, *args, &block)
     end
 
-    def operation(name, *args)
-      branch operations: [[name, args]]
+    def operation(name, *args, &block)
+      branch operations: [[name, args, *block]]
     end
 
     def call(file = nil, destination: nil, **call_options)
@@ -57,7 +53,7 @@ module ImageProcessing
       options = options.merge(loader: options[:loader].merge(loader)) if loader
       options = options.merge(saver: options[:saver].merge(saver)) if saver
       options = options.merge(operations: options[:operations] + operations) if operations
-      options = options.merge(processor_class: self::Processor) unless self.is_a?(Builder)
+      options = options.merge(processor: self::Processor) unless self.is_a?(Builder)
       options = options.merge(other_options)
 
       options.freeze
@@ -66,12 +62,12 @@ module ImageProcessing
     end
 
     DEFAULT_OPTIONS = {
-      source:          nil,
-      loader:          {},
-      saver:           {},
-      format:          nil,
-      operations:      [],
-      processor_class: nil,
+      source:     nil,
+      loader:     {},
+      saver:      {},
+      format:     nil,
+      operations: [],
+      processor:  nil,
     }.freeze
   end
 end

data/lib/image_processing/mini_magick.rb

@@ -16,88 +16,98 @@ module ImageProcessing
     end
 
     class Processor < ImageProcessing::Processor
-      IMAGE_CLASS        = ::MiniMagick::Tool
+      accumulator :magick, ::MiniMagick::Tool
+
       SHARPEN_PARAMETERS = { radius: 0, sigma: 1 }
 
-      def resize_to_limit(magick, width, height, **options)
-        thumbnail(magick, "#{width}x#{height}>", **options)
+      def self.load_image(path_or_magick, page: nil, geometry: nil, auto_orient: true, **options)
+        if path_or_magick.is_a?(::MiniMagick::Tool)
+          magick = path_or_magick
+        else
+          source_path = path_or_magick
+          magick = ::MiniMagick::Tool::Convert.new
+
+          Utils.apply_options(magick, options)
+
+          input_path  = source_path
+          input_path += "[#{page}]" if page
+          input_path += "[#{geometry}]" if geometry
+
+          magick << input_path
+        end
+
+        magick.auto_orient if auto_orient
+        magick
       end
 
-      def resize_to_fit(magick, width, height, **options)
-        thumbnail(magick, "#{width}x#{height}", **options)
+      def self.save_image(magick, destination_path, allow_splitting: false, **options)
+        Utils.apply_options(magick, options)
+
+        magick << destination_path
+        magick.call
+
+        Utils.disallow_split_layers!(destination_path) unless allow_splitting
+      end
+
+      def resize_to_limit(width, height, **options)
+        thumbnail("#{width}x#{height}>", **options)
       end
 
-      def resize_to_fill(magick, width, height, gravity: "Center", **options)
-        thumbnail(magick, "#{width}x#{height}^", **options)
+      def resize_to_fit(width, height, **options)
+        thumbnail("#{width}x#{height}", **options)
+      end
+
+      def resize_to_fill(width, height, gravity: "Center", **options)
+        thumbnail("#{width}x#{height}^", **options)
         magick.gravity gravity
         magick.background color(:transparent)
         magick.extent "#{width}x#{height}"
       end
 
-      def resize_and_pad(magick, width, height, background: :transparent, gravity: "Center", **options)
-        thumbnail(magick, "#{width}x#{height}", **options)
+      def resize_and_pad(width, height, background: :transparent, gravity: "Center", **options)
+        thumbnail("#{width}x#{height}", **options)
         magick.background color(background)
         magick.gravity gravity
         magick.extent "#{width}x#{height}"
       end
 
-      def rotate(magick, degrees, background: nil)
+      def rotate(degrees, background: nil)
         magick.background color(background) if background
         magick.rotate(degrees)
       end
 
-      def define(magick, options)
-        return magick.define(options) if options.is_a?(String)
+      def composite(overlay = :none, mask: nil, compose: nil, gravity: nil, geometry: nil, args: nil, &block)
+        return magick.composite if overlay == :none
 
-        options.each do |namespace, settings|
-          namespace = namespace.to_s.gsub("_", "-")
+        overlay_path = convert_to_path(overlay, "overlay")
+        mask_path    = convert_to_path(mask, "mask") if mask
 
-          settings.each do |key, value|
-            key = key.to_s.gsub("_", "-")
+        magick << overlay_path
+        magick << mask_path if mask_path
 
-            magick.define "#{namespace}:#{key}=#{value}"
-          end
-        end
+        magick.compose(compose) if compose
+        define(compose: { args: args }) if args
 
-        magick
-      end
+        magick.gravity(gravity) if gravity
+        magick.geometry(geometry) if geometry
 
-      def limits(magick, options)
-        limit_args = options.flat_map { |type, value| %W[-limit #{type} #{value}] }
-        prepend_args(magick, limit_args)
-      end
+        yield magick if block_given?
 
-      def append(magick, *args)
-        magick.merge! args
+        magick.composite
       end
 
-      def load_image(path_or_magick, page: nil, geometry: nil, auto_orient: true, **options)
-        if path_or_magick.is_a?(::MiniMagick::Tool)
-          magick = path_or_magick
-        else
-          source_path = path_or_magick
-          magick = ::MiniMagick::Tool::Convert.new
-
-          apply_options(magick, options)
-
-          input_path  = source_path
-          input_path += "[#{page}]" if page
-          input_path += "[#{geometry}]" if geometry
-
-          magick << input_path
-        end
+      def define(options)
+        return magick.define(options) if options.is_a?(String)
+        Utils.apply_define(magick, options)
+      end
 
-        magick.auto_orient if auto_orient
+      def limits(options)
+        options.each { |type, value| magick.args.unshift("-limit", type.to_s, value.to_s) }
         magick
       end
 
-      def save_image(magick, destination_path, allow_splitting: false, **options)
-        apply_options(magick, options)
-
-        magick << destination_path
-        magick.call
-
-        disallow_split_layers!(destination_path) unless allow_splitting
+      def append(*args)
+        magick.merge! args
       end
 
       private
@@ -111,42 +121,65 @@ module ImageProcessing
         raise ArgumentError, "unrecognized color format: #{value.inspect} (must be one of: string, 3-element RGB array, 4-element RGBA array)"
       end
 
-      def thumbnail(magick, geometry, sharpen: {})
+      def thumbnail(geometry, sharpen: {})
         magick.resize(geometry)
-        magick.sharpen(sharpen_value(sharpen)) if sharpen
+
+        if sharpen
+          sharpen = SHARPEN_PARAMETERS.merge(sharpen)
+          magick.sharpen("#{sharpen[:radius]}x#{sharpen[:sigma]}")
+        end
+
         magick
       end
 
-      def sharpen_value(parameters)
-        parameters    = SHARPEN_PARAMETERS.merge(parameters)
-        radius, sigma = parameters.values_at(:radius, :sigma)
-
-        "#{radius}x#{sigma}"
+      def convert_to_path(file, name)
+        if file.is_a?(String)
+          file
+        elsif file.respond_to?(:to_path)
+          file.to_path
+        elsif file.respond_to?(:path)
+          file.path
+        else
+          raise ArgumentError, "#{name} must be a String, Pathname, or respond to #path"
+        end
       end
 
-      def apply_options(magick, define: {}, **options)
-        options.each do |option, value|
-          case value
-          when true, nil then magick.send(option)
-          when false     then magick.send(option).+
-          else                magick.send(option, *value)
+      module Utils
+        module_function
+
+        def disallow_split_layers!(destination_path)
+          layers = Dir[destination_path.sub(/\.\w+$/, '-*\0')]
+
+          if layers.any?
+            layers.each { |path| File.delete(path) }
+            raise Error, "Multi-layer image is being converted into a single-layer format. You should either process individual layers or set :allow_splitting to true. See https://github.com/janko-m/image_processing/wiki/Splitting-a-PDF-into-multiple-images for how to process each layer individually."
           end
         end
 
-        define(magick, define)
-      end
+        def apply_options(magick, define: {}, **options)
+          options.each do |option, value|
+            case value
+            when true, nil then magick.send(option)
+            when false     then magick.send(option).+
+            else                magick.send(option, *value)
+            end
+          end
 
-      def prepend_args(magick, args)
-        magick.args.replace args + magick.args
-        magick
-      end
+          apply_define(magick, define)
+        end
+
+        def apply_define(magick, options)
+          options.each do |namespace, settings|
+            namespace = namespace.to_s.gsub("_", "-")
 
-      def disallow_split_layers!(destination_path)
-        layers = Dir[destination_path.sub(/\.\w+$/, '-*\0')]
+            settings.each do |key, value|
+              key = key.to_s.gsub("_", "-")
+
+              magick.define "#{namespace}:#{key}=#{value}"
+            end
+          end
 
-        if layers.any?
-          layers.each { |path| File.delete(path) }
-          raise Error, "Multi-layer image is being converted into a single-layer format. You should either process individual layers or set :allow_splitting to true. See https://github.com/janko-m/image_processing/wiki/Splitting-a-PDF-into-multiple-images for how to process each layer individually."
+          magick
         end
       end
     end

data/lib/image_processing/pipeline.rb

@@ -4,7 +4,7 @@ module ImageProcessing
   class Pipeline
     DEFAULT_FORMAT = "jpg"
 
-    attr_reader :source, :loader, :saver, :format, :operations, :processor_class, :destination
+    attr_reader :source, :loader, :saver, :format, :operations, :processor, :destination
 
     def initialize(options)
       options.each do |name, value|
@@ -14,22 +14,21 @@ module ImageProcessing
     end
 
     def call(save: true)
-      processor = processor_class.new(self)
-      image     = processor.load_image(source, **loader)
+      accumulator = processor.load_image(source, **loader)
 
-      operations.each do |name, args|
-        image = processor.apply_operation(name, image, *args)
+      operations.each do |name, args, block|
+        accumulator = processor.apply_operation(accumulator, name, *args, &block)
       end
 
       if save == false
-        image
+        accumulator
       elsif destination
         handle_destination do
-          processor.save_image(image, destination, **saver)
+          processor.save_image(accumulator, destination, **saver)
         end
       else
         create_tempfile do |tempfile|
-          processor.save_image(image, tempfile.path, **saver)
+          processor.save_image(accumulator, tempfile.path, **saver)
         end
       end
     end
@@ -74,9 +73,9 @@ module ImageProcessing
     def normalize_source(source, options)
       fail Error, "source file is not provided" unless source
 
-      image_class = options[:processor_class]::IMAGE_CLASS
+      accumulator_class = options[:processor]::ACCUMULATOR_CLASS
 
-      if source.is_a?(image_class)
+      if source.is_a?(accumulator_class)
         source
       elsif source.is_a?(String)
         source
@@ -85,7 +84,7 @@ module ImageProcessing
       elsif source.respond_to?(:to_path)
         source.to_path
       else
-        fail Error, "source file needs to respond to #path, or be a String, a Pathname, or a #{image_class} object"
+        fail Error, "source file needs to respond to #path, or be a String, a Pathname, or a #{accumulator_class} object"
       end
     end
   end

data/lib/image_processing/processor.rb

@@ -1,23 +1,26 @@
 module ImageProcessing
   class Processor
-    def initialize(pipeline)
-      @pipeline = pipeline
+    def self.accumulator(name, klass)
+      define_method(name) { @accumulator }
+      protected(name)
+      const_set(:ACCUMULATOR_CLASS, klass)
     end
 
-    def apply_operation(name, image, *args)
-      if respond_to?(name)
-        public_send(name, image, *args)
+    def self.apply_operation(accumulator, name, *args, &block)
+      if (instance_methods - Object.instance_methods).include?(name)
+        instance = new(accumulator)
+        instance.public_send(name, *args, &block)
       else
-        image.send(name, *args)
+        accumulator.send(name, *args, &block)
       end
     end
 
-    def custom(image, block)
-      (block && block.call(image)) || image
+    def initialize(accumulator = nil)
+      @accumulator = accumulator
     end
 
-    private
-
-    attr_reader :pipeline
+    def custom(&block)
+      (block && block.call(@accumulator)) || @accumulator
+    end
   end
 end

data/lib/image_processing/version.rb

@@ -1,3 +1,3 @@
 module ImageProcessing
-  VERSION = "1.4.0"
+  VERSION = "1.5.0"
 end

data/lib/image_processing/vips.rb

@@ -15,41 +15,59 @@ module ImageProcessing
     end
 
     class Processor < ImageProcessing::Processor
-      IMAGE_CLASS  = ::Vips::Image
+      accumulator :image, ::Vips::Image
+
       # default sharpening mask that provides a fast and mild sharpen
       SHARPEN_MASK = ::Vips::Image.new_from_array [[-1, -1, -1],
                                                    [-1, 32, -1],
                                                    [-1, -1, -1]], 24
 
-      def apply_operation(name, image, *args)
-        result = super
-        result.is_a?(::Vips::Image) ? result : image
+
+      def self.load_image(path_or_image, autorot: true, **options)
+        if path_or_image.is_a?(::Vips::Image)
+          image = path_or_image
+        else
+          source_path = path_or_image
+          options     = Utils.select_valid_loader_options(source_path, options)
+
+          image = ::Vips::Image.new_from_file(source_path, **options)
+        end
+
+        image = image.autorot if autorot && !options.key?(:autorotate)
+        image
       end
 
-      def resize_to_limit(image, width, height, **options)
+      def self.save_image(image, destination_path, quality: nil, **options)
+        options = options.merge(Q: quality) if quality
+        options = Utils.select_valid_saver_options(destination_path, options)
+
+        image.write_to_file(destination_path, **options)
+      end
+
+      def resize_to_limit(width, height, **options)
         width, height = default_dimensions(width, height)
-        thumbnail(image, width, height, size: :down, **options)
+        thumbnail(width, height, size: :down, **options)
       end
 
-      def resize_to_fit(image, width, height, **options)
+      def resize_to_fit(width, height, **options)
         width, height = default_dimensions(width, height)
-        thumbnail(image, width, height, **options)
+        thumbnail(width, height, **options)
       end
 
-      def resize_to_fill(image, width, height, **options)
-        thumbnail(image, width, height, crop: :centre, **options)
+      def resize_to_fill(width, height, **options)
+        thumbnail(width, height, crop: :centre, **options)
       end
 
-      def resize_and_pad(image, width, height, gravity: "centre", extend: nil, background: nil, alpha: nil, **options)
+      def resize_and_pad(width, height, gravity: "centre", extend: nil, background: nil, alpha: nil, **options)
         embed_options = { extend: extend, background: background }
         embed_options.reject! { |name, value| value.nil? }
 
-        image = thumbnail(image, width, height, **options)
+        image = thumbnail(width, height, **options)
         image = image.add_alpha if alpha && !image.has_alpha?
         image.gravity(gravity, width, height, **embed_options)
       end
 
-      def rotate(image, degrees, background: nil)
+      def rotate(degrees, background: nil)
         if degrees % 90 == 0
           image.rot(:"d#{degrees % 360}")
         else
@@ -60,30 +78,33 @@ module ImageProcessing
         end
       end
 
-      def load_image(path_or_image, autorot: true, **options)
-        if path_or_image.is_a?(::Vips::Image)
-          image = path_or_image
-        else
-          source_path = path_or_image
-          options     = select_valid_loader_options(source_path, options)
-
-          image = ::Vips::Image.new_from_file(source_path, **options)
+      def composite(other, mode, **options)
+        other = [other] unless other.is_a?(Array)
+
+        other = other.map do |object|
+          if object.is_a?(String)
+            ::Vips::Image.new_from_file(object)
+          elsif object.respond_to?(:to_path)
+            ::Vips::Image.new_from_file(object.to_path)
+          elsif object.respond_to?(:path)
+            ::Vips::Image.new_from_file(object.path)
+          else
+            object
+          end
         end
 
-        image = image.autorot if autorot && !options.key?(:autorotate)
-        image
+        image.composite(other, mode, **options)
       end
 
-      def save_image(image, destination_path, quality: nil, **options)
-        options = options.merge(Q: quality) if quality
-        options = select_valid_saver_options(destination_path, options)
-
-        image.write_to_file(destination_path, **options)
-      end
+      # make Vips::Image#set, #set_type, and #set_value chainable
+      def set(*args)       image.tap { |img| img.set(*args) }       end
+      def set_type(*args)  image.tap { |img| img.set_type(*args) }  end
+      def set_value(*args) image.tap { |img| img.set_value(*args) } end
 
       private
 
-      def thumbnail(image, width, height, sharpen: SHARPEN_MASK, **options)
+      def thumbnail(width, height, sharpen: SHARPEN_MASK, **options)
+        image = self.image
         image = image.thumbnail_image(width, height: height, **options)
         image = image.conv(sharpen) if sharpen
         image
@@ -95,25 +116,29 @@ module ImageProcessing
         [width || ::Vips::MAX_COORD, height || ::Vips::MAX_COORD]
       end
 
-      def select_valid_loader_options(source_path, options)
-        loader = ::Vips.vips_foreign_find_load(source_path)
-        loader ? select_valid_options(loader, options) : options
-      end
+      module Utils
+        module_function
 
-      def select_valid_saver_options(destination_path, options)
-        saver = ::Vips.vips_foreign_find_save(destination_path)
-        saver ? select_valid_options(saver, options) : options
-      end
+        def select_valid_loader_options(source_path, options)
+          loader = ::Vips.vips_foreign_find_load(source_path)
+          loader ? select_valid_options(loader, options) : options
+        end
+
+        def select_valid_saver_options(destination_path, options)
+          saver = ::Vips.vips_foreign_find_save(destination_path)
+          saver ? select_valid_options(saver, options) : options
+        end
 
-      def select_valid_options(operation_name, options)
-        operation = ::Vips::Operation.new(operation_name)
+        def select_valid_options(operation_name, options)
+          operation = ::Vips::Operation.new(operation_name)
 
-        operation_options = operation.get_construct_args
-          .select { |name, flags| (flags & ::Vips::ARGUMENT_INPUT)    != 0 }
-          .select { |name, flags| (flags & ::Vips::ARGUMENT_REQUIRED) == 0 }
-          .map(&:first).map(&:to_sym)
+          operation_options = operation.get_construct_args
+            .select { |name, flags| (flags & ::Vips::ARGUMENT_INPUT)    != 0 }
+            .select { |name, flags| (flags & ::Vips::ARGUMENT_REQUIRED) == 0 }
+            .map(&:first).map(&:to_sym)
 
-        options.select { |name, value| operation_options.include?(name) }
+          options.select { |name, value| operation_options.include?(name) }
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: image_processing
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Janko Marohnić
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-15 00:00:00.000000000 Z
+date: 2018-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mini_magick