blueimp-load-image-rails 1.8.0 → 1.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8133cf8c64435ad3168dd29b095059df333d32a3
-  data.tar.gz: 5f1f05730295c1ffdd58a47ebe3693e2399f25a6
+  metadata.gz: fbb9643e780934f976c80f31783a97f58ea7e81a
+  data.tar.gz: 1465e3a4a2d1692d513325f1e3975127e19e021d
 SHA512:
-  metadata.gz: b27c7863a034c4bd3de0b52279f0db569800586daf10db97cc5ff63102ce7f5215883650ac0db4c01b50251e6b2d065df4d68f0fc0bb6516f230bc217b56a25b
-  data.tar.gz: 647256f48a2a63c9a90ad98d06bd7e6fb42eab3b2f8d8becaf54362788837f46a4852a314ff321eb4c1a850c420284e8c473f1a280e6f4bb1aa196bb51c534db
+  metadata.gz: 35b880d2320a6c96ed59c5a72719fb0797ad289a0b3c398879eb06654ee7c0b07c59b8cd9bd7999ec2be65ceac216b343a64b4f157fdb1864ce31d9ba4ede4a9
+  data.tar.gz: 98e7eff6674aff85875affcd77c9a1bba150d78dfff2aff5e165d4aaf14bd583c86b077ae85235e3b0258812500cabba4f000ddfd4e53f91d4ef5e943e6da1cd

data/{vendor → app}/assets/javascripts/blueimp-load-image.js

@@ -1,5 +1,6 @@
 //= require load-image
 //= require load-image-ios
+//= require load-image-orientation
 //= require load-image-meta
 //= require load-image-exif
 //= require load-image-exif-map

data/{vendor → app}/assets/javascripts/load-image-ios.js

@@ -1,5 +1,5 @@
 /*
- * JavaScript Load Image iOS scaling fixes 1.0.0
+ * JavaScript Load Image iOS scaling fixes 1.0.3
  * https://github.com/blueimp/JavaScript-Load-Image
  *
  * Copyright 2013, Sebastian Tschan
@@ -53,22 +53,26 @@
     };
 
     // Detects vertical squash in JPEG images:
-    loadImage.detectVerticalSquash = function (img, correctedHeight) {
-        var canvas = document.createElement('canvas'),
+    loadImage.detectVerticalSquash = function (img, subsampled) {
+        var naturalHeight = img.naturalHeight || img.height,
+            canvas = document.createElement('canvas'),
             context = canvas.getContext('2d'),
             data,
             sy,
             ey,
             py,
             alpha;
+        if (subsampled) {
+            naturalHeight /= 2;
+        }
         canvas.width = 1;
-        canvas.height = correctedHeight;
+        canvas.height = naturalHeight;
         context.drawImage(img, 0, 0);
-        data = context.getImageData(0, 0, 1, correctedHeight).data;
+        data = context.getImageData(0, 0, 1, naturalHeight).data;
         // search image edge pixel position in case it is squashed vertically:
         sy = 0;
-        ey = correctedHeight;
-        py = correctedHeight;
+        ey = naturalHeight;
+        py = naturalHeight;
         while (py > sy) {
             alpha = data[(py - 1) * 4 + 3];
             if (alpha === 0) {
@@ -78,7 +82,7 @@
             }
             py = (ey + sy) >> 1;
         }
-        return (py / correctedHeight) || 1;
+        return (py / naturalHeight) || 1;
     };
 
     // Renders image to canvas while working around iOS image scaling bugs:
@@ -100,20 +104,23 @@
                 tmpCanvas = document.createElement('canvas'),
                 tileSize = 1024,
                 tmpContext = tmpCanvas.getContext('2d'),
-                subSampled,
+                subsampled,
                 vertSquashRatio,
                 tileX,
                 tileY;
             tmpCanvas.width = tileSize;
             tmpCanvas.height = tileSize;
             context.save();
-            subSampled = loadImage.detectSubsampling(img);
-            if (subSampled) {
+            subsampled = loadImage.detectSubsampling(img);
+            if (subsampled) {
+                sourceX /= 2;
+                sourceY /= 2;
                 sourceWidth /= 2;
                 sourceHeight /= 2;
             }
-            vertSquashRatio = loadImage.detectVerticalSquash(img, sourceHeight);
-            if (subSampled && vertSquashRatio !== 1) {
+            vertSquashRatio = loadImage.detectVerticalSquash(img, subsampled);
+            if (subsampled || vertSquashRatio !== 1) {
+                sourceY *= vertSquashRatio;
                 destWidth = Math.ceil(tileSize * destWidth / sourceWidth);
                 destHeight = Math.ceil(
                     tileSize * destHeight / sourceHeight / vertSquashRatio

data/app/assets/javascripts/load-image-orientation.js

@@ -0,0 +1,159 @@
+/*
+ * JavaScript Load Image Orientation 1.0.0
+ * https://github.com/blueimp/JavaScript-Load-Image
+ *
+ * Copyright 2013, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ */
+
+/*global define, window */
+
+(function (factory) {
+    'use strict';
+    if (typeof define === 'function' && define.amd) {
+        // Register as an anonymous AMD module:
+        define(['load-image'], factory);
+    } else {
+        // Browser globals:
+        factory(window.loadImage);
+    }
+}(function (loadImage) {
+    'use strict';
+
+    var originalHasCanvasOptionMethod = loadImage.hasCanvasOption;
+
+    // This method is used to determine if the target image
+    // should be a canvas element:
+    loadImage.hasCanvasOption = function (options) {
+        return originalHasCanvasOptionMethod(options) || options.orientation;
+    };
+
+    // Transform image orientation based on
+    // the given EXIF orientation option:
+    loadImage.transformCoordinates = function (canvas, options) {
+        var ctx = canvas.getContext('2d'),
+            width = canvas.width,
+            height = canvas.height,
+            orientation = options.orientation;
+        if (!orientation) {
+            return;
+        }
+        if (orientation > 4) {
+            canvas.width = height;
+            canvas.height = width;
+        }
+        switch (orientation) {
+        case 2:
+            // horizontal flip
+            ctx.translate(width, 0);
+            ctx.scale(-1, 1);
+            break;
+        case 3:
+            // 180° rotate left
+            ctx.translate(width, height);
+            ctx.rotate(Math.PI);
+            break;
+        case 4:
+            // vertical flip
+            ctx.translate(0, height);
+            ctx.scale(1, -1);
+            break;
+        case 5:
+            // vertical flip + 90 rotate right
+            ctx.rotate(0.5 * Math.PI);
+            ctx.scale(1, -1);
+            break;
+        case 6:
+            // 90° rotate right
+            ctx.rotate(0.5 * Math.PI);
+            ctx.translate(0, -height);
+            break;
+        case 7:
+            // horizontal flip + 90 rotate right
+            ctx.rotate(0.5 * Math.PI);
+            ctx.translate(width, -height);
+            ctx.scale(-1, 1);
+            break;
+        case 8:
+            // 90° rotate left
+            ctx.rotate(-0.5 * Math.PI);
+            ctx.translate(-width, 0);
+            break;
+        }
+    };
+
+    // Transforms coordinate and dimension options
+    // based on the given orientation option:
+    loadImage.getTransformedOptions = function (options) {
+        if (!options.orientation || options.orientation === 1) {
+            return options;
+        }
+        var newOptions = {},
+            i;
+        for (i in options) {
+            if (options.hasOwnProperty(i)) {
+                newOptions[i] = options[i];
+            }
+        }
+        switch (options.orientation) {
+        case 2:
+            // horizontal flip
+            newOptions.left = options.right;
+            newOptions.right = options.left;
+            break;
+        case 3:
+            // 180° rotate left
+            newOptions.left = options.right;
+            newOptions.top = options.bottom;
+            newOptions.right = options.left;
+            newOptions.bottom = options.top;
+            break;
+        case 4:
+            // vertical flip
+            newOptions.top = options.bottom;
+            newOptions.bottom = options.top;
+            break;
+        case 5:
+            // vertical flip + 90 rotate right
+            newOptions.left = options.top;
+            newOptions.top = options.left;
+            newOptions.right = options.bottom;
+            newOptions.bottom = options.right;
+            break;
+        case 6:
+            // 90° rotate right
+            newOptions.left = options.top;
+            newOptions.top = options.right;
+            newOptions.right = options.bottom;
+            newOptions.bottom = options.left;
+            break;
+        case 7:
+            // horizontal flip + 90 rotate right
+            newOptions.left = options.bottom;
+            newOptions.top = options.right;
+            newOptions.right = options.top;
+            newOptions.bottom = options.left;
+            break;
+        case 8:
+            // 90° rotate left
+            newOptions.left = options.bottom;
+            newOptions.top = options.left;
+            newOptions.right = options.top;
+            newOptions.bottom = options.right;
+            break;
+        }
+        if (options.orientation > 4) {
+            newOptions.maxWidth = options.maxHeight;
+            newOptions.maxHeight = options.maxWidth;
+            newOptions.minWidth = options.minHeight;
+            newOptions.minHeight = options.minWidth;
+            newOptions.sourceWidth = options.sourceHeight;
+            newOptions.sourceHeight = options.sourceWidth;
+        }
+        return newOptions;
+    };
+
+}));

data/{vendor → app}/assets/javascripts/load-image.js

@@ -1,5 +1,5 @@
 /*
- * JavaScript Load Image 1.8.0
+ * JavaScript Load Image 1.9.0
  * https://github.com/blueimp/JavaScript-Load-Image
  *
  * Copyright 2011, Sebastian Tschan
@@ -72,53 +72,17 @@
         return Object.prototype.toString.call(obj) === '[object ' + type + ']';
     };
 
-    // Transform image orientation based on the given EXIF orientation data:
-    loadImage.transformCoordinates = function (canvas, orientation) {
-        var ctx = canvas.getContext('2d'),
-            width = canvas.width,
-            height = canvas.height;
-        if (orientation > 4) {
-            canvas.width = height;
-            canvas.height = width;
-        }
-        switch (orientation) {
-        case 2:
-            // horizontal flip
-            ctx.translate(width, 0);
-            ctx.scale(-1, 1);
-            break;
-        case 3:
-            // 180 rotate left
-            ctx.translate(width, height);
-            ctx.rotate(Math.PI);
-            break;
-        case 4:
-            // vertical flip
-            ctx.translate(0, height);
-            ctx.scale(1, -1);
-            break;
-        case 5:
-            // vertical flip + 90 rotate right
-            ctx.rotate(0.5 * Math.PI);
-            ctx.scale(1, -1);
-            break;
-        case 6:
-            // 90 rotate right
-            ctx.rotate(0.5 * Math.PI);
-            ctx.translate(0, -height);
-            break;
-        case 7:
-            // horizontal flip + 90 rotate right
-            ctx.rotate(0.5 * Math.PI);
-            ctx.translate(width, -height);
-            ctx.scale(-1, 1);
-            break;
-        case 8:
-            // 90 rotate left
-            ctx.rotate(-0.5 * Math.PI);
-            ctx.translate(-width, 0);
-            break;
-        }
+    // Transform image coordinates, allows to override e.g.
+    // the canvas orientation based on the orientation option,
+    // gets canvas, options passed as arguments:
+    loadImage.transformCoordinates = function () {
+        return;
+    };
+
+    // Returns transformed options, allows to override e.g.
+    // coordinate and dimension options based on the orientation:
+    loadImage.getTransformedOptions = function (options) {
+        return options;
     };
 
     // Canvas render method, allows to override the
@@ -149,31 +113,35 @@
         return canvas;
     };
 
-    // Scales the given image (img or canvas HTML element)
+    // This method is used to determine if the target image
+    // should be a canvas element:
+    loadImage.hasCanvasOption = function (options) {
+        return options.canvas || options.crop;
+    };
+
+    // Scales and/or crops the given image (img or canvas HTML element)
     // using the given options.
     // Returns a canvas object if the browser supports canvas
-    // and the canvas or crop option is true or a canvas object
-    // is passed as image, else the scaled image:
+    // and the hasCanvasOption method returns true or a canvas
+    // object is passed as image, else the scaled image:
     loadImage.scale = function (img, options) {
         options = options || {};
         var canvas = document.createElement('canvas'),
             useCanvas = img.getContext ||
-                ((options.canvas || options.crop || options.orientation) &&
-                    canvas.getContext),
-            width = img.width,
-            height = img.height,
-            sourceWidth = width,
-            sourceHeight = height,
-            sourceX = 0,
-            sourceY = 0,
-            destX = 0,
-            destY = 0,
+                (loadImage.hasCanvasOption(options) && canvas.getContext),
+            width = img.naturalWidth || img.width,
+            height = img.naturalHeight || img.height,
+            destWidth = width,
+            destHeight = height,
             maxWidth,
             maxHeight,
             minWidth,
             minHeight,
-            destWidth,
-            destHeight,
+            sourceWidth,
+            sourceHeight,
+            sourceX,
+            sourceY,
+            tmp,
             scaleUp = function () {
                 var scale = Math.max(
                     (minWidth || destWidth) / destWidth,
@@ -194,34 +162,53 @@
                     destHeight = Math.ceil(destHeight * scale);
                 }
             };
-        if (useCanvas && options.orientation > 4) {
-            maxWidth = options.maxHeight;
-            maxHeight = options.maxWidth;
-            minWidth = options.minHeight;
-            minHeight = options.minWidth;
-        } else {
-            maxWidth = options.maxWidth;
-            maxHeight = options.maxHeight;
-            minWidth = options.minWidth;
-            minHeight = options.minHeight;
+        if (useCanvas) {
+            options = loadImage.getTransformedOptions(options);
+            sourceX = options.left || 0;
+            sourceY = options.top || 0;
+            if (options.sourceWidth) {
+                sourceWidth = options.sourceWidth;
+                if (options.right !== undefined && options.left === undefined) {
+                    sourceX = width - sourceWidth - options.right;
+                }
+            } else {
+                sourceWidth = width - sourceX - (options.right || 0);
+            }
+            if (options.sourceHeight) {
+                sourceHeight = options.sourceHeight;
+                if (options.bottom !== undefined && options.top === undefined) {
+                    sourceY = height - sourceHeight - options.bottom;
+                }
+            } else {
+                sourceHeight = height - sourceY - (options.bottom || 0);
+            }
+            destWidth = sourceWidth;
+            destHeight = sourceHeight;
         }
+        maxWidth = options.maxWidth;
+        maxHeight = options.maxHeight;
+        minWidth = options.minWidth;
+        minHeight = options.minHeight;
         if (useCanvas && maxWidth && maxHeight && options.crop) {
             destWidth = maxWidth;
             destHeight = maxHeight;
-            if (width / height < maxWidth / maxHeight) {
-                sourceHeight = maxHeight * width / maxWidth;
-                sourceY = (height - sourceHeight) / 2;
-            } else {
-                sourceWidth = maxWidth * height / maxHeight;
-                sourceX = (width - sourceWidth) / 2;
+            tmp = sourceWidth / sourceHeight - maxWidth / maxHeight;
+            if (tmp < 0) {
+                sourceHeight = maxHeight * sourceWidth / maxWidth;
+                if (options.top === undefined && options.bottom === undefined) {
+                    sourceY = (height - sourceHeight) / 2;
+                }
+            } else if (tmp > 0) {
+                sourceWidth = maxWidth * sourceHeight / maxHeight;
+                if (options.left === undefined && options.right === undefined) {
+                    sourceX = (width - sourceWidth) / 2;
+                }
             }
         } else {
             if (options.contain || options.cover) {
                 minWidth = maxWidth = maxWidth || minWidth;
                 minHeight = maxHeight = maxHeight || minHeight;
             }
-            destWidth = width;
-            destHeight = height;
             if (options.cover) {
                 scaleDown();
                 scaleUp();
@@ -235,7 +222,7 @@
             canvas.height = destHeight;
             loadImage.transformCoordinates(
                 canvas,
-                options.orientation
+                options
             );
             return loadImage.renderImageToCanvas(
                 canvas,
@@ -244,8 +231,8 @@
                 sourceY,
                 sourceWidth,
                 sourceHeight,
-                destX,
-                destY,
+                0,
+                0,
                 destWidth,
                 destHeight
             );

data/lib/blueimp-load-image-rails/version.rb

@@ -5,7 +5,7 @@ module Blueimp
       class Version
         class << self
           def to_s
-            "1.8.0"
+            "1.9.1"
           end
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: blueimp-load-image-rails
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 1.9.1
 platform: ruby
 authors:
 - Sebastian Tschan
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-11 00:00:00.000000000 Z
+date: 2013-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -42,12 +42,13 @@ extra_rdoc_files: []
 files:
 - lib/blueimp-load-image-rails.rb
 - lib/blueimp-load-image-rails/version.rb
-- vendor/assets/javascripts/blueimp-load-image.js
-- vendor/assets/javascripts/load-image-exif-map.js
-- vendor/assets/javascripts/load-image-exif.js
-- vendor/assets/javascripts/load-image-ios.js
-- vendor/assets/javascripts/load-image-meta.js
-- vendor/assets/javascripts/load-image.js
+- app/assets/javascripts/blueimp-load-image.js
+- app/assets/javascripts/load-image-exif-map.js
+- app/assets/javascripts/load-image-exif.js
+- app/assets/javascripts/load-image-ios.js
+- app/assets/javascripts/load-image-meta.js
+- app/assets/javascripts/load-image-orientation.js
+- app/assets/javascripts/load-image.js
 homepage: https://github.com/blueimp/JavaScript-Load-Image
 licenses:
 - MIT