glur 1.1.1 → 2.0.0

package/README.md

@@ -1,10 +1,9 @@
 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
+> Fast Gaussian Blur in pure JavaScript, via IIR filter. Speed does not depend on
 > blur radius.
 
 __[demo 1](http://nodeca.github.io/glur/demo)__,
@@ -15,23 +14,28 @@ Install
 -------
 
 ```bash
-npm install glur --save
+npm install glur
 ```
 
 
 API
 ---
 
-`require('glur')(src, width, height, radius)`
+```js
+import { blurRGBA, blurMono16 } from 'glur'
+```
+
+### blurRGBA(src, width, height, radius)
 
-- __src__ - typed array with image RGBA data (will be updated with blured image).
+- __src__ - `Uint8ClampedArray` or `Uint8Array` with RGBA image data (modified in place).
 - __width__ - image width.
 - __height__ - image height.
 - __radius__ - blur radius.
 
-`require('glur/mono16')(src, width, height, radius)` - the same as above, but
-input data is grayscale Uint16Array. Can be useful to calculate unsharp mask via
-brightness/ligthness channel.
+### blurMono16(src, width, height, radius)
+
+Same as above, but input is a grayscale `Uint16Array`. Useful for unsharp mask
+via brightness/lightness channel.
 
 
 Authors

package/lib/blur_mono16.d.ts

@@ -0,0 +1,6 @@
+export default function blurMono16(
+  src: Uint16Array,
+  width: number,
+  height: number,
+  radius: number
+): void

package/lib/blur_mono16.mjs

@@ -0,0 +1,116 @@
+// 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
+
+function gaussCoef (sigma) {
+  if (sigma < 0.5) {
+    sigma = 0.5
+  }
+
+  const 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)
+
+  const a0 = k
+  const a1 = k * (a - 1) * g1
+  const a2 = k * (a + 1) * g1
+  const a3 = -k * g2
+  const b1 = 2 * g1
+  const b2 = -g2
+  const left_corner = (a0 + a1) / (1 - b1 - b2)
+  const 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
+
+  let prev_src, curr_src, curr_out, prev_out, prev_prev_out
+  let src_index, out_index, line_index
+  let i, j
+  let 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++
+    }
+
+    src_index--
+    line_index--
+    out_index += height * (width - 1)
+
+    // right to left
+    prev_src = src[src_index]
+    prev_prev_out = prev_src * coeff[7]
+    prev_out = prev_prev_out
+    curr_src = prev_src
+
+    coeff_a0 = coeff[2]
+    coeff_a1 = coeff[3]
+
+    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
+
+      prev_prev_out = prev_out
+      prev_out = curr_out
+
+      prev_src = curr_src
+      curr_src = src[src_index]
+
+      out[out_index] = line[line_index] + prev_out
+
+      src_index--
+      line_index--
+      out_index -= height
+    }
+  }
+}
+
+function blurMono16 (src, width, height, radius) {
+  // Quick exit on zero radius
+  if (!radius) { return }
+
+  const out = new Uint16Array(src.length),
+    tmp_line = new Float32Array(Math.max(width, height))
+
+  const coeff = gaussCoef(radius)
+
+  convolveMono16(src, out, tmp_line, coeff, width, height, radius)
+  convolveMono16(out, src, tmp_line, coeff, height, width, radius)
+}
+
+export default blurMono16

package/lib/blur_rgba.d.ts

@@ -0,0 +1,6 @@
+export default function blurRGBA(
+  src: Uint8ClampedArray | Uint8Array,
+  width: number,
+  height: number,
+  radius: number
+): void

package/lib/blur_rgba.mjs

@@ -0,0 +1,193 @@
+// 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
+
+function gaussCoef (sigma) {
+  if (sigma < 0.5) {
+    sigma = 0.5
+  }
+
+  const 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)
+
+  const a0 = k
+  const a1 = k * (a - 1) * g1
+  const a2 = k * (a + 1) * g1
+  const a3 = -k * g2
+  const b1 = 2 * g1
+  const b2 = -g2
+  const left_corner = (a0 + a1) / (1 - b1 - b2)
+  const 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
+
+  let rgba
+  let prev_src_r, prev_src_g, prev_src_b, prev_src_a
+  let curr_src_r, curr_src_g, curr_src_b, curr_src_a
+  let curr_out_r, curr_out_g, curr_out_b, curr_out_a
+  let prev_out_r, prev_out_g, prev_out_b, prev_out_a
+  let prev_prev_out_r, prev_prev_out_g, prev_prev_out_b, prev_prev_out_a
+
+  let src_index, out_index, line_index
+  let i, j
+  let 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++
+    }
+
+    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
+    }
+  }
+}
+
+function blurRGBA (src, width, height, radius) {
+  // Quick exit on zero radius
+  if (!radius) { return }
+
+  // Unify input data type, to keep convolver calls isomorphic
+  const src32 = new Uint32Array(src.buffer)
+
+  const out = new Uint32Array(src32.length),
+    tmp_line = new Float32Array(Math.max(width, height) * 4)
+
+  const coeff = gaussCoef(radius)
+
+  convolveRGBA(src32, out, tmp_line, coeff, width, height, radius)
+  convolveRGBA(out, src32, tmp_line, coeff, height, width, radius)
+}
+
+export default blurRGBA

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export { default as blurRGBA } from './blur_rgba.js'
+export { default as blurMono16 } from './blur_mono16.js'

package/lib/index.mjs

@@ -0,0 +1,2 @@
+export { default as blurRGBA } from './blur_rgba.mjs'
+export { default as blurMono16 } from './blur_mono16.mjs'

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.1.1",
+  "version": "2.0.0",
   "keywords": [
     "blur",
     "gaussian"
@@ -9,16 +9,26 @@
   "homepage": "https://github.com/andr83/glur/issues",
   "license": "MIT",
   "repository": "nodeca/glur",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
-    "index.js",
-    "mono16.js"
+    "lib/"
   ],
   "scripts": {
-    "test": "./node_modules/.bin/eslint ."
+    "demo": "npx serve .",
+    "lint": "eslint .",
+    "test": "npm run lint"
   },
   "devDependencies": {
     "ansi": "0.3.x",
     "benchmark": "1.0.x",
-    "eslint": "^1.8.0"
+    "eslint": "^9",
+    "neostandard": "^0.13.0"
   }
 }

package/CHANGELOG.md

@@ -1,22 +0,0 @@
-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/index.js

@@ -1,196 +0,0 @@
-// 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 a0, a1, a2, a3, b1, b2, left_corner, right_corner;
-
-function gaussCoef(sigma) {
-  if (sigma < 0.5) {
-    sigma = 0.5;
-  }
-
-  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++;
-    }
-
-    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 + curr_src_r * coeff_a1 + prev_out_r * coeff_b1 + prev_prev_out_r * coeff_b2;
-      curr_out_g = curr_src_g * coeff_a0 + curr_src_g * coeff_a1 + prev_out_g * coeff_b1 + prev_prev_out_g * coeff_b2;
-      curr_out_b = curr_src_b * coeff_a0 + curr_src_b * coeff_a1 + prev_out_b * coeff_b1 + prev_prev_out_b * coeff_b2;
-      curr_out_a = curr_src_a * coeff_a0 + curr_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;
-    }
-  }
-}
-
-
-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 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,119 +0,0 @@
-// 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 a0, a1, a2, a3, b1, b2, left_corner, right_corner;
-
-function gaussCoef(sigma) {
-  if (sigma < 0.5) {
-    sigma = 0.5;
-  }
-
-  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++;
-    }
-
-    src_index--;
-    line_index--;
-    out_index += height * (width - 1);
-
-    // right to left
-    prev_src = src[src_index];
-    prev_prev_out = prev_src * coeff[7];
-    prev_out = prev_prev_out;
-    curr_src = prev_src;
-
-    coeff_a0 = coeff[2];
-    coeff_a1 = coeff[3];
-
-    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;
-
-      prev_prev_out = prev_out;
-      prev_out = curr_out;
-
-      prev_src = curr_src;
-      curr_src = src[src_index];
-
-      out[out_index] = line[line_index] + prev_out;
-
-      src_index--;
-      line_index--;
-      out_index -= height;
-    }
-  }
-}
-
-
-function blurMono16(src, width, height, radius) {
-  // Quick exit on zero radius
-  if (!radius) { return; }
-
-  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;