glur 1.0.0 → 1.1.2

package/CHANGELOG.md

@@ -0,0 +1,29 @@
+1.1.2 / 2016-05-05
+------------------
+
+- Fixed typo in RGBA blur math equations (regression from 1.1.0),
+  thanks to @tonykwok.
+
+
+1.1.1 / 2015-11-10
+------------------
+
+- Fixed line buffer size for mono blur when vertical images used.
+
+
+1.1.0 / 2015-11-05
+------------------
+
+- Changed interpolation fn to one from Intel's whitepaper.
+
+
+1.0.1 / 2015-11-04
+------------------
+
+- Maintenance: general cleanup, demo improvements.
+
+
+1.0.0 / 2015-11-02
+------------------
+
+- First release.

package/README.md

@@ -1,12 +1,14 @@
 glur
 ====
 
+[![Build Status](https://travis-ci.org/nodeca/glur.svg?branch=master)](https://travis-ci.org/nodeca/glur)
 [![NPM version](https://img.shields.io/npm/v/glur.svg)](https://www.npmjs.org/package/glur)
 
 > Fast Gaussian Blur in pure JavaScript, via IIR filer. Speed does not depend on
 > blur radius.
 
-__[Demo](http://nodeca.github.io/glur/demo)__
+__[demo 1](http://nodeca.github.io/glur/demo)__,
+__[demo 2](http://nodeca.github.io/glur/demo/mono16.html)__.
 
 
 Install
@@ -32,13 +34,19 @@ input data is grayscale Uint16Array. Can be useful to calculate unsharp mask via
 brightness/ligthness channel.
 
 
+Authors
+-------
+
+- Andrey Tupitsin [@anrd83](https://github.com/andr83)
+- Alexander Rodin [@a-rodin](https://github.com/a-rodin)
+- Vitaly Puzrin [@puzrin](https://github.com/puzrin)
+
+
 References
 ----------
 
 - [IIR Gaussian Blur Filter Implementation using Intel® Advanced Vector Extensions](https://software.intel.com/en-us/articles/iir-gaussian-blur-filter-implementation-using-intel-advanced-vector-extensions) -
   very good article with technical details for programmers.
-- [Быстрое размытие по Гауссу](http://habrahabr.ru/post/151157/) (RUS) - alternative
-  with more simple aproximation function (we use it here in glur).
 
 
 Licence

package/index.js

@@ -1,168 +1,196 @@
-var gaussCoef = function (sigma) {
-  var sigma_inv_4 = sigma * sigma;
-  sigma_inv_4 = 1.0 / (sigma_inv_4 * sigma_inv_4);
+// Calculate Gaussian blur of an image using IIR filter
+// The method is taken from Intel's white paper and code example attached to it:
+// https://software.intel.com/en-us/articles/iir-gaussian-blur-filter
+// -implementation-using-intel-advanced-vector-extensions
 
-  var coef_A = sigma_inv_4 * (sigma * (sigma * (sigma * 1.1442707 + 0.0130625) - 0.7500910) + 0.2546730);
-  var coef_W = sigma_inv_4 * (sigma * (sigma * (sigma * 1.3642870 + 0.0088755) - 0.3255340) + 0.3016210);
-  var coef_B = sigma_inv_4 * (sigma * (sigma * (sigma * 1.2397166 - 0.0001644) - 0.6363580) - 0.0536068);
+var a0, a1, a2, a3, b1, b2, left_corner, right_corner;
 
-  var z0_abs = Math.exp(coef_A);
-
-  var z0_real = z0_abs * Math.cos(coef_W);
-  var z0_im = z0_abs * Math.sin(coef_W);
-  var z2 = Math.exp(coef_B);
-
-  var z0_abs_2 = z0_abs * z0_abs;
-
-  var a2 = 1.0 / (z2 * z0_abs_2),
-      a0 = (z0_abs_2 + 2 * z0_real * z2) * a2,
-      a1 = -(2 * z0_real + z2) * a2,
-      b0 = 1.0 - (a0 + a1 + a2);
-
-  return new Float32Array([ b0, a0, a1, a2 ]);
-};
-
-
-var convolveRGBA = function (src, out, tmp, coeff, width, height) {
-  var x, y, rgba, r, g, b, a, out_index, y_offset, x_offset;
-  var r0, g0, b0, a0, r1, g1, b1, a1, r2, g2, b2, a2;
-
-  var coeff_b0 = coeff[0];
-  var coeff_a0 = coeff[1];
-  var coeff_a1 = coeff[2];
-  var coeff_a2 = coeff[3];
-
-  // console.time('convolve');
-  for (y = 0; y < height; y++) {
-    y_offset = y * width;
-
-    rgba = src[y_offset];
-
-    r = rgba & 0xff;
-    g = (rgba >> 8) & 0xff;
-    b = (rgba >> 16) & 0xff;
-    a = (rgba >> 24) & 0xff;
-
-    r0 = r;
-    g0 = g;
-    b0 = b;
-    a0 = a;
-
-    r1 = r0;
-    g1 = g0;
-    b1 = b0;
-    a1 = a0;
-
-    r2 = r1;
-    g2 = g1;
-    b2 = b1;
-    a2 = a1;
-
-    x_offset = 0;
-
-    for (x = 0; x < width; x++) {
-      rgba = src[y_offset + x];
-
-      r = rgba & 0xff;
-      g = (rgba >> 8) & 0xff;
-      b = (rgba >> 16) & 0xff;
-      a = (rgba >> 24) & 0xff;
-
-      r = coeff_b0 * r + (coeff_a0 * r0 + coeff_a1 * r1 + coeff_a2 * r2);
-      g = coeff_b0 * g + (coeff_a0 * g0 + coeff_a1 * g1 + coeff_a2 * g2);
-      b = coeff_b0 * b + (coeff_a0 * b0 + coeff_a1 * b1 + coeff_a2 * b2);
-      a = coeff_b0 * a + (coeff_a0 * a0 + coeff_a1 * a1 + coeff_a2 * a2);
-
-      r2 = r1;
-      g2 = g1;
-      b2 = b1;
-      a2 = a1;
-
-      r1 = r0;
-      g1 = g0;
-      b1 = b0;
-      a1 = a0;
-
-      r0 = r;
-      g0 = g;
-      b0 = b;
-      a0 = a;
-
-      tmp[x_offset] = r;
-      tmp[x_offset + 1] = g;
-      tmp[x_offset + 2] = b;
-      tmp[x_offset + 3] = a;
+function gaussCoef(sigma) {
+  if (sigma < 0.5) {
+    sigma = 0.5;
+  }
 
-      x_offset += 4;
+  var a = Math.exp(0.726 * 0.726) / sigma,
+      g1 = Math.exp(-a),
+      g2 = Math.exp(-2 * a),
+      k = (1 - g1) * (1 - g1) / (1 + 2 * a * g1 - g2);
+
+  a0 = k;
+  a1 = k * (a - 1) * g1;
+  a2 = k * (a + 1) * g1;
+  a3 = -k * g2;
+  b1 = 2 * g1;
+  b2 = -g2;
+  left_corner = (a0 + a1) / (1 - b1 - b2);
+  right_corner = (a2 + a3) / (1 - b1 - b2);
+
+  // Attempt to force type to FP32.
+  return new Float32Array([ a0, a1, a2, a3, b1, b2, left_corner, right_corner ]);
+}
+
+function convolveRGBA(src, out, line, coeff, width, height) {
+  // takes src image and writes the blurred and transposed result into out
+
+  var rgba;
+  var prev_src_r, prev_src_g, prev_src_b, prev_src_a;
+  var curr_src_r, curr_src_g, curr_src_b, curr_src_a;
+  var curr_out_r, curr_out_g, curr_out_b, curr_out_a;
+  var prev_out_r, prev_out_g, prev_out_b, prev_out_a;
+  var prev_prev_out_r, prev_prev_out_g, prev_prev_out_b, prev_prev_out_a;
+
+  var src_index, out_index, line_index;
+  var i, j;
+  var coeff_a0, coeff_a1, coeff_b1, coeff_b2;
+
+  for (i = 0; i < height; i++) {
+    src_index = i * width;
+    out_index = i;
+    line_index = 0;
+
+    // left to right
+    rgba = src[src_index];
+
+    prev_src_r = rgba & 0xff;
+    prev_src_g = (rgba >> 8) & 0xff;
+    prev_src_b = (rgba >> 16) & 0xff;
+    prev_src_a = (rgba >> 24) & 0xff;
+
+    prev_prev_out_r = prev_src_r * coeff[6];
+    prev_prev_out_g = prev_src_g * coeff[6];
+    prev_prev_out_b = prev_src_b * coeff[6];
+    prev_prev_out_a = prev_src_a * coeff[6];
+
+    prev_out_r = prev_prev_out_r;
+    prev_out_g = prev_prev_out_g;
+    prev_out_b = prev_prev_out_b;
+    prev_out_a = prev_prev_out_a;
+
+    coeff_a0 = coeff[0];
+    coeff_a1 = coeff[1];
+    coeff_b1 = coeff[4];
+    coeff_b2 = coeff[5];
+
+    for (j = 0; j < width; j++) {
+      rgba = src[src_index];
+      curr_src_r = rgba & 0xff;
+      curr_src_g = (rgba >> 8) & 0xff;
+      curr_src_b = (rgba >> 16) & 0xff;
+      curr_src_a = (rgba >> 24) & 0xff;
+
+      curr_out_r = curr_src_r * coeff_a0 + prev_src_r * coeff_a1 + prev_out_r * coeff_b1 + prev_prev_out_r * coeff_b2;
+      curr_out_g = curr_src_g * coeff_a0 + prev_src_g * coeff_a1 + prev_out_g * coeff_b1 + prev_prev_out_g * coeff_b2;
+      curr_out_b = curr_src_b * coeff_a0 + prev_src_b * coeff_a1 + prev_out_b * coeff_b1 + prev_prev_out_b * coeff_b2;
+      curr_out_a = curr_src_a * coeff_a0 + prev_src_a * coeff_a1 + prev_out_a * coeff_b1 + prev_prev_out_a * coeff_b2;
+
+      prev_prev_out_r = prev_out_r;
+      prev_prev_out_g = prev_out_g;
+      prev_prev_out_b = prev_out_b;
+      prev_prev_out_a = prev_out_a;
+
+      prev_out_r = curr_out_r;
+      prev_out_g = curr_out_g;
+      prev_out_b = curr_out_b;
+      prev_out_a = curr_out_a;
+
+      prev_src_r = curr_src_r;
+      prev_src_g = curr_src_g;
+      prev_src_b = curr_src_b;
+      prev_src_a = curr_src_a;
+
+      line[line_index] = prev_out_r;
+      line[line_index + 1] = prev_out_g;
+      line[line_index + 2] = prev_out_b;
+      line[line_index + 3] = prev_out_a;
+      line_index += 4;
+      src_index++;
     }
 
-    r0 = r;
-    g0 = g;
-    b0 = b;
-    a0 = a;
-
-    r1 = r0;
-    g1 = g0;
-    b1 = b0;
-    a1 = a0;
-
-    r2 = r1;
-    g2 = g1;
-    b2 = b1;
-    a2 = a1;
-
-    out_index = y + height * width;
-
-    for (x = width - 1; x >= 0; x--) {
-      x_offset -= 4;
-
-      r = tmp[x_offset];
-      g = tmp[x_offset + 1];
-      b = tmp[x_offset + 2];
-      a = tmp[x_offset + 3];
-
-      r = coeff_b0 * r + (coeff_a0 * r0 + coeff_a1 * r1 + coeff_a2 * r2);
-      g = coeff_b0 * g + (coeff_a0 * g0 + coeff_a1 * g1 + coeff_a2 * g2);
-      b = coeff_b0 * b + (coeff_a0 * b0 + coeff_a1 * b1 + coeff_a2 * b2);
-      a = coeff_b0 * a + (coeff_a0 * a0 + coeff_a1 * a1 + coeff_a2 * a2);
-
-      r2 = r1;
-      g2 = g1;
-      b2 = b1;
-      a2 = a1;
-
-      r1 = r0;
-      g1 = g0;
-      b1 = b0;
-      a1 = a0;
-
-      r0 = r;
-      g0 = g;
-      b0 = b;
-      a0 = a;
-
-      r = (r |0) & 0xff;
-      g = (g |0) & 0xff;
-      b = (b |0) & 0xff;
-      a = (a |0) & 0xff;
-
+    src_index--;
+    line_index -= 4;
+    out_index += height * (width - 1);
+
+    // right to left
+    rgba = src[src_index];
+
+    prev_src_r = rgba & 0xff;
+    prev_src_g = (rgba >> 8) & 0xff;
+    prev_src_b = (rgba >> 16) & 0xff;
+    prev_src_a = (rgba >> 24) & 0xff;
+
+    prev_prev_out_r = prev_src_r * coeff[7];
+    prev_prev_out_g = prev_src_g * coeff[7];
+    prev_prev_out_b = prev_src_b * coeff[7];
+    prev_prev_out_a = prev_src_a * coeff[7];
+
+    prev_out_r = prev_prev_out_r;
+    prev_out_g = prev_prev_out_g;
+    prev_out_b = prev_prev_out_b;
+    prev_out_a = prev_prev_out_a;
+
+    curr_src_r = prev_src_r;
+    curr_src_g = prev_src_g;
+    curr_src_b = prev_src_b;
+    curr_src_a = prev_src_a;
+
+    coeff_a0 = coeff[2];
+    coeff_a1 = coeff[3];
+
+    for (j = width - 1; j >= 0; j--) {
+      curr_out_r = curr_src_r * coeff_a0 + prev_src_r * coeff_a1 + prev_out_r * coeff_b1 + prev_prev_out_r * coeff_b2;
+      curr_out_g = curr_src_g * coeff_a0 + prev_src_g * coeff_a1 + prev_out_g * coeff_b1 + prev_prev_out_g * coeff_b2;
+      curr_out_b = curr_src_b * coeff_a0 + prev_src_b * coeff_a1 + prev_out_b * coeff_b1 + prev_prev_out_b * coeff_b2;
+      curr_out_a = curr_src_a * coeff_a0 + prev_src_a * coeff_a1 + prev_out_a * coeff_b1 + prev_prev_out_a * coeff_b2;
+
+      prev_prev_out_r = prev_out_r;
+      prev_prev_out_g = prev_out_g;
+      prev_prev_out_b = prev_out_b;
+      prev_prev_out_a = prev_out_a;
+
+      prev_out_r = curr_out_r;
+      prev_out_g = curr_out_g;
+      prev_out_b = curr_out_b;
+      prev_out_a = curr_out_a;
+
+      prev_src_r = curr_src_r;
+      prev_src_g = curr_src_g;
+      prev_src_b = curr_src_b;
+      prev_src_a = curr_src_a;
+
+      rgba = src[src_index];
+      curr_src_r = rgba & 0xff;
+      curr_src_g = (rgba >> 8) & 0xff;
+      curr_src_b = (rgba >> 16) & 0xff;
+      curr_src_a = (rgba >> 24) & 0xff;
+
+      rgba = ((line[line_index] + prev_out_r) << 0) +
+        ((line[line_index + 1] + prev_out_g) << 8) +
+        ((line[line_index + 2] + prev_out_b) << 16) +
+        ((line[line_index + 3] + prev_out_a) << 24);
+
+      out[out_index] = rgba;
+
+      src_index--;
+      line_index -= 4;
       out_index -= height;
-      out[out_index] = (a << 24) | (b << 16) | (g << 8) | r;
     }
   }
-  // console.timeEnd('convolve');
-};
+}
+
+
+function blurRGBA(src, width, height, radius) {
+  // Quick exit on zero radius
+  if (!radius) { return; }
 
+  // Unify input data type, to keep convolver calls isomorphic
+  var src32 = new Uint32Array(src.buffer);
 
-var blurRGBA = function (src, width, height, radius) {
-  var src32    = new Uint32Array(src.buffer),
-      out      = new Uint32Array(width * height),
-      tmp_line = new Float32Array(width * 4);
+  var out      = new Uint32Array(src32.length),
+      tmp_line = new Float32Array(Math.max(width, height) * 4);
 
   var coeff = gaussCoef(radius);
 
   convolveRGBA(src32, out, tmp_line, coeff, width, height, radius);
   convolveRGBA(out, src32, tmp_line, coeff, height, width, radius);
-};
+}
 
 module.exports = blurRGBA;

package/mono16.js

@@ -1,90 +1,119 @@
-var gaussCoef = function (sigma) {
-  var sigma_inv_4 = sigma * sigma;
-  sigma_inv_4 = 1.0 / (sigma_inv_4 * sigma_inv_4);
+// Calculate Gaussian blur of an image using IIR filter
+// The method is taken from Intel's white paper and code example attached to it:
+// https://software.intel.com/en-us/articles/iir-gaussian-blur-filter
+// -implementation-using-intel-advanced-vector-extensions
 
-  var coef_A = sigma_inv_4 * (sigma * (sigma * (sigma * 1.1442707 + 0.0130625) - 0.7500910) + 0.2546730);
-  var coef_W = sigma_inv_4 * (sigma * (sigma * (sigma * 1.3642870 + 0.0088755) - 0.3255340) + 0.3016210);
-  var coef_B = sigma_inv_4 * (sigma * (sigma * (sigma * 1.2397166 - 0.0001644) - 0.6363580) - 0.0536068);
+var a0, a1, a2, a3, b1, b2, left_corner, right_corner;
 
-  var z0_abs = Math.exp(coef_A);
-
-  var z0_real = z0_abs * Math.cos(coef_W);
-  var z0_im = z0_abs * Math.sin(coef_W);
-  var z2 = Math.exp(coef_B);
-
-  var z0_abs_2 = z0_abs * z0_abs;
-
-  var a2 = 1.0 / (z2 * z0_abs_2),
-      a0 = (z0_abs_2 + 2 * z0_real * z2) * a2,
-      a1 = -(2 * z0_real + z2) * a2,
-      b0 = 1.0 - (a0 + a1 + a2);
-
-  return new Float32Array([ b0, a0, a1, a2 ]);
-};
-
-
-var convolveMono16 = function (src, out, tmp, coeff, width, height) {
-  var x, y, out_index, y_offset, x_offset;
-  var v, v0, v1, v2;
-
-  var coeff_b0 = coeff[0];
-  var coeff_a0 = coeff[1];
-  var coeff_a1 = coeff[2];
-  var coeff_a2 = coeff[3];
-
-  for (y = 0; y < height; y++) {
-    y_offset = y * width;
-
-    v = src[y_offset];
-    v0 = v;
-    v1 = v0;
-    v2 = v1;
-
-    x_offset = 0;
+function gaussCoef(sigma) {
+  if (sigma < 0.5) {
+    sigma = 0.5;
+  }
 
-    for (x = 0; x < width; x++) {
-      v = src[y_offset + x];
-      v = coeff_b0 * v + (coeff_a0 * v0 + coeff_a1 * v1 + coeff_a2 * v2);
+  var a = Math.exp(0.726 * 0.726) / sigma,
+      g1 = Math.exp(-a),
+      g2 = Math.exp(-2 * a),
+      k = (1 - g1) * (1 - g1) / (1 + 2 * a * g1 - g2);
+
+  a0 = k;
+  a1 = k * (a - 1) * g1;
+  a2 = k * (a + 1) * g1;
+  a3 = -k * g2;
+  b1 = 2 * g1;
+  b2 = -g2;
+  left_corner = (a0 + a1) / (1 - b1 - b2);
+  right_corner = (a2 + a3) / (1 - b1 - b2);
+
+  // Attempt to force type to FP32.
+  return new Float32Array([ a0, a1, a2, a3, b1, b2, left_corner, right_corner ]);
+}
+
+function convolveMono16(src, out, line, coeff, width, height) {
+  // takes src image and writes the blurred and transposed result into out
+
+  var prev_src, curr_src, curr_out, prev_out, prev_prev_out;
+  var src_index, out_index, line_index;
+  var i, j;
+  var coeff_a0, coeff_a1, coeff_b1, coeff_b2;
+
+  for (i = 0; i < height; i++) {
+    src_index = i * width;
+    out_index = i;
+    line_index = 0;
+
+    // left to right
+    prev_src = src[src_index];
+    prev_prev_out = prev_src * coeff[6];
+    prev_out = prev_prev_out;
+
+    coeff_a0 = coeff[0];
+    coeff_a1 = coeff[1];
+    coeff_b1 = coeff[4];
+    coeff_b2 = coeff[5];
+
+    for (j = 0; j < width; j++) {
+      curr_src = src[src_index];
+
+      curr_out = curr_src * coeff_a0 +
+                 prev_src * coeff_a1 +
+                 prev_out * coeff_b1 +
+                 prev_prev_out * coeff_b2;
+
+      prev_prev_out = prev_out;
+      prev_out = curr_out;
+      prev_src = curr_src;
+
+      line[line_index] = prev_out;
+      line_index++;
+      src_index++;
+    }
 
-      v2 = v1;
-      v1 = v0;
-      v0 = v;
+    src_index--;
+    line_index--;
+    out_index += height * (width - 1);
 
-      tmp[x_offset] = v;
-      x_offset++;
-    }
+    // right to left
+    prev_src = src[src_index];
+    prev_prev_out = prev_src * coeff[7];
+    prev_out = prev_prev_out;
+    curr_src = prev_src;
 
-    v0 = v;
-    v1 = v0;
-    v2 = v1;
+    coeff_a0 = coeff[2];
+    coeff_a1 = coeff[3];
 
-    out_index = y + height * width;
+    for (j = width - 1; j >= 0; j--) {
+      curr_out = curr_src * coeff_a0 +
+                 prev_src * coeff_a1 +
+                 prev_out * coeff_b1 +
+                 prev_prev_out * coeff_b2;
 
-    for (x = width - 1; x >= 0; x--) {
-      x_offset--;
+      prev_prev_out = prev_out;
+      prev_out = curr_out;
 
-      v = tmp[x_offset];
-      v = coeff_b0 * v + (coeff_a0 * v0 + coeff_a1 * v1 + coeff_a2 * v2);
+      prev_src = curr_src;
+      curr_src = src[src_index];
 
-      v2 = v1;
-      v1 = v0;
-      v0 = v;
+      out[out_index] = line[line_index] + prev_out;
 
+      src_index--;
+      line_index--;
       out_index -= height;
-      out[out_index] = v;
     }
   }
-};
+}
+
 
+function blurMono16(src, width, height, radius) {
+  // Quick exit on zero radius
+  if (!radius) { return; }
 
-var blurMono16 = function (src, width, height, radius) {
-  var out      = new Uint16Array(width * height),
-      tmp_line = new Float32Array(width);
+  var out      = new Uint16Array(src.length),
+      tmp_line = new Float32Array(Math.max(width, height));
 
   var coeff = gaussCoef(radius);
 
   convolveMono16(src, out, tmp_line, coeff, width, height, radius);
   convolveMono16(out, src, tmp_line, coeff, height, width, radius);
-};
+}
 
 module.exports = blurMono16;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "glur",
   "description": "Fast Gaussian Blur in pure JavaScript, via IIR filer. Speed does not depend on blur radius.",
-  "version": "1.0.0",
+  "version": "1.1.2",
   "keywords": [
     "blur",
     "gaussian"
@@ -13,8 +13,12 @@
     "index.js",
     "mono16.js"
   ],
+  "scripts": {
+    "test": "./node_modules/.bin/eslint ."
+  },
   "devDependencies": {
     "ansi": "0.3.x",
-    "benchmark": "1.0.x"
+    "benchmark": "1.0.x",
+    "eslint": "^1.8.0"
   }
 }