imogen 0.0.3

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NzMwYzg4MjlkMjE0MDBmYjYzMWZlZTZiOGZkYzcyYmE3OGU0YmQ2Yg==
+  data.tar.gz: !binary |-
+    NTYzYjQ3ZDMyMzJjMjU1ODAxNmUyNDU4Mjc3YTFjZjY1NmIyYTM5Yw==
+SHA512:
+  metadata.gz: !binary |-
+    MmMwZWM3MDE1ZDlmZTU5Y2U3YjQ4ZWE0ZDIxMzc2ODc3NGM0NmVhYzg2YTdk
+    MmFiY2I4OTA2MGJkNmJlYmUxNWVlMGQ4MzZmZTQ1Yjg0ZjIwNTc3MDgyNjVh
+    ZGVmZTMxOGMxODc1YzBjMmI4ODU1YTkzZjdhNmYwM2JlNzYxYjc=
+  data.tar.gz: !binary |-
+    OTU3MWQ4MjI3NWY1ODAzNjQzZTg5YmI4MGMyZTU5MDYxOWI2MDAzZTgxODAz
+    YjlhYjQwOWUwN2ZjZGFmYjcxM2U0ODdiOTM1Njg3OGYxYjNhNTc3OTg3MGMw
+    NmNhZjc3YTQ2NGIwOWM0ZmRlNDY4N2RiMGEzOWJhMGNlOGYyODE=

data/lib/imogen/auto_crop/box.rb

@@ -0,0 +1,79 @@
+#!ruby
+require 'opencv'
+module Imogen::AutoCrop::Box
+  include OpenCV
+  class Best
+    def initialize(grayscale)
+      @corners = grayscale.good_features_to_track(0.3, 1.0, block_size: 3, max: 20)
+      if @corners.nil? or @corners.length == 0
+        @center = Center.new(grayscale)
+      else
+        @center = nil
+      end
+    end
+
+    def self.distance(p1, p2)
+      dx = p1.x.to_i - p2.x.to_i
+      dy = p1.y.to_i - p2.y.to_i
+      return Math.sqrt((dx * dx) + (dy * dy)) 
+    end
+
+    def box()
+      return @center.box unless @center.nil?
+      c = median()
+      cp = BoxInfo.new(c[0], c[1],0)
+      total_distance = 0;
+      features = @corners.collect {|corner| d = Best.distance(corner, cp); total_distance += d; {x: corner.x, y: corner.y, d: d}}
+      mean_distance = total_distance/features.length
+      sigma = features.inject(0) {|memo, feature| v = feature[:d] - mean_distance; memo += (v*v)}
+      sigma = Math.sqrt(sigma.to_f/features.length)
+      # 2 sigmas would capture > 95% of normally distributed features
+      cp.radius = 2*sigma
+      cp
+    end
+
+    def median()
+      @median ||= begin
+        xs = []
+        ys = []
+        @corners.each {|c| xs << c.x.to_i; ys << c.y.to_i}
+        xs.sort!
+        ys.sort!
+        ix = 0
+        if (@corners.length % 2 == 0)
+          l = (@corners.length == 2) ? 0 : (@corners.length/2)
+          x = ((xs[l] + xs[l+1]) /2).floor
+          y = ((ys[l] + ys[l+1]) /2).floor
+          [x,y]
+        else
+          r = (@corners.length/2).ceil
+          [xs[r], ys[r]]
+        end
+      end
+    end
+  end
+  class Center
+    def initialize(grayscale)
+      @center ||= [(grayscale.cols/2).floor, (grayscale.rows/2).floor]
+      @radius = @center.min
+      @ratio = @radius / @center.max
+    end
+    def box
+      return BoxInfo.new(@center[0],@center[1],@radius)
+    end
+  end
+  class BoxInfo
+    attr_reader :x, :y
+    attr_accessor :radius
+    def initialize(x,y,r)
+      @x = x
+      @y = y
+      @radius = r
+    end
+  end
+  def self.info(grayscale)
+    dims = [grayscale.cols, grayscale.rows]
+    ratio = dims.min / dims.max
+    ratio < 0.84 ? Best.new(grayscale).box() : Center.new(grayscale).box()
+  end
+end

data/lib/imogen/auto_crop/edges.rb

@@ -0,0 +1,63 @@
+#!ruby
+require 'opencv'
+require 'free-image'
+require 'tempfile'
+
+module Imogen::AutoCrop
+class Edges
+  include OpenCV
+  def initialize(src)
+    @xoffset = 0
+    @yoffset = 0
+    if src.is_a? FreeImage::Bitmap
+      img = src
+      @xoffset = img.width.to_f/6
+      @yoffset = img.height.to_f/6
+      @tempfile = Tempfile.new(['crop','.png'])
+
+      img.copy(@xoffset,@yoffset,img.width-@xoffset,img.height-@yoffset) do |crop|
+        crop.save(@tempfile.path, :png)
+        crop.free
+      end
+    else
+      raise src.class.name 
+    end
+    # use bigger features on bigger images
+    @grayscale = CvMat.load(@tempfile.path, CV_LOAD_IMAGE_GRAYSCALE)
+    @xrange = (0..@grayscale.cols)
+    @yrange = (0..@grayscale.rows)
+  end
+
+  def bound_min(center)
+    [center.x - @xrange.min, @xrange.max - center.x, center.y - @yrange.min, @yrange.max - center.y].min
+  end
+
+  # returns leftX, topY, rightX, bottomY
+  def get(*args)
+    c = Imogen::AutoCrop::Box.info(@grayscale)
+    r = c.radius.floor
+    # adjust the box
+    coords = [c.x, c.y]
+    min_rad = args.max/2
+    unless r >= min_rad && r <= bound_min(c)
+      # first adjust to the lesser of max (half short dimension) and min (half requested length) radius
+      # this might require upscaling in rare situations to preserve bound safety
+      r = min_rad if r < min_rad
+      max_rad = [@xrange.max - @xrange.min, @yrange.max - @yrange.min].min / 2
+      r = max_rad if r > max_rad
+      # now move the center point minimally to accomodate the necessary radius
+      coords[0] = @xrange.max - r if (coords[0] + r) > @xrange.max  
+      coords[0] = @xrange.min + r if (coords[0] - r) < @xrange.min  
+      coords[1] = @yrange.max - r if (coords[1] + r) > @yrange.max  
+      coords[1] = @yrange.min + r if (coords[1] - r) < @yrange.min  
+    end
+    coords = [coords[0] + @xoffset, coords[1] + @yoffset].collect {|i| i.floor}
+    c = coords
+
+    return [c[0]-r, c[1]-r, c[0]+r, c[1] + r]
+  end
+  def unlink
+    @tempfile.unlink
+  end
+end
+end

data/lib/imogen/auto_crop.rb

@@ -0,0 +1,20 @@
+module Imogen
+  module AutoCrop
+    autoload :Edges, 'imogen/auto_crop/edges'
+    autoload :Box, 'imogen/auto_crop/box'
+    def self.convert(img, dest_path, scale=768, format=:jpeg)
+      frame = Edges.new(img)
+      edges = frame.get(scale)
+      img.copy(*edges) do |crop|
+        crop.rescale(scale, scale) do |thumb|
+          t24 = thumb.convert_to_24bits
+          dst = FreeImage::File.new(dest_path)
+          dst.save(t24, format)
+          t24.free
+          thumb.free
+        end
+      end
+      frame.unlink
+    end
+  end
+end

data/lib/imogen/zoomable.rb

@@ -0,0 +1,15 @@
+#require 'image_science'
+module Imogen
+	module Zoomable
+    def self.levels_for(*dims)
+      max = dims[0..1].max || 0
+      return 0 if max < 192
+      max_tiles = (max.to_f / 96)
+      Math.log2(max_tiles).floor
+    end
+    def self.convert(img, dest_path)
+      dst = FreeImage::File.new(dest_path)
+      dst.save(img, :jp2, 8)
+    end
+  end
+end

data/lib/imogen.rb

@@ -0,0 +1,106 @@
+# encoding: UTF-8
+require 'ffi'
+require 'rbconfig'
+require 'free-image'
+module Imogen
+
+  def self.from(src_path)
+    FreeImage::Bitmap.open(src_path) do |img|
+      yield img
+    end
+  end
+  module Scaled
+    def self.convert(img, dest_path, scale=1500, format = :jpeg)
+      w = img.width
+      h = img.height
+      dims = (w > h) ? [1500, 1500*h/w] : [1500*w/h, 1500]
+      img.rescale(dims[0], dims[1]) do |scaled|
+        scaled = scaled.convert_to_24bits
+        dst = FreeImage::File.new(dest_path)
+        dst.save(scaled, format)
+        scaled.free
+      end
+    end
+  end
+  require 'imogen/auto_crop'
+  require 'imogen/zoomable'
+
+  def self.search_paths
+    @search_paths ||= begin
+      if ENV['FREE_IMAGE_LIBRARY_PATH']
+        [ ENV['FREE_IMAGE_LIBRARY_PATH'] ]
+      elsif FFI::Platform::IS_WINDOWS
+        ENV['PATH'].split(File::PATH_SEPARATOR)
+      else
+        [ '/usr/local/{lib64,lib32,lib}', '/opt/local/{lib64,lib32,lib}', '/usr/{lib64,lib32,lib}' ]
+      end
+    end
+  end
+
+  def self.find_lib(lib)
+    files = search_paths.inject(Array.new) do |array, path|
+      file_name = File.expand_path(File.join(path, "#{lib}.#{FFI::Platform::LIBSUFFIX}"))
+      array << Dir.glob(file_name)
+      array
+    end
+    files.flatten.compact.first
+  end
+
+  def self.free_image_library_paths
+    @free_image_library_paths ||= begin
+      libs = %w{libfreeimage libfreeimage.3 FreeImage}
+
+      libs.map do |lib|
+        find_lib(lib)
+      end.compact
+    end
+  end
+
+  extend ::FFI::Library
+
+  if free_image_library_paths.any?
+    ffi_lib(*free_image_library_paths)
+  elsif FFI::Platform.windows?
+    ffi_lib("FreeImaged")
+  else
+    ffi_lib("freeimage")
+  end
+
+  ffi_convention :stdcall if FFI::Platform.windows?
+
+  def self.format_from(image_path)
+    result = FreeImage.FreeImage_GetFileType(image_path, 0)
+    FreeImage.check_last_error
+
+    if result == :unknown
+      # Try to guess the file format from the file extension
+      result = FreeImage.FreeImage_GetFIFFromFilename(image_path)
+      FreeImage.check_last_error
+    end
+    result
+  end
+
+  def self.image(src_path)
+
+    flags = 0
+
+    fif = format_from(src_path)
+    if ((fif != :unknown) and FreeImage.FreeImage_FIFSupportsReading(fif))
+      ptr = FreeImage.FreeImage_Load(fif, src_path, flags)
+      FreeImage.check_last_error
+      return FreeImage::Bitmap.new(ptr, nil)
+    end
+    return nil
+  end
+  def self.with_image(src_path, &block)
+
+    flags = 0
+
+    fif = format_from(src_path)
+    if ((fif != :unknown) and FreeImage.FreeImage_FIFSupportsReading(fif))
+      ptr = FreeImage.FreeImage_Load(fif, src_path, flags)
+      FreeImage.check_last_error
+      FreeImage::Bitmap.new(ptr, nil, &block)
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: imogen
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Ben Armintor
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-opencv
+  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: 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: 
+email: armintor@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/imogen.rb
+- lib/imogen/auto_crop.rb
+- lib/imogen/auto_crop/box.rb
+- lib/imogen/auto_crop/edges.rb
+- lib/imogen/zoomable.rb
+homepage: https://github.com/cul/imogen
+licenses: []
+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.2
+signing_key: 
+specification_version: 4
+summary: derivative generation via FreeImage and smart square thumbnail via OpenCV
+test_files: []