smartcrop-rails 0.1.12 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 587e817f6248849e1897dc152f0785e9e0eb0bf8
-  data.tar.gz: f67399f4ee4c4fdf430c5c6f2e4a12a4a4e86b77
+  metadata.gz: af7d9f17f5b2d5c660ec32c3d4383ec3f92773e7
+  data.tar.gz: b9fd2c1551321cfc99adee8da45c71601c5103f8
 SHA512:
-  metadata.gz: 2a9f0de4b55fdc8cc68928d4e4aec6c8a82e34ecbb1eab6c7a5dbde1de1ca465b039b407269167afe5b9396ab593ad8cb77270ec1f93c114126f95c1dc88655e
-  data.tar.gz: 0cd4beb44a5aa523e4477b3d700ff0b37e1b7c9cff57ad7a0d91dfa690830a2a080d30ffc123c258d4b41dc6021a5eeeec71353ea1e6985852bf22cdcae28f04
+  metadata.gz: 430abe02c079fd9d1a2f78ab9c4dd7f2f1bbf5ad5cedeb1634c883928c3c68fee1ac11b6b21ca78d16b6c1da05e02dfc102b2c7f715d1f96858ca99119bc0784
+  data.tar.gz: c0a8abae042233c194064153f226c6a7225c339a5dae6829723465f0bca1a749c161f7d20491e96847b9f217ad77df960ed2e5970c3d4722558ee769b4a03099

data/lib/smartcrop/rails/version.rb

@@ -1,5 +1,5 @@
 module Smartcrop
   module Rails
-    VERSION = "0.1.12"
+    VERSION = "1.1.0"
   end
 end

data/vendor/assets/javascripts/smartcrop.js

@@ -1,7 +1,8 @@
-/** smart-crop.js
+/**
+ * smartcrop.js
  * A javascript library implementing content aware image cropping
  *
- * Copyright (C) 2014 Jonas Wagner
+ * Copyright (C) 2016 Jonas Wagner
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
@@ -23,369 +24,527 @@
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-(function(){
-"use strict";
+(function() {
+'use strict';
 
-function SmartCrop(options){
-   this.options = extend({}, SmartCrop.DEFAULTS, options);
-}
-SmartCrop.DEFAULTS = {
-    width: 0,
-    height: 0,
-    aspect: 0,
-    cropWidth: 0,
-    cropHeight: 0,
-    detailWeight: 0.2,
-    skinColor: [0.78, 0.57, 0.44],
-    skinBias: 0.01,
-    skinBrightnessMin: 0.2,
-    skinBrightnessMax: 1.0,
-    skinThreshold: 0.8,
-    skinWeight: 1.8,
-    saturationBrightnessMin: 0.05,
-    saturationBrightnessMax: 0.9,
-    saturationThreshold: 0.4,
-    saturationBias: 0.2,
-    saturationWeight: 0.3,
-    // step * minscale rounded down to the next power of two should be good
-    scoreDownSample: 8,
-    step: 8,
-    scaleStep: 0.1,
-    minScale: 0.9,
-    maxScale: 1.0,
-    edgeRadius: 0.4,
-    edgeWeight: -20.0,
-    outsideImportance: -0.5,
-    ruleOfThirds: true,
-    prescale: true,
-    canvasFactory: null,
-    debug: false
+var smartcrop = {};
+// Promise implementation to use
+smartcrop.Promise = typeof Promise !== 'undefined' ? Promise : function() {
+  throw new Error('No native promises and smartcrop.Promise not set.');
+};
+
+smartcrop.DEFAULTS = {
+  width: 0,
+  height: 0,
+  aspect: 0,
+  cropWidth: 0,
+  cropHeight: 0,
+  detailWeight: 0.2,
+  skinColor: [0.78, 0.57, 0.44],
+  skinBias: 0.01,
+  skinBrightnessMin: 0.2,
+  skinBrightnessMax: 1.0,
+  skinThreshold: 0.8,
+  skinWeight: 1.8,
+  saturationBrightnessMin: 0.05,
+  saturationBrightnessMax: 0.9,
+  saturationThreshold: 0.4,
+  saturationBias: 0.2,
+  saturationWeight: 0.3,
+  // Step * minscale rounded down to the next power of two should be good
+  scoreDownSample: 8,
+  step: 8,
+  scaleStep: 0.1,
+  minScale: 1.0,
+  maxScale: 1.0,
+  edgeRadius: 0.4,
+  edgeWeight: -20.0,
+  outsideImportance: -0.5,
+  boostWeight: 100.0,
+  ruleOfThirds: true,
+  prescale: true,
+  imageOperations: null,
+  canvasFactory: defaultCanvasFactory,
+  // Factory: defaultFactories,
+  debug: false,
 };
-SmartCrop.crop = function(image, options, callback){
-    if(options.aspect){
-        options.width = options.aspect;
-        options.height = 1;
+
+
+
+smartcrop.crop = function(inputImage, options_, callback) {
+  var options = extend({}, smartcrop.DEFAULTS, options_);
+
+  if (options.aspect) {
+    options.width = options.aspect;
+    options.height = 1;
+  }
+
+  if (options.imageOperations === null) {
+    options.imageOperations = canvasImageOperations(options.canvasFactory);
+  }
+
+  var iop = options.imageOperations;
+
+  var scale = 1;
+  var prescale = 1;
+
+  return iop.open(inputImage, options.input).then(function(image) {
+
+    if (options.width && options.height) {
+      scale = min(image.width / options.width, image.height / options.height);
+      options.cropWidth = ~~(options.width * scale);
+      options.cropHeight = ~~(options.height * scale);
+      // Img = 100x100, width = 95x95, scale = 100/95, 1/scale > min
+      // don't set minscale smaller than 1/scale
+      // -> don't pick crops that need upscaling
+      options.minScale = min(options.maxScale, max(1 / scale, options.minScale));
+
+      if (options.prescale !== false) {
+        prescale = 1 / scale / options.minScale;
+        if (prescale < 1) {
+          image = iop.resample(image, image.width * prescale, image.height * prescale);
+          options.cropWidth = ~~(options.cropWidth * prescale);
+          options.cropHeight = ~~(options.cropHeight * prescale);
+          if (options.boost) {
+            options.boost = options.boost.map(function(boost) {
+              return {
+                x: ~~(boost.x * prescale),
+                y: ~~(boost.y * prescale),
+                width: ~~(boost.width * prescale),
+                height: ~~(boost.height * prescale),
+                weight: boost.weight
+              };
+            });
+          }
+        }
+        else {
+          prescale = 1;
+        }
+      }
     }
+    return image;
+  })
+  .then(function(image) {
+    return iop.getData(image).then(function(data) {
+      var result = analyse(options, data);
 
-    // work around images scaled in css by drawing them onto a canvas
-    if(image.naturalWidth && (image.naturalWidth != image.width || image.naturalHeight != image.height)){
-        var c = new SmartCrop(options).canvas(image.naturalWidth, image.naturalHeight),
-            cctx = c.getContext('2d');
-        c.width = image.naturalWidth;
-        c.height = image.naturalHeight;
-        cctx.drawImage(image, 0, 0);
-        image = c;
+      var crops = result.crops || [result.topCrop];
+      for (var i = 0, iLen = crops.length; i < iLen; i++) {
+        var crop = crops[i];
+        crop.x = ~~(crop.x / prescale);
+        crop.y = ~~(crop.y / prescale);
+        crop.width = ~~(crop.width / prescale);
+        crop.height = ~~(crop.height / prescale);
+      }
+      if (callback) callback(result);
+      return result;
+    });
+  });
+};
+
+
+// Check if all the dependencies are there
+// todo:
+smartcrop.isAvailable = function(options) {
+  if (!smartcrop.Promise) return false;
+
+  var canvasFactory = options ? options.canvasFactory : defaultCanvasFactory;
+
+  if (canvasFactory === defaultCanvasFactory) {
+    var c = document.createElement('canvas');
+    if (!c.getContext('2d')) {
+      return false;
     }
+  }
+
+  return true;
+};
+
+function edgeDetect(i, o) {
+  var id = i.data;
+  var od = o.data;
+  var w = i.width;
+  var h = i.height;
 
-    var scale = 1,
-        prescale = 1;
-    if(options.width && options.height) {
-        scale = min(image.width/options.width, image.height/options.height);
-        options.cropWidth = ~~(options.width * scale);
-        options.cropHeight = ~~(options.height * scale);
-        // img = 100x100, width = 95x95, scale = 100/95, 1/scale > min
-        // don't set minscale smaller than 1/scale
-        // -> don't pick crops that need upscaling
-        options.minScale = min(options.maxScale || SmartCrop.DEFAULTS.maxScale, max(1/scale, (options.minScale||SmartCrop.DEFAULTS.minScale)));
+  for (var y = 0; y < h; y++) {
+    for (var x = 0; x < w; x++) {
+      var p = (y * w + x) * 4;
+      var lightness;
+
+      if (x === 0 || x >= w - 1 || y === 0 || y >= h - 1) {
+        lightness = sample(id, p);
+      }
+      else {
+        lightness = sample(id, p) * 4 -
+            sample(id, p - w * 4) -
+            sample(id, p - 4) -
+            sample(id, p + 4) -
+            sample(id, p + w * 4);
+      }
+
+      od[p + 1] = lightness;
     }
-    var smartCrop = new SmartCrop(options);
-    if(options.width && options.height) {
-        if(options.prescale !== false){
-            prescale = 1/scale/options.minScale;
-            if(prescale < 1) {
-                var prescaledCanvas = smartCrop.canvas(image.width*prescale, image.height*prescale),
-                    ctx = prescaledCanvas.getContext('2d');
-                ctx.drawImage(image, 0, 0, image.width, image.height, 0, 0, prescaledCanvas.width, prescaledCanvas.height);
-                image = prescaledCanvas;
-                smartCrop.options.cropWidth = ~~(options.cropWidth*prescale);
-                smartCrop.options.cropHeight = ~~(options.cropHeight*prescale);
-            }
-            else {
-                prescale = 1;
-            }
-        }
+  }
+}
+
+function skinDetect(options, i, o) {
+  var id = i.data;
+  var od = o.data;
+  var w = i.width;
+  var h = i.height;
+
+  for (var y = 0; y < h; y++) {
+    for (var x = 0; x < w; x++) {
+      var p = (y * w + x) * 4;
+      var lightness = cie(id[p], id[p + 1], id[p + 2]) / 255;
+      var skin = skinColor(options, id[p], id[p + 1], id[p + 2]);
+      var isSkinColor = skin > options.skinThreshold;
+      var isSkinBrightness = lightness >= options.skinBrightnessMin && lightness <= options.skinBrightnessMax;
+      if (isSkinColor && isSkinBrightness) {
+        od[p] = (skin - options.skinThreshold) * (255 / (1 - options.skinThreshold));
+      }
+      else {
+        od[p] = 0;
+      }
     }
-    var result = smartCrop.analyse(image);
-    for(var i = 0, i_len = result.crops.length; i < i_len; i++) {
-        var crop = result.crops[i];
-        crop.x = ~~(crop.x/prescale);
-        crop.y = ~~(crop.y/prescale);
-        crop.width = ~~(crop.width/prescale);
-        crop.height = ~~(crop.height/prescale);
+  }
+}
+
+function saturationDetect(options, i, o) {
+  var id = i.data;
+  var od = o.data;
+  var w = i.width;
+  var h = i.height;
+  for (var y = 0; y < h; y++) {
+    for (var x = 0; x < w; x++) {
+      var p = (y * w + x) * 4;
+
+      var lightness = cie(id[p], id[p + 1], id[p + 2]) / 255;
+      var sat = saturation(id[p], id[p + 1], id[p + 2]);
+
+      var acceptableSaturation = sat > options.saturationThreshold;
+      var acceptableLightness = lightness >= options.saturationBrightnessMin &&
+          lightness <= options.saturationBrightnessMax;
+      if (acceptableLightness && acceptableLightness) {
+        od[p + 2] = (sat - options.saturationThreshold) * (255 / (1 - options.saturationThreshold));
+      }
+      else {
+        od[p + 2] = 0;
+      }
     }
-    callback(result);
-    return result;
-};
-// check if all the dependencies are there
-SmartCrop.isAvailable = function(options){
-    try {
-        var s = new this(options),
-            c = s.canvas(16, 16);
-        return typeof c.getContext === 'function';
+  }
+}
+
+function applyBoosts(options, output) {
+  if (!options.boost) return;
+  var od = output.data;
+  for (var i = 0; i < output.width; i += 4) {
+    od[i + 3] = 0;
+  }
+  for (i = 0; i < options.boost.length; i++) {
+    applyBoost(options.boost[i], options, output);
+  }
+}
+
+function applyBoost(boost, options, output) {
+  var od = output.data;
+  var w = output.width;
+  var x0 = ~~boost.x;
+  var x1 = ~~(boost.x + boost.width);
+  var y0 = ~~boost.y;
+  var y1 = ~~(boost.y + boost.height);
+  var weight = boost.weight * 255;
+  for (var y = y0; y < y1; y++) {
+    for (var x = x0; x < x1; x++) {
+      var i = (y * w + x) * 4;
+      od[i + 3] += weight;
     }
-    catch(e){
-        return false;
+  }
+}
+
+function generateCrops(options, width, height) {
+  var results = [];
+  var minDimension = min(width, height);
+  var cropWidth = options.cropWidth || minDimension;
+  var cropHeight = options.cropHeight || minDimension;
+  for (var scale = options.maxScale; scale >= options.minScale; scale -= options.scaleStep) {
+    for (var y = 0; y + cropHeight * scale <= height; y += options.step) {
+      for (var x = 0; x + cropWidth * scale <= width; x += options.step) {
+        results.push({
+          x: x,
+          y: y,
+          width: cropWidth * scale,
+          height: cropHeight * scale,
+        });
+      }
     }
-};
-SmartCrop.prototype = {
-    canvas: function(w, h){
-        if(this.options.canvasFactory !== null){
-            return this.options.canvasFactory(w, h);
-        }
-        var c = document.createElement('canvas');
-        c.width = w;
-        c.height = h;
-        return c;
-    },
-    edgeDetect: function(i, o){
-        var id = i.data,
-            od = o.data,
-            w = i.width,
-            h = i.height;
-        for(var y = 0; y < h; y++) {
-            for(var x = 0; x < w; x++) {
-                var p = (y*w+x)*4,
-                    lightness;
-                if(x === 0 || x >= w-1 || y === 0 || y >= h-1){
-                    lightness = sample(id, p);
-                }
-                else {
-                    lightness = sample(id, p)*4 - sample(id, p-w*4) - sample(id, p-4) - sample(id, p+4) - sample(id, p+w*4);
-                }
-                od[p+1] = lightness;
-            }
-        }
-    },
-    skinDetect: function(i, o){
-        var id = i.data,
-            od = o.data,
-            w = i.width,
-            h = i.height,
-            options = this.options;
-        for(var y = 0; y < h; y++) {
-            for(var x = 0; x < w; x++) {
-                var p = (y*w+x)*4,
-                    lightness = cie(id[p], id[p+1], id[p+2])/255,
-                    skin = this.skinColor(id[p], id[p+1], id[p+2]);
-                if(skin > options.skinThreshold && lightness >= options.skinBrightnessMin && lightness <= options.skinBrightnessMax){
-                    od[p] = (skin-options.skinThreshold)*(255/(1-options.skinThreshold));
-                }
-                else {
-                    od[p] = 0;
-                }
-            }
-        }
-    },
-    saturationDetect: function(i, o){
-        var id = i.data,
-            od = o.data,
-            w = i.width,
-            h = i.height,
-            options = this.options;
-        for(var y = 0; y < h; y++) {
-            for(var x = 0; x < w; x++) {
-                var p = (y*w+x)*4,
-                    lightness = cie(id[p], id[p+1], id[p+2])/255,
-                    sat = saturation(id[p], id[p+1], id[p+2]);
-                if(sat > options.saturationThreshold && lightness >= options.saturationBrightnessMin && lightness <= options.saturationBrightnessMax){
-                    od[p+2] = (sat-options.saturationThreshold)*(255/(1-options.saturationThreshold));
-                }
-                else {
-                    od[p+2] = 0;
-                }
-            }
-        }
-    },
-    crops: function(image){
-        var crops = [],
-            width = image.width,
-            height = image.height,
-            options = this.options,
-            minDimension = min(width, height),
-            cropWidth = options.cropWidth || minDimension,
-            cropHeight = options.cropHeight || minDimension;
-        for(var scale = options.maxScale; scale >= options.minScale; scale -= options.scaleStep){
-            for(var y = 0; y+cropHeight*scale <= height; y+=options.step) {
-                for(var x = 0; x+cropWidth*scale <= width; x+=options.step) {
-                    crops.push({
-                        x: x,
-                        y: y,
-                        width: cropWidth*scale,
-                        height: cropHeight*scale
-                    });
-                }
-            }
-        }
-        return crops;
-    },
-    score: function(output, crop){
-        var score = {
-                detail: 0,
-                saturation: 0,
-                skin: 0,
-                total: 0
-            },
-            options = this.options,
-            od = output.data,
-            downSample = options.scoreDownSample,
-            invDownSample = 1/downSample,
-            outputHeightDownSample = output.height*downSample,
-            outputWidthDownSample = output.width*downSample,
-            outputWidth = output.width;
-        for(var y = 0; y < outputHeightDownSample; y+=downSample) {
-            for(var x = 0; x < outputWidthDownSample; x+=downSample) {
-                var p = (~~(y*invDownSample)*outputWidth+~~(x*invDownSample))*4,
-                    importance = this.importance(crop, x, y),
-                    detail = od[p+1]/255;
-                score.skin += od[p]/255*(detail+options.skinBias)*importance;
-                score.detail += detail*importance;
-                score.saturation += od[p+2]/255*(detail+options.saturationBias)*importance;
-            }
+  }
+  return results;
+}
+
+function score(options, output, crop) {
+  var result = {
+    detail: 0,
+    saturation: 0,
+    skin: 0,
+    boost: 0,
+    total: 0,
+  };
+
+  var od = output.data;
+  var downSample = options.scoreDownSample;
+  var invDownSample = 1 / downSample;
+  var outputHeightDownSample = output.height * downSample;
+  var outputWidthDownSample = output.width * downSample;
+  var outputWidth = output.width;
+
+  for (var y = 0; y < outputHeightDownSample; y += downSample) {
+    for (var x = 0; x < outputWidthDownSample; x += downSample) {
+      var p = (~~(y * invDownSample) * outputWidth + ~~(x * invDownSample)) * 4;
+      var i = importance(options, crop, x, y);
+      var detail = od[p + 1] / 255;
+
+      result.skin += od[p] / 255 * (detail + options.skinBias) * i;
+      result.detail += detail * i;
+      result.saturation += od[p + 2] / 255 * (detail + options.saturationBias) * i;
+      result.boost += od[p + 3] / 255 * i;
+    }
+  }
+
+  result.total = (result.detail * options.detailWeight +
+                  result.skin * options.skinWeight +
+                  result.saturation * options.saturationWeight +
+                  result.boost * options.boostWeight) / (crop.width * crop.height);
+  return result;
+}
+
+function importance(options, crop, x, y) {
+  if (crop.x > x || x >= crop.x + crop.width || crop.y > y || y >= crop.y + crop.height) {
+    return options.outsideImportance;
+  }
+  x = (x - crop.x) / crop.width;
+  y = (y - crop.y) / crop.height;
+  var px = abs(0.5 - x) * 2;
+  var py = abs(0.5 - y) * 2;
+  // Distance from edge
+  var dx = Math.max(px - 1.0 + options.edgeRadius, 0);
+  var dy = Math.max(py - 1.0 + options.edgeRadius, 0);
+  var d = (dx * dx + dy * dy) * options.edgeWeight;
+  var s = 1.41 - sqrt(px * px + py * py);
+  if (options.ruleOfThirds) {
+    s += (Math.max(0, s + d + 0.5) * 1.2) * (thirds(px) + thirds(py));
+  }
+  return s + d;
+}
+smartcrop.importance = importance;
+
+function skinColor(options, r, g, b) {
+  var mag = sqrt(r * r + g * g + b * b);
+  var rd = (r / mag - options.skinColor[0]);
+  var gd = (g / mag - options.skinColor[1]);
+  var bd = (b / mag - options.skinColor[2]);
+  var d = sqrt(rd * rd + gd * gd + bd * bd);
+  return 1 - d;
+}
+
+function analyse(options, input) {
+  var result = {};
+  var output = new ImgData(input.width, input.height);
+
+  edgeDetect(input, output);
+  skinDetect(options, input, output);
+  saturationDetect(options, input, output);
+  applyBoosts(options, output);
+
+  var scoreOutput = downSample(output, options.scoreDownSample);
+
+  var topScore = -Infinity;
+  var topCrop = null;
+  var crops = generateCrops(options, input.width, input.height);
+
+  for (var i = 0, iLen = crops.length; i < iLen; i++) {
+    var crop = crops[i];
+    crop.score = score(options, scoreOutput, crop);
+    if (crop.score.total > topScore) {
+      topCrop = crop;
+      topScore = crop.score.total;
+    }
+
+  }
+
+  result.topCrop = topCrop;
+
+  if (options.debug && topCrop) {
+    result.crops = crops;
+    result.debugOutput = output;
+    result.debugOptions = options;
+    // Create a copy which will not be adjusted by the post scaling of smartcrop.crop
+    result.debugTopCrop = extend({}, result.topCrop);
+  }
+  return result;
+}
 
+function ImgData(width, height, data) {
+  this.width = width;
+  this.height = height;
+  if (data) {
+    this.data = new Uint8ClampedArray(data);
+  }
+  else {
+    this.data = new Uint8ClampedArray(width * height * 4);
+  }
+}
+smartcrop.ImgData = ImgData;
+
+function downSample(input, factor) {
+  var idata = input.data;
+  var iwidth = input.width;
+  var width = Math.floor(input.width / factor);
+  var height = Math.floor(input.height / factor);
+  var output = new ImgData(width, height);
+  var data = output.data;
+  var ifactor2 = 1 / (factor * factor);
+  for (var y = 0; y < height; y++) {
+    for (var x = 0; x < width; x++) {
+      var i = (y * width + x) * 4;
+
+      var r = 0;
+      var g = 0;
+      var b = 0;
+      var a = 0;
+
+      var mr = 0;
+      var mg = 0;
+      var mb = 0;
+
+      for (var v = 0; v < factor; v++) {
+        for (var u = 0; u < factor; u++) {
+          var j = ((y * factor + v) * iwidth + (x * factor + u)) * 4;
+          r += idata[j];
+          g += idata[j + 1];
+          b += idata[j + 2];
+          a += idata[j + 3];
+          mr = Math.max(mr, idata[j]);
+          mg = Math.max(mg, idata[j + 1]);
+          mb = Math.max(mb, idata[j + 2]);
         }
-        score.total = (score.detail*options.detailWeight + score.skin*options.skinWeight + score.saturation*options.saturationWeight)/crop.width/crop.height;
-        return score;
+      }
+      // this is some funky magic to preserve detail a bit more for
+      // skin (r) and detail (g). Saturation (b) does not get this boost.
+      data[i] = r * ifactor2 * 0.5 + mr * 0.5;
+      data[i + 1] = g * ifactor2 * 0.7 + mg * 0.3;
+      data[i + 2] = b * ifactor2;
+      data[i + 3] = a * ifactor2;
+    }
+  }
+  return output;
+}
+smartcrop._downSample = downSample;
+
+function defaultCanvasFactory(w, h) {
+  var c = document.createElement('canvas');
+  c.width = w;
+  c.height = h;
+  return c;
+}
+
+function canvasImageOperations(canvasFactory) {
+  return {
+    // Takes imageInput as argument
+    // returns an object which has at least
+    // {width: n, height: n}
+    open: function(image) {
+      // Work around images scaled in css by drawing them onto a canvas
+      var w = image.naturalWidth || image.width;
+      var h = image.naturalHeight || image.height;
+      var c = canvasFactory(w, h);
+      var ctx = c.getContext('2d');
+      if (image.naturalWidth && (image.naturalWidth != image.width || image.naturalHeight != image.height)) {
+        c.width = image.naturalWidth;
+        c.height = image.naturalHeight;
+      }
+      else {
+        c.width = image.width;
+        c.height = image.height;
+      }
+      ctx.drawImage(image, 0, 0);
+      return smartcrop.Promise.resolve(c);
     },
-    importance: function(crop, x, y){
-        var options = this.options;
-
-        if (crop.x > x || x >= crop.x+crop.width || crop.y > y || y >= crop.y+crop.height) return options.outsideImportance;
-        x = (x-crop.x)/crop.width;
-        y = (y-crop.y)/crop.height;
-        var px = abs(0.5-x)*2,
-            py = abs(0.5-y)*2,
-            // distance from edge
-            dx = Math.max(px-1.0+options.edgeRadius, 0),
-            dy = Math.max(py-1.0+options.edgeRadius, 0),
-            d = (dx*dx+dy*dy)*options.edgeWeight;
-        var s = 1.41-sqrt(px*px+py*py);
-        if(options.ruleOfThirds){
-            s += (Math.max(0, s+d+0.5)*1.2)*(thirds(px)+thirds(py));
-        }
-        return s+d;
+    // Takes an image (as returned by open), and changes it's size by resampling
+    resample: function(image, width, height) {
+      return Promise.resolve(image).then(function(image) {
+        var c = canvasFactory(~~width, ~~height);
+        var ctx = c.getContext('2d');
+
+        ctx.drawImage(image, 0, 0, image.width, image.height, 0, 0, c.width, c.height);
+        return smartcrop.Promise.resolve(c);
+      });
     },
-    skinColor: function(r, g, b){
-        var mag = sqrt(r*r+g*g+b*b),
-            options = this.options,
-            rd = (r/mag-options.skinColor[0]),
-            gd = (g/mag-options.skinColor[1]),
-            bd = (b/mag-options.skinColor[2]),
-            d = sqrt(rd*rd+gd*gd+bd*bd);
-            return 1-d;
+    getData: function(image) {
+      return Promise.resolve(image).then(function(c) {
+        var ctx = c.getContext('2d');
+        var id = ctx.getImageData(0, 0, c.width, c.height);
+        return new ImgData(c.width, c.height, id.data);
+      });
     },
-    analyse: function(image){
-        var result = {},
-            options = this.options,
-            canvas = this.canvas(image.width, image.height),
-            ctx = canvas.getContext('2d');
-        ctx.drawImage(image, 0, 0);
-        var input = ctx.getImageData(0, 0, canvas.width, canvas.height),
-            output = ctx.getImageData(0, 0, canvas.width, canvas.height);
-        this.edgeDetect(input, output);
-        this.skinDetect(input, output);
-        this.saturationDetect(input, output);
-
-        var scoreCanvas = this.canvas(ceil(image.width/options.scoreDownSample), ceil(image.height/options.scoreDownSample)),
-            scoreCtx = scoreCanvas.getContext('2d');
-
-        ctx.putImageData(output, 0, 0);
-        scoreCtx.drawImage(canvas, 0, 0, canvas.width, canvas.height, 0, 0, scoreCanvas.width, scoreCanvas.height);
-
-        var scoreOutput = scoreCtx.getImageData(0, 0, scoreCanvas.width, scoreCanvas.height);
-
-        var topScore = -Infinity,
-            topCrop = null,
-            crops = this.crops(image);
-
-        for(var i = 0, i_len = crops.length; i < i_len; i++) {
-            var crop = crops[i];
-            crop.score = this.score(scoreOutput, crop);
-            if(crop.score.total > topScore){
-                topCrop = crop;
-                topScore = crop.score.total;
-            }
-
-        }
+  };
+}
+smartcrop._canvasImageOperations = canvasImageOperations;
 
-        result.crops = crops;
-        result.topCrop = topCrop;
-
-        if(options.debug && topCrop){
-            ctx.fillStyle = 'rgba(255, 0, 0, 0.1)';
-            ctx.fillRect(topCrop.x, topCrop.y, topCrop.width, topCrop.height);
-            for (var y = 0; y < output.height; y++) {
-                for (var x = 0; x < output.width; x++) {
-                    var p = (y * output.width + x) * 4;
-                    var importance = this.importance(topCrop, x, y);
-                    if (importance > 0) {
-                        output.data[p + 1] += importance * 32;
-                    }
-
-                    if (importance < 0) {
-                        output.data[p] += importance * -64;
-                    }
-                    output.data[p + 3] = 255;
-                }
-            }
-            ctx.putImageData(output, 0, 0);
-            ctx.strokeStyle = 'rgba(255, 0, 0, 0.8)';
-            ctx.strokeRect(topCrop.x, topCrop.y, topCrop.width, topCrop.height);
-            result.debugCanvas = canvas;
-        }
-        return result;
-    }
-};
+// Aliases and helpers
+var min = Math.min;
+var max = Math.max;
+var abs = Math.abs;
+var ceil = Math.ceil;
+var sqrt = Math.sqrt;
 
-// aliases and helpers
-var min = Math.min,
-    max = Math.max,
-    abs = Math.abs,
-    ceil = Math.ceil,
-    sqrt = Math.sqrt;
-
-function extend(o){
-    for(var i = 1, i_len = arguments.length; i < i_len; i++) {
-        var arg = arguments[i];
-        if(arg){
-            for(var name in arg){
-                o[name] = arg[name];
-            }
-        }
+function extend(o) {
+  for (var i = 1, iLen = arguments.length; i < iLen; i++) {
+    var arg = arguments[i];
+    if (arg) {
+      for (var name in arg) {
+        o[name] = arg[name];
+      }
     }
-    return o;
+  }
+  return o;
 }
 
-// gets value in the range of [0, 1] where 0 is the center of the pictures
+// Gets value in the range of [0, 1] where 0 is the center of the pictures
 // returns weight of rule of thirds [0, 1]
-function thirds(x){
-    x = ((x-(1/3)+1.0)%2.0*0.5-0.5)*16;
-    return Math.max(1.0-x*x, 0.0);
+function thirds(x) {
+  x = ((x - (1 / 3) + 1.0) % 2.0 * 0.5 - 0.5) * 16;
+  return Math.max(1.0 - x * x, 0.0);
 }
 
-function cie(r, g, b){
-    return 0.5126*b + 0.7152*g + 0.0722*r;
+function cie(r, g, b) {
+  return 0.5126 * b + 0.7152 * g + 0.0722 * r;
 }
 function sample(id, p) {
-    return cie(id[p], id[p+1], id[p+2]);
+  return cie(id[p], id[p + 1], id[p + 2]);
 }
-function saturation(r, g, b){
-    var maximum = max(r/255, g/255, b/255), minumum = min(r/255, g/255, b/255);
-    if(maximum === minumum){
-        return 0;
-    }
-    var l = (maximum + minumum) / 2,
-        d = maximum-minumum;
-    return l > 0.5 ? d/(2-maximum-minumum) : d/(maximum+minumum);
+function saturation(r, g, b) {
+  var maximum = max(r / 255, g / 255, b / 255);
+  var minumum = min(r / 255, g / 255, b / 255);
+
+  if (maximum === minumum) {
+    return 0;
+  }
+
+  var l = (maximum + minumum) / 2;
+  var d = maximum - minumum;
+
+  return l > 0.5 ? d / (2 - maximum - minumum) : d / (maximum + minumum);
 }
 
-// amd
-if (typeof define !== 'undefined' && define.amd) define(function(){return SmartCrop;});
-//common js
-if (typeof exports !== 'undefined') exports.SmartCrop = SmartCrop;
-// browser
-else if (typeof navigator !== 'undefined') window.SmartCrop = SmartCrop;
-// nodejs
+// Amd
+if (typeof define !== 'undefined' && define.amd) define(function() {return smartcrop;});
+// Common js
+if (typeof exports !== 'undefined') exports.smartcrop = smartcrop;
+// Browser
+else if (typeof navigator !== 'undefined') window.SmartCrop = window.smartcrop = smartcrop;
+// Nodejs
 if (typeof module !== 'undefined') {
-    module.exports = SmartCrop;
+  module.exports = smartcrop;
 }
-})();
+})();

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smartcrop-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 1.1.0
 platform: ruby
 authors:
 - Mohammed Sadiq
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-02-03 00:00:00.000000000 Z
+date: 2016-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler