morandi 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 699363674b014c312fbf514929f5d9a68bc7710c
+  data.tar.gz: a3a8dc47dfb8e4b2a3c09904d44bd0ab32240043
+SHA512:
+  metadata.gz: 522a4bda18dfe5f5c5326f56385c2bf45bc0e14f5b2dd2946234be72e1d322d5b835e8cd3487e69d824d674bdd31daf508d67389f35fbdb0d8842e25ece61b39
+  data.tar.gz: 06b08143b66b203c290e2b2493db345ac3d34ef82d95d663d5496fae9bcd965cef9b54dffb50ad9647ed349cc09f52dc5f474734ead26cad6da6f5feb56b3361

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in morandi.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,25 @@
+Copyright (c) 2015 Geoff Youngs
+
+
+
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,49 @@
+# Morandi
+
+Library of simple image manipulations - replicating the behaviour of
+morandi-js.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'morandi'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install morandi
+
+## Usage
+
+````
+   Morandi.process(in_file, settings, out_file)
+````
+- 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
+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
+
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/morandi/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/morandi.rb

@@ -0,0 +1,252 @@
+require "morandi/version"
+require 'gdk_pixbuf2'
+require 'cairo'
+require 'pixbufutils'
+require 'redeye'
+
+require 'morandi/utils'
+require 'morandi/image-ops'
+require 'morandi/redeye'
+
+module Morandi
+  # Your code goes here...
+  class ImageProcessor
+  attr_reader :options, :pb
+  attr_accessor :config
+
+  def valid_jpeg?(filename)
+    return false unless File.exist?(filename)
+    return false unless File.size(filename) > 0
+
+    type, _, _ = Gdk::Pixbuf.get_file_info(filename)
+
+    type.name == 'jpeg'
+  rescue
+    false
+  end
+
+  def initialize(file, scale_to, options)
+    @file = file
+    #@size = size
+    @scale_to = scale_to
+    @options = options || {}
+
+    @width, @height = options['output.width'], options['output.height']
+
+    load_file = @file
+    type, width, height = Gdk::Pixbuf.get_file_info(load_file)
+
+    if type.name.eql?('jpeg')
+      icc_file = "#{@file}.icc.jpg"
+      if valid_jpeg?(icc_file) || system("jpgicc", "-q97", @file, icc_file)
+        load_file = icc_file
+      end
+    end
+
+    if @scale_to
+      @pb = Gdk::Pixbuf.new(load_file, @scale_to, @scale_to)
+      @src_max = [width, height].max
+      @actual_max = [@pb.width, @pb.height].max
+    else
+      @pb = Gdk::Pixbuf.new(load_file)
+      @src_max = [@pb.width, @pb.height].max
+      @actual_max = [@pb.width, @pb.height].max
+    end
+
+    @scale = @actual_max / @src_max.to_f
+  end
+
+  def process!
+    # Apply Red-Eye corrections
+    apply_redeye!
+
+    # Apply contrast, brightness etc
+    apply_colour_manipulations!
+
+    # apply rotation
+    apply_rotate!
+
+    # apply crop
+    apply_crop!
+
+    # apply filter
+    apply_filters!
+
+    # add border
+    apply_decorations!
+
+    if options['output.limit']
+      @pb = @pb.scale_max([@width, @height].max)
+    end
+
+    @pb
+  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!
+    #STDERR.puts "FILTER: #{options.inspect}"
+    if options['brighten'].to_i.nonzero?
+      brighten = [ [ 5 * options['brighten'], -100 ].max, 100 ].min
+      STDERR.puts([:brighten, brighten].inspect)
+      @pb = PixbufUtils.brightness(@pb, brighten)
+    end
+    if options['gamma'] && (options['gamma'] != 1.0)
+      @pb = PixbufUtils.gamma(@pb, options['gamma'])
+    end
+    if options['contrast'].to_i.nonzero?
+      @pb = PixbufUtils.contrast(@pb, [ [ 5 * options['contrast'], -100 ].max, 100 ].min)
+    end
+    if options['sharpen'].to_i.nonzero?
+      if options['sharpen'] > 0
+        [options['sharpen'], 5].min.times do
+          @pb = 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, &:+))
+        end
+      end
+    end
+  end
+
+  def apply_redeye!
+    for eye in options['redeye'] || []
+      @pb = Morandi::RedEye.tap_on(@pb, eye[0] * @scale, eye[1] * @scale)
+    end
+  end
+
+  def angle
+    a = options['angle'].to_i
+    if a
+      (360-a)%360
+    else
+      nil
+    end
+  end
+
+  # modifies @pb with any applied rotation
+  def apply_rotate!
+    a = angle()
+
+    unless (a%360).zero?
+      @pb = @pb.rotate(a)
+    end
+
+    unless options['straighten'].to_f.zero?
+      @pb = Morandi::Straighten.new(options['straighten'].to_f).call(nil, @pb)
+    end
+
+    @image_width = @pb.width
+    @image_height = @pb.height
+  end
+
+  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
+
+  #
+  def apply_crop!
+    crop = options['crop']
+
+    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? { |i|
+      i.kind_of?(Numeric)
+    }
+
+    # can't crop, won't crop
+    return if @width.nil? && @height.nil? && crop.nil?
+
+    if crop && @scale != 1.0
+      crop = crop.map { |s| (s.to_f * @scale).floor  }
+    end
+
+    crop ||= Morandi::Utils.autocrop_coords(@pb.width, @pb.height, @width, @height)
+
+    @pb = Morandi::Utils.apply_crop(@pb, crop[0], crop[1], crop[2], crop[3])
+  end
+
+
+  def apply_filters!
+    filter = options['fx']
+
+    case filter
+    when 'greyscale'
+      op = Morandi::Colourify.new_from_hash('op' => filter)
+    when 'sepia', 'bluetone'
+      op = Morandi::Colourify.new_from_hash('op' => filter, 'alpha' => (0.85 * 255).to_i)
+    else
+      return
+    end
+    @pb = op.call(nil, @pb)
+  end
+
+  def apply_decorations!
+    style, colour = options['border-style'], options['background-style']
+
+    return if style.nil? or style.eql?('none')
+    return if colour.eql?('none')
+    colour ||= 'black'
+
+    crop = options['crop']
+    crop = crop.map { |s| (s.to_f * @scale).floor  } if crop && @scale != 1.0
+
+    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
+    })
+
+    @pb = op.call(nil, @pb)
+  end
+
+  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(fn, 'png')
+  end
+
+  def write_to_jpeg(fn, quality = 97)
+    @pb.save(fn, 'jpeg', :quality => quality)
+  end
+end
+
+  module_function
+  def process(file_in, settings, out_file)
+    pro = ImageProcessor.new(file_in, settings['output.max'], settings)
+    pro.process!
+    pro.write_to_jpeg(out_file)
+  end
+
+end

data/lib/morandi/image-ops.rb

@@ -0,0 +1,332 @@
+module Morandi
+class ImageOp
+  class << self
+    def new_from_hash(hash)
+      op = allocate()
+      hash.each_pair do |key,val|
+        op.instance_variable_set("@#{key}", val) if op.respond_to?(key.intern)
+      end
+      op
+    end
+  end
+  def initialize()
+  end
+  def priority
+    100
+  end
+end
+class Crop < ImageOp
+  attr_accessor :area
+  def initialize(area=nil)
+    super()
+    @area = area
+  end
+  def constrain(val,min,max)
+    if val < min
+      min
+    elsif val > max
+      max
+    else
+      val
+    end
+  end
+  def call(image, pixbuf)
+    if @area and (not @area.width.zero?) and (not @area.height.zero?)
+      # NB: Cheap - fast & shares memory
+      Gdk::Pixbuf.new(pixbuf, @area.x, @area.y,
+          @area.width, @area.height)
+    else
+      pixbuf
+    end
+  end
+end
+class Rotate < ImageOp
+  attr_accessor :angle
+  def initialize(angle=0)
+    super()
+    @angle = angle
+  end
+  def call(image, pixbuf)
+    if @angle.zero?
+      pixbuf
+    else
+      case @angle
+      when 0, 90, 180, 270
+        PixbufUtils::rotate(pixbuf, @angle)
+      else
+        raise "Not a valid angle"
+      end
+    end
+  end
+end
+class Straighten < ImageOp
+  attr_accessor :angle
+  def initialize(angle=0)
+    super()
+    @angle = angle
+  end
+  def call(image, pixbuf)
+    if @angle.zero?
+      pixbuf
+    else
+      surface = Cairo::ImageSurface.new(:rgb24, pixbuf.width, pixbuf.height)
+
+      rotationValueRad = @angle * (Math::PI/180)
+
+      ratio = pixbuf.width.to_f/pixbuf.height
+      rh = (pixbuf.height) / ((ratio * Math.sin(rotationValueRad.abs)) + Math.cos(rotationValueRad.abs))
+      scale = pixbuf.height / rh.to_f.abs
+
+      a_ratio = pixbuf.height.to_f/pixbuf.width
+      a_rh = (pixbuf.width) / ((a_ratio * Math.sin(rotationValueRad.abs)) + Math.cos(rotationValueRad.abs))
+      a_scale = pixbuf.width / a_rh.to_f.abs
+
+      scale = a_scale if a_scale > scale
+
+      cr = Cairo::Context.new(surface)
+      #p [@angle, rotationValueRad, rh, scale, pixbuf.height]
+
+      cr.translate(pixbuf.width / 2.0, pixbuf.height / 2.0)
+      cr.rotate(rotationValueRad)
+      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)
+      final_pb = surface.to_pixbuf
+      cr.destroy
+      surface.destroy
+      return final_pb
+    end
+  end
+end
+
+class ImageCaption < ImageOp
+  attr_accessor :text, :font, :position
+  def initialize()
+    super()
+  end
+
+  def font
+    @font || "Open Sans Condensed Light #{ ([@pixbuf.width,@pixbuf.height].max/80.0).to_i }"
+  end
+
+  def position
+    @position ||
+    (@pixbuf ? ([ [@pixbuf.width,@pixbuf.height].max/20 ] * 2) : [100, 100])
+  end
+
+  def call(image, pixbuf)
+    @pixbuf = pixbuf
+    surface = Cairo::ImageSurface.new(:rgb24, pixbuf.width, pixbuf.height)
+    cr = Cairo::Context.new(surface)
+
+    cr.save do
+      cr.set_source_pixbuf(pixbuf)
+      #cr.rectangle(0, 0, pixbuf.width, pixbuf.height)
+      cr.paint(1.0)
+      cr.translate(*self.position)
+
+      layout = cr.create_pango_layout
+      layout.set_text(self.text)
+      fd = Pango::FontDescription.new(self.font)
+      layout.font_description = fd
+      layout.set_width((pixbuf.width - self.position[0] - 100)*Pango::SCALE)
+      layout.context_changed
+      ink, _ = layout.pixel_extents
+      cr.set_source_rgba(0, 0, 0, 0.3)
+      cr.rectangle(-25, -25, ink.width + 50, ink.height + 50)
+      cr.fill
+      cr.set_source_rgb(1, 1, 1)
+      cr.show_pango_layout(layout)
+    end
+
+
+    final_pb = surface.to_pixbuf
+    cr.destroy
+    surface.destroy
+    return final_pb
+  end
+end
+
+class ImageBorder < ImageOp
+  attr_accessor :style, :colour, :crop, :size, :print_size, :shrink, :border_size
+  def initialize(style='none', colour='white')
+    super()
+    @style = style
+    @colour = colour
+  end
+
+  def call(image, pixbuf)
+    return pixbuf unless %w[square retro].include? @style
+    surface = Cairo::ImageSurface.new(:rgb24, pixbuf.width, pixbuf.height)
+    cr = Cairo::Context.new(surface)
+
+    img_width = pixbuf.width
+    img_height = pixbuf.height
+
+    cr.save do
+      if @crop
+        if @crop[0] < 0 || @crop[1] < 0
+          img_width = size[0]
+          img_height = size[1]
+          cr.translate( - @crop[0], - @crop[1])
+        end
+      end
+
+      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-#{$$}.#{Time.now.to_i}", 'jpeg')
+          hgram = Colorscore::Histogram.new(fn)
+          File.unlink(fn) rescue nil
+          col =  hgram.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
+
+    border_scale =  [img_width,img_height].max.to_f / print_size.max.to_i
+    size = @border_size
+    size *= border_scale
+    x, y = size, size
+
+    # 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 - (size * 2)) / longest_side
+
+    if @crop
+      if @crop[0] < 0 || @crop[1] < 0
+        x -= @crop[0]
+        y -= @crop[1]
+      end
+    end
+
+    case style
+    when 'retro'
+      CairoUtils.rounded_rectangle(cr, x, y,
+                                   img_width + x - (size*2), img_height+y-(size*2), size)
+    when 'square'
+        cr.rectangle(x, y, img_width - (size*2), img_height - (size*2))
+    end
+    cr.clip()
+
+    if @shrink
+      cr.translate(size, size)
+      cr.scale(pb_scale, pb_scale)
+    end
+    cr.set_source_pixbuf(pixbuf)
+    cr.rectangle(0, 0, pixbuf.width, pixbuf.height)
+
+    cr.paint(1.0)
+    final_pb = surface.to_pixbuf
+    cr.destroy
+    surface.destroy
+    return final_pb
+  end
+end
+
+class Gamma < ImageOp
+  attr_reader :gamma
+  def initialize(gamma=1.0)
+    super()
+    @gamma = gamma
+  end
+  def call(image, pixbuf)
+    if @gamma == 1.0
+      pixbuf
+    else
+      PixbufUtils.gamma(pixbuf, @gamma)
+    end
+  end
+  def priority
+    90
+  end
+end
+
+class RedEyeOp < ImageOp
+  attr_reader :x1, :y1, :x2, :y2, :sensitivity, :no_eyes
+  attr_accessor :order
+  def initialize(x1, y1, x2, y2, sensitivity, no_eyes)
+    super()
+    require 'redeye'
+    x1, x2 = x2, x1 if x1 > x2
+    y1, y2 = y2, y1 if y1 > y2
+    @x1, @y1, @x2, @y2, @sensitivity, @no_eyes =
+      x1, y1, x2, y2, sensitivity, no_eyes
+  end
+  def call(image, pixbuf)
+    @x2 = pixbuf.width if @x2 >= pixbuf.width
+    @y2 = pixbuf.height if @y2 >= pixbuf.height
+    @x1 = @x2 - 1 if @x1 >= @x2
+    @y1 = @y2 - 1 if @y1 >= @y2
+    redeye = ::RedEye.new(pixbuf.dup, @x1, @y1, @x2, @y2)
+    blobs = redeye.identify_blobs(@sensitivity).reject { |i|
+      i.noPixels < 2 or ! i.squareish?(0.5, 0.4)
+    }.sort_by { |i| i.noPixels }
+    biggest = blobs.size > @no_eyes ?  blobs[-1 * @no_eyes..-1] : blobs
+    biggest.each { |blob| redeye.correct_blob(blob.id) }
+    redeye.pixbuf
+  end
+  def priority
+    20 + @order
+  end
+end
+
+class Colourify < ImageOp
+  attr_reader :op
+  def initialize(op, alpha=255)
+    super()
+    @op = op
+    @alpha = alpha
+  end
+
+  def alpha
+    @alpha || 255
+  end
+
+  def sepia(pixbuf)
+    PixbufUtils.tint(pixbuf, 25, 5, -25, alpha)
+  end
+
+  def bluetone(pixbuf)
+    PixbufUtils.tint(pixbuf, -10, 5, 25, alpha)
+  end
+
+  def null(pixbuf)
+    pixbuf
+  end
+  alias :full :null # WebKiosk
+  alias :colour :null # WebKiosk
+
+  def greyscale(pixbuf)
+    PixbufUtils.tint(pixbuf, 0, 0, 0, alpha)
+  end
+  alias :bw :greyscale # WebKiosk
+
+  def call(image, pixbuf)
+    if @op and respond_to?(@op)
+      __send__(@op, pixbuf)
+    else
+      pixbuf # Default is nothing
+    end
+  end
+end
+
+end

data/lib/morandi/redeye.rb

@@ -0,0 +1,55 @@
+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 { |i|
+      i.noPixels < 4 or ! i.squareish?(0.5, 0.4)
+    }.sort_by { |i|
+      i.area_min_x = x1
+      i.area_min_y = y1
+
+      # Higher is better
+      score = (i.noPixels) / (i.distance_from(x, y) ** 2)
+    }
+
+    #blobs.each do |blob|
+    #  p [ [x, y], blob.centre(), blob.distance_from(x, y), blob]
+    #end
+
+    blob = blobs.last
+    redeye.correct_blob(blob.id) if blob
+    pb = redeye.pixbuf
+  end
+end
+end
+end
+
+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
+
+  # Pythagorean
+  def distance_from(x,y)
+    cx,cy = centre()
+
+    dx = cx - x
+    dy = cy - y
+
+    Math.sqrt( (dx * dx) + (dy * dy) )
+  end
+end
+

data/lib/morandi/utils.rb

@@ -0,0 +1,106 @@
+module Morandi
+  module Utils
+    module_function
+    def autocrop_coords(iw, ih, width, height)
+      return nil unless width
+      aspect = width.to_f / height.to_f
+      iaspect = iw.to_f / ih.to_f
+
+      if ih > iw
+        # Portrait image
+        # Check whether the aspect ratio is greater or smaller
+        # ie. where constraints will hit
+        aspect = height.to_f / width.to_f
+      end
+
+      # Landscape
+      if aspect > iaspect
+        # Width constraint - aspect-rect wider
+        crop_width  = iw
+        crop_height = (crop_width / aspect).to_i
+      else
+        # Height constraint - aspect-rect wider
+        crop_height = ih
+        crop_width  = (crop_height * aspect).to_i
+      end
+
+      [
+        ((iw - crop_width)>>1),
+        ((ih - crop_height)>>1),
+        crop_width,
+        crop_height
+      ].map { |i| i.to_i }
+    end
+
+    def constrain(val,min,max)
+      if val < min
+        min
+      elsif val > max
+        max
+      else
+        val
+      end
+    end
+
+    def apply_crop(pixbuf, x, y, w, h, fill_col = 0xffffffff)
+      if (x < 0) or (y < 0) || ((x+w) > pixbuf.width) || ((y+h) > pixbuf.height)
+        #tw, th = [w-x,w].max, [h-y,h].max
+        base_pixbuf = Gdk::Pixbuf.new(Gdk::Pixbuf::ColorSpace::RGB, false, 8, w, h)
+        base_pixbuf.fill!(fill_col)
+        dest_x = [x, 0].min
+        dest_y = [y, 0].min
+        #src_x = [x,0].max
+        #src_y = [y,0].max
+        dest_x = [-x,0].max
+        dest_y = [-y,0].max
+
+        #if x < 0
+        #else
+        #end
+        #if y < 0
+        #  dest_h = [h-dest_y, pixbuf.height, base_pixbuf.height-dest_y].min
+        #else
+        #	dest_h = [h,pixbuf.height].min
+        #end
+        #  dest_w  = [w-dest_x, pixbuf.width, base_pixbuf.width-dest_x].min
+
+        offset_x = [x,0].max
+        offset_y = [y,0].max
+        copy_w = [w, pixbuf.width - offset_x].min
+        copy_h = [h, pixbuf.height - offset_y].min
+
+        paste_x = [x, 0].min * -1
+        paste_y = [y, 0].min * -1
+
+        if copy_w + paste_x > base_pixbuf.width
+          copy_w = base_pixbuf.width - paste_x
+        end
+        if copy_h + paste_y > base_pixbuf.height
+          copy_h = base_pixbuf.height - paste_y
+        end
+
+        args = [pixbuf, paste_x, paste_y, copy_w, copy_h, paste_x - offset_x, paste_y - offset_y, 1, 1, Gdk::Pixbuf::INTERP_HYPER, 255]
+        #p args
+        base_pixbuf.composite!(*args)
+        pixbuf = base_pixbuf
+      else
+        x = constrain(x, 0, pixbuf.width)
+        y = constrain(y, 0, pixbuf.height)
+        w = constrain(w, 1, pixbuf.width - x)
+        h = constrain(h, 1, pixbuf.height - y)
+        #p [pixbuf, x, y, w, h]
+        pixbuf = Gdk::Pixbuf.new(pixbuf, x, y, w, h)
+      end
+      pixbuf
+    end
+  end
+end
+
+class Gdk::Pixbuf
+  def scale_max(max_size, interp = Gdk::Pixbuf::InterpType::BILINEAR, max_scale = 1.0)
+    mul = (max_size / [width,height].max.to_f)
+    mul = [max_scale = 1.0,mul].min
+    scale(width * mul, height * mul, interp)
+  end
+end
+

data/lib/morandi/version.rb

@@ -0,0 +1,3 @@
+module Morandi
+  VERSION = "0.9.0"
+end

data/morandi.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'morandi/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "morandi"
+  spec.version       = Morandi::VERSION
+  spec.authors       = ["Geoff Youngs\n\n\n"]
+  spec.email         = ["git@intersect-uk.co.uk"]
+  spec.summary       = %q{Simple Image Edits}
+  spec.description   = %q{Apply simple edits to images}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "gdk_pixbuf2"
+  spec.add_dependency "cairo"
+  spec.add_dependency "pixbufutils"
+  spec.add_dependency "redeye"
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/morandi_spec.rb

@@ -0,0 +1,64 @@
+require 'morandi'
+
+RSpec.describe Morandi, "#process_to_file" do
+  context "in command mode" do
+    it "should create ouptut" do
+      Morandi.process("sample/sample.jpg", {}, out="sample/out_plain.jpg")
+      expect(File.exist?(out))
+    end
+
+    it "should do rotation of images" do
+      original = Gdk::Pixbuf.get_file_info("sample/sample.jpg")
+      Morandi.process("sample/sample.jpg", {
+        'angle' => 90
+      }, out="sample/out_rotate90.jpg")
+      expect(File.exist?(out))
+      _,w,h = Gdk::Pixbuf.get_file_info(out)
+      expect(original[1]).to eq(h)
+      expect(original[2]).to eq(w)
+    end
+
+    it "should do cropping of images" do
+      Morandi.process("sample/sample.jpg", {
+        'crop' => [10,10,300,300]
+      }, out="sample/out_crop.jpg")
+      expect(File.exist?(out))
+      _,w,h = Gdk::Pixbuf.get_file_info(out)
+      expect(w).to eq(300)
+      expect(h).to eq(300)
+    end
+
+    it "should reduce the size of images" do
+      Morandi.process("sample/sample.jpg", {
+        'output.max' => 200
+      }, out="sample/out_reduce.jpg")
+      expect(File.exist?(out))
+      _,w,h = Gdk::Pixbuf.get_file_info(out)
+      expect(w).to be <= 200
+      expect(h).to be <= 200
+    end
+
+    it "should reduce the size of images" do
+      Morandi.process("sample/sample.jpg", {
+        'fx' => 'sepia'
+      }, out="sample/out_sepia.jpg")
+      expect(File.exist?(out))
+      _,w,h = Gdk::Pixbuf.get_file_info(out)
+      expect(_.name).to eq('jpeg')
+    end
+
+    it "should output at the specified size" do
+      Morandi.process("sample/sample.jpg", {
+        'output.width' => 300,
+        'output.height' => 200,
+        'image.auto-crop' => true,
+        'output.limit' => true
+      }, out="sample/out_at_size.jpg")
+      expect(File.exist?(out))
+      _,w,h = Gdk::Pixbuf.get_file_info(out)
+      expect(_.name).to eq('jpeg')
+      expect(h).to be <= 200
+      expect(w).to be <= 300
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: morandi
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- |+
+  Geoff Youngs
+
+
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gdk_pixbuf2
+  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'
+- !ruby/object:Gem::Dependency
+  name: cairo
+  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'
+- !ruby/object:Gem::Dependency
+  name: pixbufutils
+  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'
+- !ruby/object:Gem::Dependency
+  name: redeye
+  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'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  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
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/morandi.rb
+- lib/morandi/image-ops.rb
+- lib/morandi/redeye.rb
+- lib/morandi/utils.rb
+- lib/morandi/version.rb
+- morandi.gemspec
+- sample/sample.jpg
+- spec/morandi_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: Simple Image Edits
+test_files:
+- spec/morandi_spec.rb
+- spec/spec_helper.rb