morandi 0.12.1 → 0.99.4

data/lib/morandi/image-ops.rb

@@ -1,307 +0,0 @@
-require 'pango'
-require 'colorscore'
-
-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
-      GdkPixbuf::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'
-      # WARNING: CairoUtils class is not available in this gem!
-      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 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/utils.rb

@@ -1,136 +0,0 @@
-require 'gdk_pixbuf2'
-
-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 = GdkPixbuf::Pixbuf.new(
-          colorspace: GdkPixbuf::Colorspace::RGB,
-          has_alpha: false,
-          bits_per_sample: 8,
-          width: w,
-          height: 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
-        base_pixbuf.composite! pixbuf, {
-          dest_x: paste_x,
-          dest_y: paste_y,
-          dest_width: copy_w,
-          dest_height: copy_h,
-          offset_x: paste_x - offset_x,
-          offset_y: paste_y - offset_y,
-          scale_x: 1,
-          scale_y: 1,
-          interpolation_type: :hyper,
-          overall_alpha: 255
-        }
-        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 = pixbuf.subpixbuf(x, y, w, h)
-      end
-      pixbuf
-    end
-  end
-end
-
-class GdkPixbuf::Pixbuf
-  unless defined?(::GdkPixbuf::Pixbuf::InterpType)
-    InterpType = GdkPixbuf::InterpType
-  end
-
-  def scale_max(max_size, interp = GdkPixbuf::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
-
-class Cairo::ImageSurface
-  def to_pixbuf
-    loader = GdkPixbuf::PixbufLoader.new
-    io = StringIO.new
-    write_to_png(io)
-    io.rewind
-    loader.last_write(io.read)
-    loader.pixbuf
-  end
-end

data/morandi.gemspec

@@ -1,33 +0,0 @@
-# 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 "gtk2"
-  spec.add_dependency "gdk_pixbuf2", "~> 3.4.0"
-  spec.add_dependency "cairo"
-  spec.add_dependency "pixbufutils"
-  spec.add_dependency "redeye"
-  spec.add_dependency "pango"
-  spec.add_dependency "colorscore"
-
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "pry"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
-end

data/spec/morandi_spec.rb

@@ -1,208 +0,0 @@
-# frozen_string_literal: true
-
-require 'fileutils'
-require 'morandi'
-
-RSpec.describe Morandi, '#process' 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
-
-    context "with a big image and a bigger cropped area to fill" do
-      it 'should create ouptut' do
-        settings = {
-          "crop"=>"0,477,15839,18804",
-          "angle"=>90,
-          "fx"=>"colour",
-          "straighten"=>0.0,
-          "gamma"=>0.98,
-          "redeye"=>[]
-        }
-
-        Morandi.process('sample/sample.jpg', settings, out = 'sample/out_crop_glitch_image.jpg')
-        expect(File.exist?(out))
-      end
-    end
-
-    it 'should do rotation of images' do
-      original = GdkPixbuf::Pixbuf.get_file_info('sample/sample.jpg')
-      Morandi.process('sample/sample.jpg', {
-                        'angle' => 90
-                      }, out = 'sample/out_rotate90.jpg')
-      expect(File.exist?(out))
-      _, width, height = GdkPixbuf::Pixbuf.get_file_info(out)
-      expect(original[1]).to eq(height)
-      expect(original[2]).to eq(width)
-    end
-
-    it 'should accept pixbufs as an argument' do
-      pixbuf = GdkPixbuf::Pixbuf.new(file: 'sample/sample.jpg')
-      pro = Morandi::ImageProcessor.new(pixbuf, {}, {})
-      pro.process!
-      expect(pixbuf.width).to eq(pro.result.width)
-    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))
-      _, width, height = GdkPixbuf::Pixbuf.get_file_info(out)
-      expect(width).to eq(300)
-      expect(height).to eq(300)
-    end
-
-    it 'should use user supplied path.icc' do
-      src = 'sample/sample.jpg'
-      icc = '/tmp/this-is-secure-thing.jpg'
-      default_icc = Morandi::ImageProcessor.default_icc_path(src)
-      out = 'sample/out_icc.jpg'
-      FileUtils.rm_f(default_icc)
-      Morandi.process(src, {}, out, 'path.icc' => icc)
-      expect(File).to exist(icc)
-      expect(File).not_to exist(default_icc)
-    end
-
-    it 'should ignore user supplied path.icc' do
-      src = 'sample/sample.jpg'
-      icc = '/tmp/this-is-insecure-thing.jpg'
-      default_icc = Morandi::ImageProcessor.default_icc_path(src)
-      FileUtils.rm_f(icc)
-      FileUtils.rm_f(default_icc)
-      out = 'sample/out_icc.jpg'
-      Morandi.process(src, { 'path.icc' => icc, 'output.max' => 200 }, out)
-      expect(File).not_to exist(icc)
-      expect(File).to exist(default_icc)
-    end
-
-    it 'should do cropping of images with a string' do
-      Morandi.process('sample/sample.jpg', {
-                        'crop' => '10,10,300,300'
-                      }, out = 'sample/out_crop.jpg')
-      expect(File.exist?(out))
-      _, width, height = GdkPixbuf::Pixbuf.get_file_info(out)
-      expect(width).to eq(300)
-      expect(height).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))
-      _, width, height = GdkPixbuf::Pixbuf.get_file_info(out)
-      expect(width).to be <= 200
-      expect(height).to be <= 200
-    end
-
-    it 'should reduce the straighten images' do
-      Morandi.process('sample/sample.jpg', {
-                        'straighten' => 5
-                      }, out = 'sample/out_straighten.jpg')
-      expect(File.exist?(out))
-      info, _, _ = GdkPixbuf::Pixbuf.get_file_info(out)
-      expect(info.name).to eq('jpeg')
-    end
-
-    it 'should reduce the gamma correct images' do
-      Morandi.process('sample/sample.jpg', {
-                        'gamma' => 1.2
-                      }, out = 'sample/out_gamma.jpg')
-      expect(File.exist?(out))
-      info, _, _ = GdkPixbuf::Pixbuf.get_file_info(out)
-      expect(info.name).to eq('jpeg')
-    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))
-      info, _, _ = GdkPixbuf::Pixbuf.get_file_info(out)
-      expect(info.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))
-      info, width, height = GdkPixbuf::Pixbuf.get_file_info(out)
-      expect(info.name).to eq('jpeg')
-      expect(width).to be <= 300
-      expect(height).to be <= 200
-    end
-
-    it 'should blur the image' do
-      Morandi.process('sample/sample.jpg', {
-        'sharpen'  => -3
-      }, out = 'sample/out_blur.jpg')
-      expect(File.exist?(out))
-    end
-
-    it 'should apply a border and maintain the target size' do
-      Morandi.process('sample/sample.jpg', {
-        'border-style'     => 'square',
-        'background-style' => 'dominant',
-        'border-size-mm'   => 5,
-        'output.width'     => 800,
-        'output.height'    => 650
-      }, out = 'sample/out_border.jpg')
-      expect(File.exist?(out))
-
-      info, width, height = GdkPixbuf::Pixbuf.get_file_info(out)
-      expect(info.name).to eq('jpeg')
-      expect(width).to eq 800
-      expect(height).to eq 650
-    end
-
-    it 'should apply multiple transformations' do
-      Morandi.process('sample/sample.jpg', {
-        'brighten'         => 5,
-        'contrast'         => 5,
-        'sharpen'          => 2,
-        'fx'               => 'greyscale',
-        'border-style'     => 'solid',
-        'background-style' => '#00FF00',
-        'crop'             => [50, 0, 750, 650],
-        'output.width'     => 300,
-        'output.height'    => 260,
-        'output.limit'     => true
-      }, out = 'sample/out_various.jpg')
-      expect(File.exist?(out))
-
-      info, width, height = GdkPixbuf::Pixbuf.get_file_info(out)
-      expect(info.name).to eq('jpeg')
-      expect(width).to eq 300
-      expect(height).to eq 260
-    end
-  end
-
-  context 'with increasing quality settings' do
-    let(:max_quality_file_size) do
-      Morandi.process('sample/sample.jpg', { 'quality' => 100 }, 'sample/out-100.jpg')
-      File.size('sample/out-100.jpg')
-    end
-
-    let(:default_of_97_quality) do
-      Morandi.process('sample/sample.jpg', {}, 'sample/out-97.jpg')
-      File.size('sample/out-97.jpg')
-    end
-
-    let(:quality_of_40_by_options_args) do
-      Morandi.process('sample/sample.jpg', { 'quality' => 40 }, 'sample/out-40.jpg')
-      File.size('sample/out-40.jpg')
-    end
-
-    # Sort the output files' sizes and expect them to match to quality order
-    it 'creates files of increasing size' do
-      created_file_sizes = [default_of_97_quality, max_quality_file_size, quality_of_40_by_options_args].sort
-      expect(created_file_sizes).to eq([quality_of_40_by_options_args, default_of_97_quality, max_quality_file_size])
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,19 +0,0 @@
-# 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
-
-require "pry"
-
-RSpec.configure do |config|
-  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