morandi 0.12.1 → 0.99.4

data/lib/morandi/image_processor.rb

@@ -1,245 +1,251 @@
+# frozen_string_literal: true
+
 require 'morandi/profiled_pixbuf'
 require 'morandi/redeye'
+require 'morandi/operation/straighten'
+require 'morandi/operation/colourify'
+require 'morandi/operation/image_border'
 
-class Morandi::ImageProcessor
-  attr_reader :options, :pb
-  attr_accessor :config
-
-  def self.default_icc_path(path)
-    "#{path}.icc.jpg"
-  end
+module Morandi
+  # rubocop:disable Metrics/ClassLength
 
-  def initialize(file, user_options, local_options={})
-    @file = file
+  # ImageProcessor transforms an image.
+  class ImageProcessor
+    attr_reader :options, :pb
 
-    user_options.keys.grep(/^path/).each { |k| user_options.delete(k) }
+    def initialize(file, user_options, local_options = {})
+      @file = file
 
-    # Give priority to user_options
-    @options = (local_options || {}).merge(user_options || {})
-    @local_options = local_options
+      user_options.keys.grep(/^path/).each { |k| user_options.delete(k) }
 
-    @scale_to = @options['output.max']
-    @width, @height = @options['output.width'], @options['output.height']
+      # Give priority to user_options
+      @options = (local_options || {}).merge(user_options || {})
+      @local_options = local_options
 
-    if @file.is_a?(String)
-      get_pixbuf
-    elsif @file.is_a?(GdkPixbuf::Pixbuf) or @file.is_a?(Morandi::ProfiledPixbuf)
-      @pb = @file
-      @scale = 1.0
+      @max_size_px = @options['output.max']
+      @width = @options['output.width']
+      @height = @options['output.height']
     end
-  end
 
-  def process!
-    # Apply Red-Eye corrections
-    apply_redeye!
+    def process!
+      case @file
+      when String
+        get_pixbuf
+      when GdkPixbuf::Pixbuf, Morandi::ProfiledPixbuf
+        @pb = @file
+        @scale = 1.0
+      end
+
+      # Apply Red-Eye corrections
+      apply_redeye!
 
-    # Apply contrast, brightness etc
-    apply_colour_manipulations!
+      # Apply contrast, brightness etc
+      apply_colour_manipulations!
 
-    # apply rotation
-    apply_rotate!
+      # apply rotation
+      apply_rotate!
 
-    # apply crop
-    apply_crop!
+      # apply crop
+      apply_crop!
 
-    # apply filter
-    apply_filters!
+      # apply filter
+      apply_filters!
 
-    # add border
-    apply_decorations!
+      # add border
+      apply_decorations!
 
-    if @options['output.limit'] && @width && @height
-      @pb = @pb.scale_max([@width, @height].max)
+      @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
 
-    @pb
-  end
+    # Returns generated pixbuf
+    def result
+      process! unless @pb
+      @pb
+    end
 
-  def result
-    @pb
-  end
+    def write_to_png(write_to, orientation = :any)
+      pb = @pb
 
-  def write_to_png(fn, orientation=:any)
-    pb = @pb
+      case orientation
+      when :landscape
+        pb = @pb.rotate(90) if @pb.width < @pb.height
+      when :portrait
+        pb = @pb.rotate(90) if @pb.width > @pb.height
+      end
+      pb.save(write_to, 'png')
+    end
 
-    case orientation
-    when :landscape
-      pb = @pb.rotate(90) if @pb.width < @pb.height
-    when :portrait
-      pb = @pb.rotate(90) if @pb.width > @pb.height
+    def write_to_jpeg(write_to, quality = nil)
+      quality ||= options.fetch('quality', '97')
+      @pb.save(write_to, 'jpeg', quality: quality.to_s)
     end
-    pb.save(fn, 'png')
-  end
 
-  def write_to_jpeg(fn, quality = nil)
-    quality ||= options.fetch('quality', '97')
-    @pb.save(fn, 'jpeg', quality: quality.to_s)
-  end
+    protected
 
-protected
-  def get_pixbuf
-    _, width, height = GdkPixbuf::Pixbuf.get_file_info(@file)
-
-    if @scale_to
-      @pb = Morandi::ProfiledPixbuf.new(@file, @scale_to, @scale_to, @local_options)
-      @src_max = [width, height].max
-      @actual_max = [@pb.width, @pb.height].max
-    else
-      @pb = Morandi::ProfiledPixbuf.new(@file, @local_options)
-      @src_max = [@pb.width, @pb.height].max
-      @actual_max = [@pb.width, @pb.height].max
-    end
+    def get_pixbuf
+      _, width, height = GdkPixbuf::Pixbuf.get_file_info(@file)
+      @pb = Morandi::ProfiledPixbuf.new(@file, @local_options, @max_size_px)
 
-    @scale = @actual_max / @src_max.to_f
-  end
+      # 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
 
-  SHARPEN = [
-    -1, -1, -1, -1, -1,
-    -1,  2,  2,  2, -1,
-    -1,  2,  8,  2, -1,
-    -1,  2,  2,  2, -1,
-    -1, -1, -1, -1, -1,
-  ]
-  BLUR = [
-    0, 1, 1, 1, 0,
-    1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1,
-    0, 1, 1, 1, 0,
-  ]
-
-  def apply_colour_manipulations!
-    if options['brighten'].to_i.nonzero?
-      brighten = [ [ 5 * options['brighten'], -100 ].max, 100 ].min
-      @pb = PixbufUtils.brightness(@pb, brighten)
+      @scale = actual_max / src_max.to_f
     end
 
-    if options['gamma'] && (options['gamma'] != 1.0)
-      @pb = PixbufUtils.gamma(@pb, options['gamma'])
-    end
+    SHARPEN = [
+      -1, -1, -1, -1, -1,
+      -1,  2,  2,  2, -1,
+      -1,  2,  8,  2, -1,
+      -1,  2,  2,  2, -1,
+      -1, -1, -1, -1, -1
+    ].freeze
 
-    if options['contrast'].to_i.nonzero?
-      @pb = PixbufUtils.contrast(@pb, [ [ 5 * options['contrast'], -100 ].max, 100 ].min)
-    end
+    BLUR = [
+      0, 1, 1, 1, 0,
+      1, 1, 1, 1, 1,
+      1, 1, 1, 1, 1,
+      1, 1, 1, 1, 1,
+      0, 1, 1, 1, 0
+    ].freeze
+
+    def apply_colour_manipulations!
+      if options['brighten'].to_i.nonzero?
+        brighten = (5 * options['brighten']).clamp(-100, 100)
+        @pb = MorandiNative::PixbufUtils.brightness(@pb, brighten)
+      end
+
+      if options['gamma'] && not_equal_to_one(options['gamma'])
+        @pb = MorandiNative::PixbufUtils.gamma(@pb,
+                                               options['gamma'])
+      end
+
+      if options['contrast'].to_i.nonzero?
+        contrast = (5 * options['contrast']).clamp(-100, 100)
+        @pb = MorandiNative::PixbufUtils.contrast(@pb, contrast)
+      end
+
+      return unless options['sharpen'].to_i.nonzero?
 
-    if options['sharpen'].to_i.nonzero?
-      if options['sharpen'] > 0
+      if options['sharpen'].positive?
         [options['sharpen'], 5].min.times do
-          @pb = PixbufUtils.filter(@pb, SHARPEN, SHARPEN.inject(0, &:+))
+          @pb = MorandiNative::PixbufUtils.filter(@pb, SHARPEN, SHARPEN.inject(0, &:+))
         end
-      elsif options['sharpen'] < 0
-        [ (options['sharpen']*-1), 5].min.times do
-          @pb = PixbufUtils.filter(@pb, BLUR, BLUR.inject(0, &:+))
+      elsif options['sharpen'].negative?
+        [(options['sharpen'] * -1), 5].min.times do
+          @pb = MorandiNative::PixbufUtils.filter(@pb, BLUR, BLUR.inject(0, &:+))
         end
       end
     end
-  end
 
-  def apply_redeye!
-    for eye in options['redeye'] || []
-      @pb = Morandi::RedEye::TapRedEye.tap_on(@pb, eye[0] * @scale, eye[1] * @scale)
+    def apply_redeye!
+      (options['redeye'] || []).each do |eye|
+        @pb = Morandi::RedEye::TapRedEye.tap_on(@pb, eye[0] * @scale, eye[1] * @scale)
+      end
     end
-  end
 
-  def angle
-    a = options['angle'].to_i
-    if a
-      (360-a)%360
-    else
-      nil
+    def angle
+      a = options['angle'].to_i
+      (360 - a) % 360 if a
     end
-  end
 
-  # modifies @pb with any applied rotation
-  def apply_rotate!
-    a = angle()
+    # modifies @pb with any applied rotation
+    def apply_rotate!
+      a = angle
 
-    unless (a%360).zero?
-      @pb = @pb.rotate(a)
+      @pb = @pb.rotate(a) unless (a % 360).zero?
+
+      unless options['straighten'].to_f.zero?
+        @pb = Morandi::Operation::Straighten.new_from_hash(angle: options['straighten'].to_f).call(@pb)
+      end
+
+      @image_width = @pb.width
+      @image_height = @pb.height
     end
 
-    unless options['straighten'].to_f.zero?
-      @pb = Morandi::Straighten.new(options['straighten'].to_f).call(nil, @pb)
+    DEFAULT_CONFIG = {
+      'border-size-mm' => 5
+    }.freeze
+    def config_for(key)
+      return options[key] if options&.key?(key)
+
+      DEFAULT_CONFIG[key]
     end
 
-    @image_width = @pb.width
-    @image_height = @pb.height
-  end
+    def apply_crop!
+      crop = options['crop']
 
-  DEFAULT_CONFIG = {
-    'border-size-mm' => 5
-  }
-  def config_for(key)
-    return options[key] if options && options.has_key?(key)
-    return @config[key] if @config && @config.has_key?(key)
-    DEFAULT_CONFIG[key]
-  end
+      return if crop.nil? && config_for('image.auto-crop').eql?(false)
 
-  #
-  def apply_crop!
-    crop = options['crop']
+      crop = crop.split(',').map(&:to_i) if crop.is_a?(String) && crop =~ /^\d+,\d+,\d+,\d+/
 
-    if crop.nil? && config_for('image.auto-crop').eql?(false)
-      return
-    end
+      crop = nil unless crop.is_a?(Array) && crop.size.eql?(4) && crop.all? do |i|
+        i.is_a?(Numeric)
+      end
 
-    if crop.is_a?(String) && crop =~ /^\d+,\d+,\d+,\d+/
-      crop = crop.split(/,/).map(&:to_i)
-    end
+      # can't crop, won't crop
+      return if @width.nil? && @height.nil? && crop.nil?
 
-    crop = nil unless crop.is_a?(Array) && crop.size.eql?(4) && crop.all? { |i|
-      i.kind_of?(Numeric)
-    }
+      crop = crop.map { |s| (s.to_f * @scale).floor } if crop && not_equal_to_one(@scale)
 
-    # can't crop, won't crop
-    return if @width.nil? && @height.nil? && crop.nil?
+      crop ||= Morandi::CropUtils.autocrop_coords(@pb.width, @pb.height, @width, @height)
 
-    if crop && @scale != 1.0
-      crop = crop.map { |s| (s.to_f * @scale).floor  }
+      @pb = Morandi::CropUtils.apply_crop(@pb, crop[0], crop[1], crop[2], crop[3])
     end
 
-    crop ||= Morandi::Utils.autocrop_coords(@pb.width, @pb.height, @width, @height)
+    def apply_filters!
+      filter = options['fx']
 
-    @pb = Morandi::Utils.apply_crop(@pb, crop[0], crop[1], crop[2], crop[3])
-  end
+      case filter
+      when 'greyscale', 'sepia', 'bluetone'
+        op = Morandi::Operation::Colourify.new_from_hash('filter' => filter)
+      else
+        return
+      end
+      @pb = op.call(@pb)
+    end
 
+    def apply_decorations!
+      style = options['border-style']
+      colour = options['background-style']
 
-  def apply_filters!
-    filter = options['fx']
+      return if style.nil? || style.eql?('none')
+      return if colour.eql?('none')
 
-    case filter
-    when 'greyscale'
-      op = Morandi::Colourify.new_from_hash('op' => filter)
-    when 'sepia', 'bluetone'
-      # could also set 'alpha' => (0.85 * 255).to_i
-      op = Morandi::Colourify.new_from_hash('op' => filter)
-    else
-      return
-    end
-    @pb = op.call(nil, @pb)
-  end
+      colour ||= 'black'
 
-  def apply_decorations!
-    style, colour = options['border-style'], options['background-style']
+      crop = options['crop']
+      crop = crop.map { |s| (s.to_f * @scale).floor } if crop && not_equal_to_one(@scale)
 
-    return if style.nil? or style.eql?('none')
-    return if colour.eql?('none')
-    colour ||= 'black'
+      op = Morandi::Operation::ImageBorder.new_from_hash(
+        'style' => style,
+        'colour' => colour || '#000000',
+        'crop' => crop,
+        'size' => [@image_width, @image_height],
+        'print_size' => [@width, @height],
+        'shrink' => true,
+        'border_size' => @scale * config_for('border-size-mm').to_i * 300 / 25.4 # 5mm at 300dpi
+      )
 
-    crop = options['crop']
-    crop = crop.map { |s| (s.to_f * @scale).floor  } if crop && @scale != 1.0
+      @pb = op.call(@pb)
+    end
 
-    op = Morandi::ImageBorder.new_from_hash(data={
-      'style' => style,
-      'colour' => colour || '#000000',
-      'crop' => crop,
-      'size' => [@image_width, @image_height],
-      'print_size' => [@width, @height],
-      'shrink'  => true,
-      'border_size' => @scale * config_for('border-size-mm').to_i * 300 / 25.4 # 5mm at 300dpi
-    })
+    private
 
-    @pb = op.call(nil, @pb)
+    def not_equal_to_one(float)
+      (float - 1.0).abs >= Float::EPSILON
+    end
   end
-
+  # rubocop:enable Metrics/ClassLength
 end

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,108 @@
+# 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, dominant (ie. from image)
+    # @!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, 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
+  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/pixbuf_ext.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'gdk_pixbuf2'
+
+# GdkPixbuf module / hierachy
+module GdkPixbuf
+  # Add #to_cairo_image_surface for converting pixels to Cairo::ImageSurface format (RGBA->ARGB)
+  class Pixbuf
+    def to_cairo_image_surface
+      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
+      scale(width * mul, height * mul, interp)
+    end
+  end
+end