morandi 0.12.1 → 0.99.03

data/lib/morandi/image_processor.rb

@@ -1,245 +1,245 @@
+# frozen_string_literal: true
+
 require 'morandi/profiled_pixbuf'
 require 'morandi/redeye'
 
-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
+    attr_accessor :config
 
-    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
+      @scale_to = @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 contrast, brightness etc
-    apply_colour_manipulations!
+      # Apply Red-Eye corrections
+      apply_redeye!
 
-    # apply rotation
-    apply_rotate!
+      # Apply contrast, brightness etc
+      apply_colour_manipulations!
 
-    # apply crop
-    apply_crop!
+      # apply rotation
+      apply_rotate!
 
-    # apply filter
-    apply_filters!
+      # apply crop
+      apply_crop!
 
-    # add border
-    apply_decorations!
+      # apply filter
+      apply_filters!
 
-    if @options['output.limit'] && @width && @height
-      @pb = @pb.scale_max([@width, @height].max)
-    end
+      # add border
+      apply_decorations!
 
-    @pb
-  end
+      @pb = @pb.scale_max([@width, @height].max) if @options['output.limit'] && @width && @height
 
-  def result
-    @pb
-  end
+      @pb
+    end
 
-  def write_to_png(fn, orientation=:any)
-    pb = @pb
+    # Returns generated pixbuf
+    def result
+      process! unless @pb
+      @pb
+    end
+
+    def write_to_png(write_to, 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
+      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
-    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
+    def write_to_jpeg(write_to, quality = nil)
+      quality ||= options.fetch('quality', '97')
+      @pb.save(write_to, 'jpeg', quality: quality.to_s)
+    end
 
-protected
-  def get_pixbuf
-    _, width, height = GdkPixbuf::Pixbuf.get_file_info(@file)
+    protected
 
-    if @scale_to
-      @pb = Morandi::ProfiledPixbuf.new(@file, @scale_to, @scale_to, @local_options)
-      @src_max = [width, height].max
+    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
-    else
-      @pb = Morandi::ProfiledPixbuf.new(@file, @local_options)
-      @src_max = [@pb.width, @pb.height].max
-      @actual_max = [@pb.width, @pb.height].max
-    end
 
-    @scale = @actual_max / @src_max.to_f
-  end
+      @src_max = if @scale_to
+                   [width, height].max
+                 else
+                   [@pb.width, @pb.height].max
+                 end
+
+      @scale = @actual_max / @src_max.to_f
+    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
+
+    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
 
-  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)
-    end
+      if options['gamma'] && not_equal_to_one(options['gamma'])
+        @pb = MorandiNative::PixbufUtils.gamma(@pb,
+                                               options['gamma'])
+      end
 
-    if options['gamma'] && (options['gamma'] != 1.0)
-      @pb = 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
 
-    if options['contrast'].to_i.nonzero?
-      @pb = PixbufUtils.contrast(@pb, [ [ 5 * options['contrast'], -100 ].max, 100 ].min)
-    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
+
+      @pb = @pb.rotate(a) unless (a % 360).zero?
 
-    unless (a%360).zero?
-      @pb = @pb.rotate(a)
+      unless options['straighten'].to_f.zero?
+        @pb = Morandi::Straighten.new_from_hash(angle: options['straighten'].to_f).call(nil,
+                                                                                        @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)
+      return @config[key] if @config&.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::Colourify.new_from_hash('filter' => filter)
+      else
+        return
+      end
+      @pb = op.call(nil, @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::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(nil, @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/pixbuf_ext.rb

@@ -0,0 +1,19 @@
+# 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
+
+    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

data/lib/morandi/profiled_pixbuf.rb

@@ -1,82 +1,61 @@
-require 'gdk_pixbuf2'
+# frozen_string_literal: true
 
-class Morandi::ProfiledPixbuf < GdkPixbuf::Pixbuf
-  def valid_jpeg?(filename)
-    return false unless File.exist?(filename)
-    return false unless File.size(filename) > 0
+require 'gdk_pixbuf2'
 
-    type, _, _ = GdkPixbuf::Pixbuf.get_file_info(filename)
+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.
+  class ProfiledPixbuf < GdkPixbuf::Pixbuf
+    def valid_jpeg?(filename)
+      return false unless File.exist?(filename)
+      return false unless File.size(filename).positive?
 
-    type && type.name.eql?('jpeg')
-  rescue
-    false
-  end
+      type, = GdkPixbuf::Pixbuf.get_file_info(filename)
 
-  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))
+      type && type.name.eql?('jpeg')
+    rescue StandardError
+      false
     end
-    loader.close
-    loader.pixbuf
-  end
 
-  def self.default_icc_path(path)
-    "#{path}.icc.jpg"
-  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 initialize(*args)
-    @local_options = args.last.is_a?(Hash) && args.pop || {}
+    def self.default_icc_path(path)
+      "#{path}.icc.jpg"
+    end
 
-    if args[0].is_a?(String)
-      @file = args[0]
+    def initialize(file, local_options, scale_to = nil)
+      @local_options = local_options
+      @file = file
 
       if suitable_for_jpegicc?
         icc_file = icc_cache_path
-
-        args[0] = icc_file if valid_jpeg?(icc_file) || system("jpgicc", "-q97", @file, icc_file)
+        valid_jpeg?(icc_file) || system('jpgicc', '-q97', @file, icc_file)
+        file = icc_file if valid_jpeg?(icc_file)
       end
-    end
-
-    # TODO: This is to fix some deprecation warnings. This needs refactoring.
-    # All can be implemented without having to hack on the PixBuff gem.
-    case args.size
-    when 1
-      super(file: args.first)
-    when 3
-      super(path: args[0], width: args[1], height: args[2])
-    else
-      super(*args)
-    end
-  rescue GdkPixbuf::PixbufError::CorruptImage => e
-    if args[0].is_a?(String) && defined? Tempfile
-      temp =  Tempfile.new
-      pixbuf = self.class.from_string(File.read(args[0]))
-      pixbuf.save(temp.path, 'jpeg')
-      args[0] = temp.path
 
-      if args.size == 1
-        super file: args.first
+      if scale_to
+        super(file: file, width: scale_to, height: scale_to)
       else
-        super(*args)
+        super(file: file)
       end
-
-      temp.close
-      temp.unlink
-    else
-      throw e
     end
-  end
 
+    private
 
-  protected
-  def suitable_for_jpegicc?
-    type, _, _ = GdkPixbuf::Pixbuf.get_file_info(@file)
-
-    type && type.name.eql?('jpeg')
-  end
+    def suitable_for_jpegicc?
+      valid_jpeg?(@file)
+    end
 
-  def icc_cache_path
-    @local_options['path.icc'] || Morandi::ProfiledPixbuf.default_icc_path(@file)
+    def icc_cache_path
+      @local_options['path.icc'] || Morandi::ProfiledPixbuf.default_icc_path(@file)
+    end
   end
 end

data/lib/morandi/redeye.rb

@@ -1,4 +1,4 @@
-require 'redeye'
+# frozen_string_literal: true
 
 module Morandi
   module RedEye
@@ -6,57 +6,45 @@ module Morandi
     # The reason for its existence is to prevent the situations when the bigger red area causes an excessive correction
     # e.g. continuous red eyeglasses frame or sunburnt person's skin around eyes forming an area
     RED_AREA_DENSITY_THRESHOLD = 0.3
-  end
-end
 
-module Morandi
-module RedEye
-module TapRedEye
-  module_function
-  def tap_on(pb, x, y)
-    n = ([pb.height,pb.width].max / 10)
-    x1  = [x - n, 0].max
-    x2  = [x + n, pb.width].min
-    y1  = [y - n, 0].max
-    y2  = [y + n, pb.height].min
-    return pb unless (x1 >= 0) && (x2 > x1) && (y1 >= 0) && (y2 > y1)
-    redeye = ::RedEye.new(pb, x1, y1, x2, y2)
-
-    sensitivity = 2
-    blobs = redeye.identify_blobs(sensitivity).reject { |region|
-      region.noPixels < 4 || !region.squareish?(0.5, RED_AREA_DENSITY_THRESHOLD)
-    }.sort_by { |region|
-      region.area_min_x = x1
-      region.area_min_y = y1
-
-      # Higher is better
-      score = (region.noPixels) / (region.distance_from(x, y) ** 2)
-    }
-
-    blob = blobs.last
-    redeye.correct_blob(blob.id) if blob
-    pb = redeye.pixbuf
-  end
-end
-end
-end
+    # RedEye finder that looks for "eye" closest to a point
+    module TapRedEye
+      module_function
 
-class ::RedEye::Region
-  attr_accessor :area_min_x
-  attr_accessor :area_min_y
-  def centre
-    [@area_min_x.to_i + ((maxX + minX) >> 1),
-     @area_min_y.to_i + ((maxY + minY) >> 1)]
-  end
+      def tap_on(pixbuf, x_coord, y_coord)
+        n = ([pixbuf.height, pixbuf.width].max / 10)
+        x1  = [x_coord - n, 0].max
+        x2  = [x_coord + n, pixbuf.width].min
+        y1  = [y_coord - n, 0].max
+        y2  = [y_coord + n, pixbuf.height].min
+
+        return pixbuf unless (x1 >= 0) && (x2 > x1) && (y1 >= 0) && (y2 > y1)
 
-  # Pythagorean
-  def distance_from(x,y)
-    cx,cy = centre()
+        red_eye = MorandiNative::RedEye.new(pixbuf, x1, y1, x2, y2)
 
-    dx = cx - x
-    dy = cy - y
+        sensitivity = 2
+        blobs = red_eye.identify_blobs(sensitivity).reject do |region|
+          region.noPixels < 4 || !region.squareish?(0.5, RED_AREA_DENSITY_THRESHOLD)
+        end
 
-    Math.sqrt( (dx * dx) + (dy * dy) )
+        sorted_blobs = blobs.sort_by do |region|
+          region.area_min_x = x1
+          region.area_min_y = y1
+        end
+
+        blob = sorted_blobs.last
+        red_eye.correct_blob(blob.id) if blob
+        red_eye.pixbuf
+      end
+    end
   end
 end
 
+module MorandiNative
+  class RedEye
+    # Represents an area with a suspected red eye
+    class Region
+      attr_accessor :area_min_x, :area_min_y
+    end
+  end
+end

data/lib/morandi/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Morandi
-  VERSION = '0.12.1'.freeze
+  VERSION = '0.99.03'
 end