From 72940990d365326cdffd3edeebc02e20aeec9035 Mon Sep 17 00:00:00 2001 From: Christoph Oberhofer Date: Mon, 12 Jan 2015 23:04:14 +0100 Subject: [PATCH 1/9] Another try on web-workers; works with decoding single-images only; live-stream and video-input won't work --- .gitignore | 1 + Gruntfile.js | 39 +- build/locator_end.frag | 2 + build/locator_start.frag | 13 + dist/locator.js | 5069 ++++++++++++++++++++++++++++++++++++++ dist/quagga.js | 189 +- src/barcode_locator.js | 101 +- src/config.js | 1 + src/quagga.js | 60 +- src/typedefs.js | 28 +- src/worker_locator.js | 39 + 11 files changed, 5389 insertions(+), 153 deletions(-) create mode 100644 build/locator_end.frag create mode 100644 build/locator_start.frag create mode 100644 dist/locator.js create mode 100644 src/worker_locator.js diff --git a/.gitignore b/.gitignore index 5d5649f..a820c68 100644 --- a/.gitignore +++ b/.gitignore @@ -3,3 +3,4 @@ node_modules/ coverage/ .project _site/ +.idea/ diff --git a/Gruntfile.js b/Gruntfile.js index ff7381c..f5b0e1f 100644 --- a/Gruntfile.js +++ b/Gruntfile.js @@ -21,7 +21,7 @@ module.exports = function(grunt) { all : ['Gruntfile.js', 'src/*.js'] }, requirejs : { - compile : { + quagga : { options : { almond : true, wrap : { @@ -51,6 +51,41 @@ module.exports = function(grunt) { } }, + "paths" : { + "typedefs" : "typedefs", + "glMatrix" : "vendor/glMatrix", + "glMatrixAddon" : "glMatrixAddon" + } + } + }, + locator : { + options : { + almond : true, + wrap : { + startFile : 'build/locator_start.frag', + endFile : 'build/locator_end.frag' + }, + "baseUrl" : "src", + "name" : "barcode_locator", + "out" : "dist/locator.js", + "include" : ['barcode_locator'], + "optimize" : "none", + "findNestedDependencies" : true, + "skipSemiColonInsertion" : true, + "shim" : { + "typedefs" : { + "deps" : [], + "exports" : "typedefs" + }, + "glMatrix" : { + "deps" : ["typedefs"], + "exports" : "glMatrix" + }, + "glMatrixAddon" : { + "deps" : ["glMatrix"], + "exports" : "glMatrixAddon" + } + }, "paths" : { "typedefs" : "typedefs", "glMatrix" : "vendor/glMatrix", @@ -68,7 +103,7 @@ module.exports = function(grunt) { grunt.loadNpmTasks('grunt-requirejs'); grunt.loadNpmTasks('grunt-karma'); // Default task(s). - grunt.registerTask('default', ['jshint', 'requirejs', 'uglify']); + grunt.registerTask('default', ['jshint', 'requirejs']); grunt.registerTask('test', ['karma']); }; diff --git a/build/locator_end.frag b/build/locator_end.frag new file mode 100644 index 0000000..a56972d --- /dev/null +++ b/build/locator_end.frag @@ -0,0 +1,2 @@ + return require('barcode_locator'); +})); \ No newline at end of file diff --git a/build/locator_start.frag b/build/locator_start.frag new file mode 100644 index 0000000..15145a9 --- /dev/null +++ b/build/locator_start.frag @@ -0,0 +1,13 @@ +(function (root, factory) { + if (typeof define === 'function' && define.amd) { + //Allow using this built library as an AMD module + //in another project. That other project will only + //see this AMD call, not the internal modules in + //the closure below. + define([], factory); + } else { + //Browser globals case. Just assign the + //result to a property on the global. + root.Locator = factory(); + } +}(this, function () { \ No newline at end of file diff --git a/dist/locator.js b/dist/locator.js new file mode 100644 index 0000000..53196b7 --- /dev/null +++ b/dist/locator.js @@ -0,0 +1,5069 @@ +(function (root, factory) { + if (typeof define === 'function' && define.amd) { + //Allow using this built library as an AMD module + //in another project. That other project will only + //see this AMD call, not the internal modules in + //the closure below. + define([], factory); + } else { + //Browser globals case. Just assign the + //result to a property on the global. + root.Locator = factory(); + } +}(this, function () {/** + * @license almond 0.2.9 Copyright (c) 2011-2014, The Dojo Foundation All Rights Reserved. + * Available via the MIT or new BSD license. + * see: http://github.com/jrburke/almond for details + */ +//Going sloppy to avoid 'use strict' string cost, but strict practices should +//be followed. +/*jslint sloppy: true */ +/*global setTimeout: false */ + +var requirejs, require, define; +(function (undef) { + var main, req, makeMap, handlers, + defined = {}, + waiting = {}, + config = {}, + defining = {}, + hasOwn = Object.prototype.hasOwnProperty, + aps = [].slice, + jsSuffixRegExp = /\.js$/; + + function hasProp(obj, prop) { + return hasOwn.call(obj, prop); + } + + /** + * Given a relative module name, like ./something, normalize it to + * a real name that can be mapped to a path. + * @param {String} name the relative name + * @param {String} baseName a real name that the name arg is relative + * to. + * @returns {String} normalized name + */ + function normalize(name, baseName) { + var nameParts, nameSegment, mapValue, foundMap, lastIndex, + foundI, foundStarMap, starI, i, j, part, + baseParts = baseName && baseName.split("/"), + map = config.map, + starMap = (map && map['*']) || {}; + + //Adjust any relative paths. + if (name && name.charAt(0) === ".") { + //If have a base name, try to normalize against it, + //otherwise, assume it is a top-level require that will + //be relative to baseUrl in the end. + if (baseName) { + //Convert baseName to array, and lop off the last part, + //so that . matches that "directory" and not name of the baseName's + //module. For instance, baseName of "one/two/three", maps to + //"one/two/three.js", but we want the directory, "one/two" for + //this normalization. + baseParts = baseParts.slice(0, baseParts.length - 1); + name = name.split('/'); + lastIndex = name.length - 1; + + // Node .js allowance: + if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) { + name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, ''); + } + + name = baseParts.concat(name); + + //start trimDots + for (i = 0; i < name.length; i += 1) { + part = name[i]; + if (part === ".") { + name.splice(i, 1); + i -= 1; + } else if (part === "..") { + if (i === 1 && (name[2] === '..' || name[0] === '..')) { + //End of the line. Keep at least one non-dot + //path segment at the front so it can be mapped + //correctly to disk. Otherwise, there is likely + //no path mapping for a path starting with '..'. + //This can still fail, but catches the most reasonable + //uses of .. + break; + } else if (i > 0) { + name.splice(i - 1, 2); + i -= 2; + } + } + } + //end trimDots + + name = name.join("/"); + } else if (name.indexOf('./') === 0) { + // No baseName, so this is ID is resolved relative + // to baseUrl, pull off the leading dot. + name = name.substring(2); + } + } + + //Apply map config if available. + if ((baseParts || starMap) && map) { + nameParts = name.split('/'); + + for (i = nameParts.length; i > 0; i -= 1) { + nameSegment = nameParts.slice(0, i).join("/"); + + if (baseParts) { + //Find the longest baseName segment match in the config. + //So, do joins on the biggest to smallest lengths of baseParts. + for (j = baseParts.length; j > 0; j -= 1) { + mapValue = map[baseParts.slice(0, j).join('/')]; + + //baseName segment has config, find if it has one for + //this name. + if (mapValue) { + mapValue = mapValue[nameSegment]; + if (mapValue) { + //Match, update name to the new value. + foundMap = mapValue; + foundI = i; + break; + } + } + } + } + + if (foundMap) { + break; + } + + //Check for a star map match, but just hold on to it, + //if there is a shorter segment match later in a matching + //config, then favor over this star map. + if (!foundStarMap && starMap && starMap[nameSegment]) { + foundStarMap = starMap[nameSegment]; + starI = i; + } + } + + if (!foundMap && foundStarMap) { + foundMap = foundStarMap; + foundI = starI; + } + + if (foundMap) { + nameParts.splice(0, foundI, foundMap); + name = nameParts.join('/'); + } + } + + return name; + } + + function makeRequire(relName, forceSync) { + return function () { + //A version of a require function that passes a moduleName + //value for items that may need to + //look up paths relative to the moduleName + return req.apply(undef, aps.call(arguments, 0).concat([relName, forceSync])); + }; + } + + function makeNormalize(relName) { + return function (name) { + return normalize(name, relName); + }; + } + + function makeLoad(depName) { + return function (value) { + defined[depName] = value; + }; + } + + function callDep(name) { + if (hasProp(waiting, name)) { + var args = waiting[name]; + delete waiting[name]; + defining[name] = true; + main.apply(undef, args); + } + + if (!hasProp(defined, name) && !hasProp(defining, name)) { + throw new Error('No ' + name); + } + return defined[name]; + } + + //Turns a plugin!resource to [plugin, resource] + //with the plugin being undefined if the name + //did not have a plugin prefix. + function splitPrefix(name) { + var prefix, + index = name ? name.indexOf('!') : -1; + if (index > -1) { + prefix = name.substring(0, index); + name = name.substring(index + 1, name.length); + } + return [prefix, name]; + } + + /** + * Makes a name map, normalizing the name, and using a plugin + * for normalization if necessary. Grabs a ref to plugin + * too, as an optimization. + */ + makeMap = function (name, relName) { + var plugin, + parts = splitPrefix(name), + prefix = parts[0]; + + name = parts[1]; + + if (prefix) { + prefix = normalize(prefix, relName); + plugin = callDep(prefix); + } + + //Normalize according + if (prefix) { + if (plugin && plugin.normalize) { + name = plugin.normalize(name, makeNormalize(relName)); + } else { + name = normalize(name, relName); + } + } else { + name = normalize(name, relName); + parts = splitPrefix(name); + prefix = parts[0]; + name = parts[1]; + if (prefix) { + plugin = callDep(prefix); + } + } + + //Using ridiculous property names for space reasons + return { + f: prefix ? prefix + '!' + name : name, //fullName + n: name, + pr: prefix, + p: plugin + }; + }; + + function makeConfig(name) { + return function () { + return (config && config.config && config.config[name]) || {}; + }; + } + + handlers = { + require: function (name) { + return makeRequire(name); + }, + exports: function (name) { + var e = defined[name]; + if (typeof e !== 'undefined') { + return e; + } else { + return (defined[name] = {}); + } + }, + module: function (name) { + return { + id: name, + uri: '', + exports: defined[name], + config: makeConfig(name) + }; + } + }; + + main = function (name, deps, callback, relName) { + var cjsModule, depName, ret, map, i, + args = [], + callbackType = typeof callback, + usingExports; + + //Use name if no relName + relName = relName || name; + + //Call the callback to define the module, if necessary. + if (callbackType === 'undefined' || callbackType === 'function') { + //Pull out the defined dependencies and pass the ordered + //values to the callback. + //Default to [require, exports, module] if no deps + deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps; + for (i = 0; i < deps.length; i += 1) { + map = makeMap(deps[i], relName); + depName = map.f; + + //Fast path CommonJS standard dependencies. + if (depName === "require") { + args[i] = handlers.require(name); + } else if (depName === "exports") { + //CommonJS module spec 1.1 + args[i] = handlers.exports(name); + usingExports = true; + } else if (depName === "module") { + //CommonJS module spec 1.1 + cjsModule = args[i] = handlers.module(name); + } else if (hasProp(defined, depName) || + hasProp(waiting, depName) || + hasProp(defining, depName)) { + args[i] = callDep(depName); + } else if (map.p) { + map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {}); + args[i] = defined[depName]; + } else { + throw new Error(name + ' missing ' + depName); + } + } + + ret = callback ? callback.apply(defined[name], args) : undefined; + + if (name) { + //If setting exports via "module" is in play, + //favor that over return value and exports. After that, + //favor a non-undefined return value over exports use. + if (cjsModule && cjsModule.exports !== undef && + cjsModule.exports !== defined[name]) { + defined[name] = cjsModule.exports; + } else if (ret !== undef || !usingExports) { + //Use the return value from the function. + defined[name] = ret; + } + } + } else if (name) { + //May just be an object definition for the module. Only + //worry about defining if have a module name. + defined[name] = callback; + } + }; + + requirejs = require = req = function (deps, callback, relName, forceSync, alt) { + if (typeof deps === "string") { + if (handlers[deps]) { + //callback in this case is really relName + return handlers[deps](callback); + } + //Just return the module wanted. In this scenario, the + //deps arg is the module name, and second arg (if passed) + //is just the relName. + //Normalize module name, if it contains . or .. + return callDep(makeMap(deps, callback).f); + } else if (!deps.splice) { + //deps is a config object, not an array. + config = deps; + if (config.deps) { + req(config.deps, config.callback); + } + if (!callback) { + return; + } + + if (callback.splice) { + //callback is an array, which means it is a dependency list. + //Adjust args if there are dependencies + deps = callback; + callback = relName; + relName = null; + } else { + deps = undef; + } + } + + //Support require(['a']) + callback = callback || function () {}; + + //If relName is a function, it is an errback handler, + //so remove it. + if (typeof relName === 'function') { + relName = forceSync; + forceSync = alt; + } + + //Simulate async callback; + if (forceSync) { + main(undef, deps, callback, relName); + } else { + //Using a non-zero value because of concern for what old browsers + //do, and latest browsers "upgrade" to 4 if lower value is used: + //http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#dom-windowtimers-settimeout: + //If want a value immediately, use require('id') instead -- something + //that works in almond on the global level, but not guaranteed and + //unlikely to work in other AMD implementations. + setTimeout(function () { + main(undef, deps, callback, relName); + }, 4); + } + + return req; + }; + + /** + * Just drops the config on the floor, but returns req in case + * the config return value is used. + */ + req.config = function (cfg) { + return req(cfg); + }; + + /** + * Expose module registry for debugging and tooling + */ + requirejs._defined = defined; + + define = function (name, deps, callback) { + + //This module may not have dependencies + if (!deps.splice) { + //deps is not an array, so probably means + //an object literal or factory function for + //the value. Adjust args. + callback = deps; + deps = []; + } + + if (!hasProp(defined, name) && !hasProp(waiting, name)) { + waiting[name] = [name, deps, callback]; + } + }; + + define.amd = { + jQuery: true + }; +}()); + +define("almond", function(){}); + +/* + * typedefs.js + * Normalizes browser-specific prefixes + */ + +glMatrixArrayType = Float32Array; +if (typeof window !== 'undefined') { + window.requestAnimFrame = (function () { + return window.requestAnimationFrame || + window.webkitRequestAnimationFrame || + window.mozRequestAnimationFrame || + window.oRequestAnimationFrame || + window.msRequestAnimationFrame || + function (/* function FrameRequestCallback */ callback, /* DOMElement Element */ element) { + window.setTimeout(callback, 1000 / 60); + }; + })(); + + navigator.getUserMedia = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia || navigator.msGetUserMedia; + window.URL = window.URL || window.webkitURL || window.mozURL || window.msURL; +} + +define("typedefs", (function (global) { + return function () { + var ret, fn; + return ret || global.typedefs; + }; +}(this))); + +/* jshint undef: true, unused: true, browser:true, devel: true */ +/* global define */ + +define('subImage',["typedefs"], function() { + + + /** + * Construct representing a part of another {ImageWrapper}. Shares data + * between the parent and the child. + * @param from {ImageRef} The position where to start the {SubImage} from. (top-left corner) + * @param size {ImageRef} The size of the resulting image + * @param I {ImageWrapper} The {ImageWrapper} to share from + * @returns {SubImage} A shared part of the original image + */ + function SubImage(from, size, I) { + if (!I) { + I = { + data : null, + size : size + }; + } + this.data = I.data; + this.originalSize = I.size; + this.I = I; + + this.from = from; + this.size = size; + } + + /** + * Displays the {SubImage} in a given canvas + * @param canvas {Canvas} The canvas element to write to + * @param scale {Number} Scale which is applied to each pixel-value + */ + SubImage.prototype.show = function(canvas, scale) { + var ctx, + frame, + data, + current, + y, + x, + pixel; + + if (!scale) { + scale = 1.0; + } + ctx = canvas.getContext('2d'); + canvas.width = this.size.x; + canvas.height = this.size.y; + frame = ctx.getImageData(0, 0, canvas.width, canvas.height); + data = frame.data; + current = 0; + for (y = 0; y < this.size.y; y++) { + for (x = 0; x < this.size.x; x++) { + pixel = y * this.size.x + x; + current = this.get(x, y) * scale; + data[pixel * 4 + 0] = current; + data[pixel * 4 + 1] = current; + data[pixel * 4 + 2] = current; + data[pixel * 4 + 3] = 255; + } + } + frame.data = data; + ctx.putImageData(frame, 0, 0); + }; + + /** + * Retrieves a given pixel position from the {SubImage} + * @param x {Number} The x-position + * @param y {Number} The y-position + * @returns {Number} The grayscale value at the pixel-position + */ + SubImage.prototype.get = function(x, y) { + return this.data[(this.from.y + y) * this.originalSize.x + this.from.x + x]; + }; + + /** + * Updates the underlying data from a given {ImageWrapper} + * @param image {ImageWrapper} The updated image + */ + SubImage.prototype.updateData = function(image) { + this.originalSize = image.size; + this.data = image.data; + }; + + /** + * Updates the position of the shared area + * @param from {x,y} The new location + * @returns {SubImage} returns {this} for possible chaining + */ + SubImage.prototype.updateFrom = function(from) { + this.from = from; + return this; + }; + + return (SubImage); +}); +/* jshint undef: true, unused: true, browser:true, devel: true */ +/* global define, vec2 */ + +define('cluster',[],function() { + + + /** + * Creates a cluster for grouping similar orientations of datapoints + */ + var Cluster = { + create : function(point, threshold) { + var points = [], center = { + rad : 0, + vec : vec2.create([0, 0]) + }, pointMap = {}; + + function init() { + add(point); + updateCenter(); + } + + function add(point) { + pointMap[point.id] = point; + points.push(point); + } + + function updateCenter() { + var i, sum = 0; + for ( i = 0; i < points.length; i++) { + sum += points[i].rad; + } + center.rad = sum / points.length; + center.vec = vec2.create([Math.cos(center.rad), Math.sin(center.rad)]); + } + + init(); + + return { + add : function(point) { + if (!pointMap[point.id]) { + add(point); + updateCenter(); + } + }, + fits : function(point) { + // check cosine similarity to center-angle + var similarity = Math.abs(vec2.dot(point.point.vec, center.vec)); + if (similarity > threshold) { + return true; + } + return false; + }, + getPoints : function() { + return points; + }, + getCenter : function() { + return center; + } + }; + }, + createPoint : function(point, id, property) { + return { + rad : point[property], + point : point, + id : id + }; + } + }; + + return (Cluster); +}); + +/* + * glMatrix.js - High performance matrix and vector operations for WebGL + * version 0.9.6 + */ + +/* + * Copyright (c) 2011 Brandon Jones + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not + * be misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + */ + + + +/* + * vec3 - 3 Dimensional Vector + */ +var vec3 = {}; + +/* + * vec3.create + * Creates a new instance of a vec3 using the default array type + * Any javascript array containing at least 3 numeric elements can serve as a vec3 + * + * Params: + * vec - Optional, vec3 containing values to initialize with + * + * Returns: + * New vec3 + */ +vec3.create = function(vec) { + var dest; + if(vec) { + dest = new glMatrixArrayType(3); + dest[0] = vec[0]; + dest[1] = vec[1]; + dest[2] = vec[2]; + } else { + if(glMatrixArrayType === Array) + dest = new glMatrixArrayType([0,0,0]); + else + dest = new glMatrixArrayType(3); + } + + return dest; +}; + +/* + * vec3.set + * Copies the values of one vec3 to another + * + * Params: + * vec - vec3 containing values to copy + * dest - vec3 receiving copied values + * + * Returns: + * dest + */ +vec3.set = function(vec, dest) { + dest[0] = vec[0]; + dest[1] = vec[1]; + dest[2] = vec[2]; + + return dest; +}; + +/* + * vec3.add + * Performs a vector addition + * + * Params: + * vec - vec3, first operand + * vec2 - vec3, second operand + * dest - Optional, vec3 receiving operation result. If not specified result is written to vec + * + * Returns: + * dest if specified, vec otherwise + */ +vec3.add = function(vec, vec2, dest) { + if(!dest || vec == dest) { + vec[0] += vec2[0]; + vec[1] += vec2[1]; + vec[2] += vec2[2]; + return vec; + } + + dest[0] = vec[0] + vec2[0]; + dest[1] = vec[1] + vec2[1]; + dest[2] = vec[2] + vec2[2]; + return dest; +}; + +/* + * vec3.subtract + * Performs a vector subtraction + * + * Params: + * vec - vec3, first operand + * vec2 - vec3, second operand + * dest - Optional, vec3 receiving operation result. If not specified result is written to vec + * + * Returns: + * dest if specified, vec otherwise + */ +vec3.subtract = function(vec, vec2, dest) { + if(!dest || vec == dest) { + vec[0] -= vec2[0]; + vec[1] -= vec2[1]; + vec[2] -= vec2[2]; + return vec; + } + + dest[0] = vec[0] - vec2[0]; + dest[1] = vec[1] - vec2[1]; + dest[2] = vec[2] - vec2[2]; + return dest; +}; + +/* + * vec3.negate + * Negates the components of a vec3 + * + * Params: + * vec - vec3 to negate + * dest - Optional, vec3 receiving operation result. If not specified result is written to vec + * + * Returns: + * dest if specified, vec otherwise + */ +vec3.negate = function(vec, dest) { + if(!dest) { dest = vec; } + + dest[0] = -vec[0]; + dest[1] = -vec[1]; + dest[2] = -vec[2]; + return dest; +}; + +/* + * vec3.scale + * Multiplies the components of a vec3 by a scalar value + * + * Params: + * vec - vec3 to scale + * val - Numeric value to scale by + * dest - Optional, vec3 receiving operation result. If not specified result is written to vec + * + * Returns: + * dest if specified, vec otherwise + */ +vec3.scale = function(vec, val, dest) { + if(!dest || vec == dest) { + vec[0] *= val; + vec[1] *= val; + vec[2] *= val; + return vec; + } + + dest[0] = vec[0]*val; + dest[1] = vec[1]*val; + dest[2] = vec[2]*val; + return dest; +}; + +/* + * vec3.normalize + * Generates a unit vector of the same direction as the provided vec3 + * If vector length is 0, returns [0, 0, 0] + * + * Params: + * vec - vec3 to normalize + * dest - Optional, vec3 receiving operation result. If not specified result is written to vec + * + * Returns: + * dest if specified, vec otherwise + */ +vec3.normalize = function(vec, dest) { + if(!dest) { dest = vec; } + + var x = vec[0], y = vec[1], z = vec[2]; + var len = Math.sqrt(x*x + y*y + z*z); + + if (!len) { + dest[0] = 0; + dest[1] = 0; + dest[2] = 0; + return dest; + } else if (len == 1) { + dest[0] = x; + dest[1] = y; + dest[2] = z; + return dest; + } + + len = 1 / len; + dest[0] = x*len; + dest[1] = y*len; + dest[2] = z*len; + return dest; +}; + +/* + * vec3.cross + * Generates the cross product of two vec3s + * + * Params: + * vec - vec3, first operand + * vec2 - vec3, second operand + * dest - Optional, vec3 receiving operation result. If not specified result is written to vec + * + * Returns: + * dest if specified, vec otherwise + */ +vec3.cross = function(vec, vec2, dest){ + if(!dest) { dest = vec; } + + var x = vec[0], y = vec[1], z = vec[2]; + var x2 = vec2[0], y2 = vec2[1], z2 = vec2[2]; + + dest[0] = y*z2 - z*y2; + dest[1] = z*x2 - x*z2; + dest[2] = x*y2 - y*x2; + return dest; +}; + +/* + * vec3.length + * Caclulates the length of a vec3 + * + * Params: + * vec - vec3 to calculate length of + * + * Returns: + * Length of vec + */ +vec3.length = function(vec){ + var x = vec[0], y = vec[1], z = vec[2]; + return Math.sqrt(x*x + y*y + z*z); +}; + +/* + * vec3.dot + * Caclulates the dot product of two vec3s + * + * Params: + * vec - vec3, first operand + * vec2 - vec3, second operand + * + * Returns: + * Dot product of vec and vec2 + */ +vec3.dot = function(vec, vec2){ + return vec[0]*vec2[0] + vec[1]*vec2[1] + vec[2]*vec2[2]; +}; + +/* + * vec3.direction + * Generates a unit vector pointing from one vector to another + * + * Params: + * vec - origin vec3 + * vec2 - vec3 to point to + * dest - Optional, vec3 receiving operation result. If not specified result is written to vec + * + * Returns: + * dest if specified, vec otherwise + */ +vec3.direction = function(vec, vec2, dest) { + if(!dest) { dest = vec; } + + var x = vec[0] - vec2[0]; + var y = vec[1] - vec2[1]; + var z = vec[2] - vec2[2]; + + var len = Math.sqrt(x*x + y*y + z*z); + if (!len) { + dest[0] = 0; + dest[1] = 0; + dest[2] = 0; + return dest; + } + + len = 1 / len; + dest[0] = x * len; + dest[1] = y * len; + dest[2] = z * len; + return dest; +}; + +/* + * vec3.lerp + * Performs a linear interpolation between two vec3 + * + * Params: + * vec - vec3, first vector + * vec2 - vec3, second vector + * lerp - interpolation amount between the two inputs + * dest - Optional, vec3 receiving operation result. If not specified result is written to vec + * + * Returns: + * dest if specified, vec otherwise + */ +vec3.lerp = function(vec, vec2, lerp, dest){ + if(!dest) { dest = vec; } + + dest[0] = vec[0] + lerp * (vec2[0] - vec[0]); + dest[1] = vec[1] + lerp * (vec2[1] - vec[1]); + dest[2] = vec[2] + lerp * (vec2[2] - vec[2]); + + return dest; +}; + +/* + * vec3.str + * Returns a string representation of a vector + * + * Params: + * vec - vec3 to represent as a string + * + * Returns: + * string representation of vec + */ +vec3.str = function(vec) { + return '[' + vec[0] + ', ' + vec[1] + ', ' + vec[2] + ']'; +}; + +/* + * mat3 - 3x3 Matrix + */ +var mat3 = {}; + +/* + * mat3.create + * Creates a new instance of a mat3 using the default array type + * Any javascript array containing at least 9 numeric elements can serve as a mat3 + * + * Params: + * mat - Optional, mat3 containing values to initialize with + * + * Returns: + * New mat3 + */ +mat3.create = function(mat) { + var dest; + + if(mat) { + dest = new glMatrixArrayType(9); + dest[0] = mat[0]; + dest[1] = mat[1]; + dest[2] = mat[2]; + dest[3] = mat[3]; + dest[4] = mat[4]; + dest[5] = mat[5]; + dest[6] = mat[6]; + dest[7] = mat[7]; + dest[8] = mat[8]; + } else { + if(glMatrixArrayType === Array) + dest = new glMatrixArrayType([0,0,0,0,0,0,0,0,0]); + else + dest = new glMatrixArrayType(9); + } + + return dest; +}; + +/* + * mat3.set + * Copies the values of one mat3 to another + * + * Params: + * mat - mat3 containing values to copy + * dest - mat3 receiving copied values + * + * Returns: + * dest + */ +mat3.set = function(mat, dest) { + dest[0] = mat[0]; + dest[1] = mat[1]; + dest[2] = mat[2]; + dest[3] = mat[3]; + dest[4] = mat[4]; + dest[5] = mat[5]; + dest[6] = mat[6]; + dest[7] = mat[7]; + dest[8] = mat[8]; + return dest; +}; + +/* + * mat3.identity + * Sets a mat3 to an identity matrix + * + * Params: + * dest - mat3 to set + * + * Returns: + * dest + */ +mat3.identity = function(dest) { + dest[0] = 1; + dest[1] = 0; + dest[2] = 0; + dest[3] = 0; + dest[4] = 1; + dest[5] = 0; + dest[6] = 0; + dest[7] = 0; + dest[8] = 1; + return dest; +}; + +/* + * mat4.transpose + * Transposes a mat3 (flips the values over the diagonal) + * + * Params: + * mat - mat3 to transpose + * dest - Optional, mat3 receiving transposed values. If not specified result is written to mat + * + * Returns: + * dest is specified, mat otherwise + */ +mat3.transpose = function(mat, dest) { + // If we are transposing ourselves we can skip a few steps but have to cache some values + if(!dest || mat == dest) { + var a01 = mat[1], a02 = mat[2]; + var a12 = mat[5]; + + mat[1] = mat[3]; + mat[2] = mat[6]; + mat[3] = a01; + mat[5] = mat[7]; + mat[6] = a02; + mat[7] = a12; + return mat; + } + + dest[0] = mat[0]; + dest[1] = mat[3]; + dest[2] = mat[6]; + dest[3] = mat[1]; + dest[4] = mat[4]; + dest[5] = mat[7]; + dest[6] = mat[2]; + dest[7] = mat[5]; + dest[8] = mat[8]; + return dest; +}; + +/* + * mat3.toMat4 + * Copies the elements of a mat3 into the upper 3x3 elements of a mat4 + * + * Params: + * mat - mat3 containing values to copy + * dest - Optional, mat4 receiving copied values + * + * Returns: + * dest if specified, a new mat4 otherwise + */ +mat3.toMat4 = function(mat, dest) { + if(!dest) { dest = mat4.create(); } + + dest[0] = mat[0]; + dest[1] = mat[1]; + dest[2] = mat[2]; + dest[3] = 0; + + dest[4] = mat[3]; + dest[5] = mat[4]; + dest[6] = mat[5]; + dest[7] = 0; + + dest[8] = mat[6]; + dest[9] = mat[7]; + dest[10] = mat[8]; + dest[11] = 0; + + dest[12] = 0; + dest[13] = 0; + dest[14] = 0; + dest[15] = 1; + + return dest; +}; + +/* + * mat3.str + * Returns a string representation of a mat3 + * + * Params: + * mat - mat3 to represent as a string + * + * Returns: + * string representation of mat + */ +mat3.str = function(mat) { + return '[' + mat[0] + ', ' + mat[1] + ', ' + mat[2] + + ', ' + mat[3] + ', '+ mat[4] + ', ' + mat[5] + + ', ' + mat[6] + ', ' + mat[7] + ', '+ mat[8] + ']'; +}; + +/* + * mat4 - 4x4 Matrix + */ +var mat4 = {}; + +/* + * mat4.create + * Creates a new instance of a mat4 using the default array type + * Any javascript array containing at least 16 numeric elements can serve as a mat4 + * + * Params: + * mat - Optional, mat4 containing values to initialize with + * + * Returns: + * New mat4 + */ +mat4.create = function(mat) { + var dest; + + if(mat) { + dest = new glMatrixArrayType(16); + dest[0] = mat[0]; + dest[1] = mat[1]; + dest[2] = mat[2]; + dest[3] = mat[3]; + dest[4] = mat[4]; + dest[5] = mat[5]; + dest[6] = mat[6]; + dest[7] = mat[7]; + dest[8] = mat[8]; + dest[9] = mat[9]; + dest[10] = mat[10]; + dest[11] = mat[11]; + dest[12] = mat[12]; + dest[13] = mat[13]; + dest[14] = mat[14]; + dest[15] = mat[15]; + } else { + if(glMatrixArrayType === Array) + dest = new glMatrixArrayType([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]); + else + dest = new glMatrixArrayType(16); + } + + return dest; +}; + +/* + * mat4.set + * Copies the values of one mat4 to another + * + * Params: + * mat - mat4 containing values to copy + * dest - mat4 receiving copied values + * + * Returns: + * dest + */ +mat4.set = function(mat, dest) { + dest[0] = mat[0]; + dest[1] = mat[1]; + dest[2] = mat[2]; + dest[3] = mat[3]; + dest[4] = mat[4]; + dest[5] = mat[5]; + dest[6] = mat[6]; + dest[7] = mat[7]; + dest[8] = mat[8]; + dest[9] = mat[9]; + dest[10] = mat[10]; + dest[11] = mat[11]; + dest[12] = mat[12]; + dest[13] = mat[13]; + dest[14] = mat[14]; + dest[15] = mat[15]; + return dest; +}; + +/* + * mat4.identity + * Sets a mat4 to an identity matrix + * + * Params: + * dest - mat4 to set + * + * Returns: + * dest + */ +mat4.identity = function(dest) { + dest[0] = 1; + dest[1] = 0; + dest[2] = 0; + dest[3] = 0; + dest[4] = 0; + dest[5] = 1; + dest[6] = 0; + dest[7] = 0; + dest[8] = 0; + dest[9] = 0; + dest[10] = 1; + dest[11] = 0; + dest[12] = 0; + dest[13] = 0; + dest[14] = 0; + dest[15] = 1; + return dest; +}; + +/* + * mat4.transpose + * Transposes a mat4 (flips the values over the diagonal) + * + * Params: + * mat - mat4 to transpose + * dest - Optional, mat4 receiving transposed values. If not specified result is written to mat + * + * Returns: + * dest is specified, mat otherwise + */ +mat4.transpose = function(mat, dest) { + // If we are transposing ourselves we can skip a few steps but have to cache some values + if(!dest || mat == dest) { + var a01 = mat[1], a02 = mat[2], a03 = mat[3]; + var a12 = mat[6], a13 = mat[7]; + var a23 = mat[11]; + + mat[1] = mat[4]; + mat[2] = mat[8]; + mat[3] = mat[12]; + mat[4] = a01; + mat[6] = mat[9]; + mat[7] = mat[13]; + mat[8] = a02; + mat[9] = a12; + mat[11] = mat[14]; + mat[12] = a03; + mat[13] = a13; + mat[14] = a23; + return mat; + } + + dest[0] = mat[0]; + dest[1] = mat[4]; + dest[2] = mat[8]; + dest[3] = mat[12]; + dest[4] = mat[1]; + dest[5] = mat[5]; + dest[6] = mat[9]; + dest[7] = mat[13]; + dest[8] = mat[2]; + dest[9] = mat[6]; + dest[10] = mat[10]; + dest[11] = mat[14]; + dest[12] = mat[3]; + dest[13] = mat[7]; + dest[14] = mat[11]; + dest[15] = mat[15]; + return dest; +}; + +/* + * mat4.determinant + * Calculates the determinant of a mat4 + * + * Params: + * mat - mat4 to calculate determinant of + * + * Returns: + * determinant of mat + */ +mat4.determinant = function(mat) { + // Cache the matrix values (makes for huge speed increases!) + var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3]; + var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7]; + var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11]; + var a30 = mat[12], a31 = mat[13], a32 = mat[14], a33 = mat[15]; + + return a30*a21*a12*a03 - a20*a31*a12*a03 - a30*a11*a22*a03 + a10*a31*a22*a03 + + a20*a11*a32*a03 - a10*a21*a32*a03 - a30*a21*a02*a13 + a20*a31*a02*a13 + + a30*a01*a22*a13 - a00*a31*a22*a13 - a20*a01*a32*a13 + a00*a21*a32*a13 + + a30*a11*a02*a23 - a10*a31*a02*a23 - a30*a01*a12*a23 + a00*a31*a12*a23 + + a10*a01*a32*a23 - a00*a11*a32*a23 - a20*a11*a02*a33 + a10*a21*a02*a33 + + a20*a01*a12*a33 - a00*a21*a12*a33 - a10*a01*a22*a33 + a00*a11*a22*a33; +}; + +/* + * mat4.inverse + * Calculates the inverse matrix of a mat4 + * + * Params: + * mat - mat4 to calculate inverse of + * dest - Optional, mat4 receiving inverse matrix. If not specified result is written to mat + * + * Returns: + * dest is specified, mat otherwise + */ +mat4.inverse = function(mat, dest) { + if(!dest) { dest = mat; } + + // Cache the matrix values (makes for huge speed increases!) + var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3]; + var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7]; + var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11]; + var a30 = mat[12], a31 = mat[13], a32 = mat[14], a33 = mat[15]; + + var b00 = a00*a11 - a01*a10; + var b01 = a00*a12 - a02*a10; + var b02 = a00*a13 - a03*a10; + var b03 = a01*a12 - a02*a11; + var b04 = a01*a13 - a03*a11; + var b05 = a02*a13 - a03*a12; + var b06 = a20*a31 - a21*a30; + var b07 = a20*a32 - a22*a30; + var b08 = a20*a33 - a23*a30; + var b09 = a21*a32 - a22*a31; + var b10 = a21*a33 - a23*a31; + var b11 = a22*a33 - a23*a32; + + // Calculate the determinant (inlined to avoid double-caching) + var invDet = 1/(b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06); + + dest[0] = (a11*b11 - a12*b10 + a13*b09)*invDet; + dest[1] = (-a01*b11 + a02*b10 - a03*b09)*invDet; + dest[2] = (a31*b05 - a32*b04 + a33*b03)*invDet; + dest[3] = (-a21*b05 + a22*b04 - a23*b03)*invDet; + dest[4] = (-a10*b11 + a12*b08 - a13*b07)*invDet; + dest[5] = (a00*b11 - a02*b08 + a03*b07)*invDet; + dest[6] = (-a30*b05 + a32*b02 - a33*b01)*invDet; + dest[7] = (a20*b05 - a22*b02 + a23*b01)*invDet; + dest[8] = (a10*b10 - a11*b08 + a13*b06)*invDet; + dest[9] = (-a00*b10 + a01*b08 - a03*b06)*invDet; + dest[10] = (a30*b04 - a31*b02 + a33*b00)*invDet; + dest[11] = (-a20*b04 + a21*b02 - a23*b00)*invDet; + dest[12] = (-a10*b09 + a11*b07 - a12*b06)*invDet; + dest[13] = (a00*b09 - a01*b07 + a02*b06)*invDet; + dest[14] = (-a30*b03 + a31*b01 - a32*b00)*invDet; + dest[15] = (a20*b03 - a21*b01 + a22*b00)*invDet; + + return dest; +}; + +/* + * mat4.toRotationMat + * Copies the upper 3x3 elements of a mat4 into another mat4 + * + * Params: + * mat - mat4 containing values to copy + * dest - Optional, mat4 receiving copied values + * + * Returns: + * dest is specified, a new mat4 otherwise + */ +mat4.toRotationMat = function(mat, dest) { + if(!dest) { dest = mat4.create(); } + + dest[0] = mat[0]; + dest[1] = mat[1]; + dest[2] = mat[2]; + dest[3] = mat[3]; + dest[4] = mat[4]; + dest[5] = mat[5]; + dest[6] = mat[6]; + dest[7] = mat[7]; + dest[8] = mat[8]; + dest[9] = mat[9]; + dest[10] = mat[10]; + dest[11] = mat[11]; + dest[12] = 0; + dest[13] = 0; + dest[14] = 0; + dest[15] = 1; + + return dest; +}; + +/* + * mat4.toMat3 + * Copies the upper 3x3 elements of a mat4 into a mat3 + * + * Params: + * mat - mat4 containing values to copy + * dest - Optional, mat3 receiving copied values + * + * Returns: + * dest is specified, a new mat3 otherwise + */ +mat4.toMat3 = function(mat, dest) { + if(!dest) { dest = mat3.create(); } + + dest[0] = mat[0]; + dest[1] = mat[1]; + dest[2] = mat[2]; + dest[3] = mat[4]; + dest[4] = mat[5]; + dest[5] = mat[6]; + dest[6] = mat[8]; + dest[7] = mat[9]; + dest[8] = mat[10]; + + return dest; +}; + +/* + * mat4.toInverseMat3 + * Calculates the inverse of the upper 3x3 elements of a mat4 and copies the result into a mat3 + * The resulting matrix is useful for calculating transformed normals + * + * Params: + * mat - mat4 containing values to invert and copy + * dest - Optional, mat3 receiving values + * + * Returns: + * dest is specified, a new mat3 otherwise + */ +mat4.toInverseMat3 = function(mat, dest) { + // Cache the matrix values (makes for huge speed increases!) + var a00 = mat[0], a01 = mat[1], a02 = mat[2]; + var a10 = mat[4], a11 = mat[5], a12 = mat[6]; + var a20 = mat[8], a21 = mat[9], a22 = mat[10]; + + var b01 = a22*a11-a12*a21; + var b11 = -a22*a10+a12*a20; + var b21 = a21*a10-a11*a20; + + var d = a00*b01 + a01*b11 + a02*b21; + if (!d) { return null; } + var id = 1/d; + + if(!dest) { dest = mat3.create(); } + + dest[0] = b01*id; + dest[1] = (-a22*a01 + a02*a21)*id; + dest[2] = (a12*a01 - a02*a11)*id; + dest[3] = b11*id; + dest[4] = (a22*a00 - a02*a20)*id; + dest[5] = (-a12*a00 + a02*a10)*id; + dest[6] = b21*id; + dest[7] = (-a21*a00 + a01*a20)*id; + dest[8] = (a11*a00 - a01*a10)*id; + + return dest; +}; + +/* + * mat4.multiply + * Performs a matrix multiplication + * + * Params: + * mat - mat4, first operand + * mat2 - mat4, second operand + * dest - Optional, mat4 receiving operation result. If not specified result is written to mat + * + * Returns: + * dest if specified, mat otherwise + */ +mat4.multiply = function(mat, mat2, dest) { + if(!dest) { dest = mat; } + + // Cache the matrix values (makes for huge speed increases!) + var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3]; + var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7]; + var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11]; + var a30 = mat[12], a31 = mat[13], a32 = mat[14], a33 = mat[15]; + + var b00 = mat2[0], b01 = mat2[1], b02 = mat2[2], b03 = mat2[3]; + var b10 = mat2[4], b11 = mat2[5], b12 = mat2[6], b13 = mat2[7]; + var b20 = mat2[8], b21 = mat2[9], b22 = mat2[10], b23 = mat2[11]; + var b30 = mat2[12], b31 = mat2[13], b32 = mat2[14], b33 = mat2[15]; + + dest[0] = b00*a00 + b01*a10 + b02*a20 + b03*a30; + dest[1] = b00*a01 + b01*a11 + b02*a21 + b03*a31; + dest[2] = b00*a02 + b01*a12 + b02*a22 + b03*a32; + dest[3] = b00*a03 + b01*a13 + b02*a23 + b03*a33; + dest[4] = b10*a00 + b11*a10 + b12*a20 + b13*a30; + dest[5] = b10*a01 + b11*a11 + b12*a21 + b13*a31; + dest[6] = b10*a02 + b11*a12 + b12*a22 + b13*a32; + dest[7] = b10*a03 + b11*a13 + b12*a23 + b13*a33; + dest[8] = b20*a00 + b21*a10 + b22*a20 + b23*a30; + dest[9] = b20*a01 + b21*a11 + b22*a21 + b23*a31; + dest[10] = b20*a02 + b21*a12 + b22*a22 + b23*a32; + dest[11] = b20*a03 + b21*a13 + b22*a23 + b23*a33; + dest[12] = b30*a00 + b31*a10 + b32*a20 + b33*a30; + dest[13] = b30*a01 + b31*a11 + b32*a21 + b33*a31; + dest[14] = b30*a02 + b31*a12 + b32*a22 + b33*a32; + dest[15] = b30*a03 + b31*a13 + b32*a23 + b33*a33; + + return dest; +}; + +/* + * mat4.multiplyVec3 + * Transforms a vec3 with the given matrix + * 4th vector component is implicitly '1' + * + * Params: + * mat - mat4 to transform the vector with + * vec - vec3 to transform + * dest - Optional, vec3 receiving operation result. If not specified result is written to vec + * + * Returns: + * dest if specified, vec otherwise + */ +mat4.multiplyVec3 = function(mat, vec, dest) { + if(!dest) { dest = vec; } + + var x = vec[0], y = vec[1], z = vec[2]; + + dest[0] = mat[0]*x + mat[4]*y + mat[8]*z + mat[12]; + dest[1] = mat[1]*x + mat[5]*y + mat[9]*z + mat[13]; + dest[2] = mat[2]*x + mat[6]*y + mat[10]*z + mat[14]; + + return dest; +}; + +/* + * mat4.multiplyVec4 + * Transforms a vec4 with the given matrix + * + * Params: + * mat - mat4 to transform the vector with + * vec - vec4 to transform + * dest - Optional, vec4 receiving operation result. If not specified result is written to vec + * + * Returns: + * dest if specified, vec otherwise + */ +mat4.multiplyVec4 = function(mat, vec, dest) { + if(!dest) { dest = vec; } + + var x = vec[0], y = vec[1], z = vec[2], w = vec[3]; + + dest[0] = mat[0]*x + mat[4]*y + mat[8]*z + mat[12]*w; + dest[1] = mat[1]*x + mat[5]*y + mat[9]*z + mat[13]*w; + dest[2] = mat[2]*x + mat[6]*y + mat[10]*z + mat[14]*w; + dest[3] = mat[3]*x + mat[7]*y + mat[11]*z + mat[15]*w; + + return dest; +}; + +/* + * mat4.translate + * Translates a matrix by the given vector + * + * Params: + * mat - mat4 to translate + * vec - vec3 specifying the translation + * dest - Optional, mat4 receiving operation result. If not specified result is written to mat + * + * Returns: + * dest if specified, mat otherwise + */ +mat4.translate = function(mat, vec, dest) { + var x = vec[0], y = vec[1], z = vec[2]; + + if(!dest || mat == dest) { + mat[12] = mat[0]*x + mat[4]*y + mat[8]*z + mat[12]; + mat[13] = mat[1]*x + mat[5]*y + mat[9]*z + mat[13]; + mat[14] = mat[2]*x + mat[6]*y + mat[10]*z + mat[14]; + mat[15] = mat[3]*x + mat[7]*y + mat[11]*z + mat[15]; + return mat; + } + + var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3]; + var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7]; + var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11]; + + dest[0] = a00; + dest[1] = a01; + dest[2] = a02; + dest[3] = a03; + dest[4] = a10; + dest[5] = a11; + dest[6] = a12; + dest[7] = a13; + dest[8] = a20; + dest[9] = a21; + dest[10] = a22; + dest[11] = a23; + + dest[12] = a00*x + a10*y + a20*z + mat[12]; + dest[13] = a01*x + a11*y + a21*z + mat[13]; + dest[14] = a02*x + a12*y + a22*z + mat[14]; + dest[15] = a03*x + a13*y + a23*z + mat[15]; + return dest; +}; + +/* + * mat4.scale + * Scales a matrix by the given vector + * + * Params: + * mat - mat4 to scale + * vec - vec3 specifying the scale for each axis + * dest - Optional, mat4 receiving operation result. If not specified result is written to mat + * + * Returns: + * dest if specified, mat otherwise + */ +mat4.scale = function(mat, vec, dest) { + var x = vec[0], y = vec[1], z = vec[2]; + + if(!dest || mat == dest) { + mat[0] *= x; + mat[1] *= x; + mat[2] *= x; + mat[3] *= x; + mat[4] *= y; + mat[5] *= y; + mat[6] *= y; + mat[7] *= y; + mat[8] *= z; + mat[9] *= z; + mat[10] *= z; + mat[11] *= z; + return mat; + } + + dest[0] = mat[0]*x; + dest[1] = mat[1]*x; + dest[2] = mat[2]*x; + dest[3] = mat[3]*x; + dest[4] = mat[4]*y; + dest[5] = mat[5]*y; + dest[6] = mat[6]*y; + dest[7] = mat[7]*y; + dest[8] = mat[8]*z; + dest[9] = mat[9]*z; + dest[10] = mat[10]*z; + dest[11] = mat[11]*z; + dest[12] = mat[12]; + dest[13] = mat[13]; + dest[14] = mat[14]; + dest[15] = mat[15]; + return dest; +}; + +/* + * mat4.rotate + * Rotates a matrix by the given angle around the specified axis + * If rotating around a primary axis (X,Y,Z) one of the specialized rotation functions should be used instead for performance + * + * Params: + * mat - mat4 to rotate + * angle - angle (in radians) to rotate + * axis - vec3 representing the axis to rotate around + * dest - Optional, mat4 receiving operation result. If not specified result is written to mat + * + * Returns: + * dest if specified, mat otherwise + */ +mat4.rotate = function(mat, angle, axis, dest) { + var x = axis[0], y = axis[1], z = axis[2]; + var len = Math.sqrt(x*x + y*y + z*z); + if (!len) { return null; } + if (len != 1) { + len = 1 / len; + x *= len; + y *= len; + z *= len; + } + + var s = Math.sin(angle); + var c = Math.cos(angle); + var t = 1-c; + + // Cache the matrix values (makes for huge speed increases!) + var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3]; + var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7]; + var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11]; + + // Construct the elements of the rotation matrix + var b00 = x*x*t + c, b01 = y*x*t + z*s, b02 = z*x*t - y*s; + var b10 = x*y*t - z*s, b11 = y*y*t + c, b12 = z*y*t + x*s; + var b20 = x*z*t + y*s, b21 = y*z*t - x*s, b22 = z*z*t + c; + + if(!dest) { + dest = mat; + } else if(mat != dest) { // If the source and destination differ, copy the unchanged last row + dest[12] = mat[12]; + dest[13] = mat[13]; + dest[14] = mat[14]; + dest[15] = mat[15]; + } + + // Perform rotation-specific matrix multiplication + dest[0] = a00*b00 + a10*b01 + a20*b02; + dest[1] = a01*b00 + a11*b01 + a21*b02; + dest[2] = a02*b00 + a12*b01 + a22*b02; + dest[3] = a03*b00 + a13*b01 + a23*b02; + + dest[4] = a00*b10 + a10*b11 + a20*b12; + dest[5] = a01*b10 + a11*b11 + a21*b12; + dest[6] = a02*b10 + a12*b11 + a22*b12; + dest[7] = a03*b10 + a13*b11 + a23*b12; + + dest[8] = a00*b20 + a10*b21 + a20*b22; + dest[9] = a01*b20 + a11*b21 + a21*b22; + dest[10] = a02*b20 + a12*b21 + a22*b22; + dest[11] = a03*b20 + a13*b21 + a23*b22; + return dest; +}; + +/* + * mat4.rotateX + * Rotates a matrix by the given angle around the X axis + * + * Params: + * mat - mat4 to rotate + * angle - angle (in radians) to rotate + * dest - Optional, mat4 receiving operation result. If not specified result is written to mat + * + * Returns: + * dest if specified, mat otherwise + */ +mat4.rotateX = function(mat, angle, dest) { + var s = Math.sin(angle); + var c = Math.cos(angle); + + // Cache the matrix values (makes for huge speed increases!) + var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7]; + var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11]; + + if(!dest) { + dest = mat; + } else if(mat != dest) { // If the source and destination differ, copy the unchanged rows + dest[0] = mat[0]; + dest[1] = mat[1]; + dest[2] = mat[2]; + dest[3] = mat[3]; + + dest[12] = mat[12]; + dest[13] = mat[13]; + dest[14] = mat[14]; + dest[15] = mat[15]; + } + + // Perform axis-specific matrix multiplication + dest[4] = a10*c + a20*s; + dest[5] = a11*c + a21*s; + dest[6] = a12*c + a22*s; + dest[7] = a13*c + a23*s; + + dest[8] = a10*-s + a20*c; + dest[9] = a11*-s + a21*c; + dest[10] = a12*-s + a22*c; + dest[11] = a13*-s + a23*c; + return dest; +}; + +/* + * mat4.rotateY + * Rotates a matrix by the given angle around the Y axis + * + * Params: + * mat - mat4 to rotate + * angle - angle (in radians) to rotate + * dest - Optional, mat4 receiving operation result. If not specified result is written to mat + * + * Returns: + * dest if specified, mat otherwise + */ +mat4.rotateY = function(mat, angle, dest) { + var s = Math.sin(angle); + var c = Math.cos(angle); + + // Cache the matrix values (makes for huge speed increases!) + var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3]; + var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11]; + + if(!dest) { + dest = mat; + } else if(mat != dest) { // If the source and destination differ, copy the unchanged rows + dest[4] = mat[4]; + dest[5] = mat[5]; + dest[6] = mat[6]; + dest[7] = mat[7]; + + dest[12] = mat[12]; + dest[13] = mat[13]; + dest[14] = mat[14]; + dest[15] = mat[15]; + } + + // Perform axis-specific matrix multiplication + dest[0] = a00*c + a20*-s; + dest[1] = a01*c + a21*-s; + dest[2] = a02*c + a22*-s; + dest[3] = a03*c + a23*-s; + + dest[8] = a00*s + a20*c; + dest[9] = a01*s + a21*c; + dest[10] = a02*s + a22*c; + dest[11] = a03*s + a23*c; + return dest; +}; + +/* + * mat4.rotateZ + * Rotates a matrix by the given angle around the Z axis + * + * Params: + * mat - mat4 to rotate + * angle - angle (in radians) to rotate + * dest - Optional, mat4 receiving operation result. If not specified result is written to mat + * + * Returns: + * dest if specified, mat otherwise + */ +mat4.rotateZ = function(mat, angle, dest) { + var s = Math.sin(angle); + var c = Math.cos(angle); + + // Cache the matrix values (makes for huge speed increases!) + var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3]; + var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7]; + + if(!dest) { + dest = mat; + } else if(mat != dest) { // If the source and destination differ, copy the unchanged last row + dest[8] = mat[8]; + dest[9] = mat[9]; + dest[10] = mat[10]; + dest[11] = mat[11]; + + dest[12] = mat[12]; + dest[13] = mat[13]; + dest[14] = mat[14]; + dest[15] = mat[15]; + } + + // Perform axis-specific matrix multiplication + dest[0] = a00*c + a10*s; + dest[1] = a01*c + a11*s; + dest[2] = a02*c + a12*s; + dest[3] = a03*c + a13*s; + + dest[4] = a00*-s + a10*c; + dest[5] = a01*-s + a11*c; + dest[6] = a02*-s + a12*c; + dest[7] = a03*-s + a13*c; + + return dest; +}; + +/* + * mat4.frustum + * Generates a frustum matrix with the given bounds + * + * Params: + * left, right - scalar, left and right bounds of the frustum + * bottom, top - scalar, bottom and top bounds of the frustum + * near, far - scalar, near and far bounds of the frustum + * dest - Optional, mat4 frustum matrix will be written into + * + * Returns: + * dest if specified, a new mat4 otherwise + */ +mat4.frustum = function(left, right, bottom, top, near, far, dest) { + if(!dest) { dest = mat4.create(); } + var rl = (right - left); + var tb = (top - bottom); + var fn = (far - near); + dest[0] = (near*2) / rl; + dest[1] = 0; + dest[2] = 0; + dest[3] = 0; + dest[4] = 0; + dest[5] = (near*2) / tb; + dest[6] = 0; + dest[7] = 0; + dest[8] = (right + left) / rl; + dest[9] = (top + bottom) / tb; + dest[10] = -(far + near) / fn; + dest[11] = -1; + dest[12] = 0; + dest[13] = 0; + dest[14] = -(far*near*2) / fn; + dest[15] = 0; + return dest; +}; + +/* + * mat4.perspective + * Generates a perspective projection matrix with the given bounds + * + * Params: + * fovy - scalar, vertical field of view + * aspect - scalar, aspect ratio. typically viewport width/height + * near, far - scalar, near and far bounds of the frustum + * dest - Optional, mat4 frustum matrix will be written into + * + * Returns: + * dest if specified, a new mat4 otherwise + */ +mat4.perspective = function(fovy, aspect, near, far, dest) { + var top = near*Math.tan(fovy*Math.PI / 360.0); + var right = top*aspect; + return mat4.frustum(-right, right, -top, top, near, far, dest); +}; + +/* + * mat4.ortho + * Generates a orthogonal projection matrix with the given bounds + * + * Params: + * left, right - scalar, left and right bounds of the frustum + * bottom, top - scalar, bottom and top bounds of the frustum + * near, far - scalar, near and far bounds of the frustum + * dest - Optional, mat4 frustum matrix will be written into + * + * Returns: + * dest if specified, a new mat4 otherwise + */ +mat4.ortho = function(left, right, bottom, top, near, far, dest) { + if(!dest) { dest = mat4.create(); } + var rl = (right - left); + var tb = (top - bottom); + var fn = (far - near); + dest[0] = 2 / rl; + dest[1] = 0; + dest[2] = 0; + dest[3] = 0; + dest[4] = 0; + dest[5] = 2 / tb; + dest[6] = 0; + dest[7] = 0; + dest[8] = 0; + dest[9] = 0; + dest[10] = -2 / fn; + dest[11] = 0; + dest[12] = -(left + right) / rl; + dest[13] = -(top + bottom) / tb; + dest[14] = -(far + near) / fn; + dest[15] = 1; + return dest; +}; + +/* + * mat4.ortho + * Generates a look-at matrix with the given eye position, focal point, and up axis + * + * Params: + * eye - vec3, position of the viewer + * center - vec3, point the viewer is looking at + * up - vec3 pointing "up" + * dest - Optional, mat4 frustum matrix will be written into + * + * Returns: + * dest if specified, a new mat4 otherwise + */ +mat4.lookAt = function(eye, center, up, dest) { + if(!dest) { dest = mat4.create(); } + + var eyex = eye[0], + eyey = eye[1], + eyez = eye[2], + upx = up[0], + upy = up[1], + upz = up[2], + centerx = center[0], + centery = center[1], + centerz = center[2]; + + if (eyex == centerx && eyey == centery && eyez == centerz) { + return mat4.identity(dest); + } + + var z0,z1,z2,x0,x1,x2,y0,y1,y2,len; + + //vec3.direction(eye, center, z); + z0 = eyex - center[0]; + z1 = eyey - center[1]; + z2 = eyez - center[2]; + + // normalize (no check needed for 0 because of early return) + len = 1/Math.sqrt(z0*z0 + z1*z1 + z2*z2); + z0 *= len; + z1 *= len; + z2 *= len; + + //vec3.normalize(vec3.cross(up, z, x)); + x0 = upy*z2 - upz*z1; + x1 = upz*z0 - upx*z2; + x2 = upx*z1 - upy*z0; + len = Math.sqrt(x0*x0 + x1*x1 + x2*x2); + if (!len) { + x0 = 0; + x1 = 0; + x2 = 0; + } else { + len = 1/len; + x0 *= len; + x1 *= len; + x2 *= len; + }; + + //vec3.normalize(vec3.cross(z, x, y)); + y0 = z1*x2 - z2*x1; + y1 = z2*x0 - z0*x2; + y2 = z0*x1 - z1*x0; + + len = Math.sqrt(y0*y0 + y1*y1 + y2*y2); + if (!len) { + y0 = 0; + y1 = 0; + y2 = 0; + } else { + len = 1/len; + y0 *= len; + y1 *= len; + y2 *= len; + } + + dest[0] = x0; + dest[1] = y0; + dest[2] = z0; + dest[3] = 0; + dest[4] = x1; + dest[5] = y1; + dest[6] = z1; + dest[7] = 0; + dest[8] = x2; + dest[9] = y2; + dest[10] = z2; + dest[11] = 0; + dest[12] = -(x0*eyex + x1*eyey + x2*eyez); + dest[13] = -(y0*eyex + y1*eyey + y2*eyez); + dest[14] = -(z0*eyex + z1*eyey + z2*eyez); + dest[15] = 1; + + return dest; +}; + +/* + * mat4.str + * Returns a string representation of a mat4 + * + * Params: + * mat - mat4 to represent as a string + * + * Returns: + * string representation of mat + */ +mat4.str = function(mat) { + return '[' + mat[0] + ', ' + mat[1] + ', ' + mat[2] + ', ' + mat[3] + + ',\n '+ mat[4] + ', ' + mat[5] + ', ' + mat[6] + ', ' + mat[7] + + ',\n '+ mat[8] + ', ' + mat[9] + ', ' + mat[10] + ', ' + mat[11] + + ',\n '+ mat[12] + ', ' + mat[13] + ', ' + mat[14] + ', ' + mat[15] + ']'; +}; + +/* + * quat4 - Quaternions + */ +quat4 = {}; + +/* + * quat4.create + * Creates a new instance of a quat4 using the default array type + * Any javascript array containing at least 4 numeric elements can serve as a quat4 + * + * Params: + * quat - Optional, quat4 containing values to initialize with + * + * Returns: + * New quat4 + */ +quat4.create = function(quat) { + var dest; + + if(quat) { + dest = new glMatrixArrayType(4); + dest[0] = quat[0]; + dest[1] = quat[1]; + dest[2] = quat[2]; + dest[3] = quat[3]; + } else { + if(glMatrixArrayType === Array) + dest = new glMatrixArrayType([0,0,0,0]); + else + dest = new glMatrixArrayType(4); + } + + return dest; +}; + +/* + * quat4.set + * Copies the values of one quat4 to another + * + * Params: + * quat - quat4 containing values to copy + * dest - quat4 receiving copied values + * + * Returns: + * dest + */ +quat4.set = function(quat, dest) { + dest[0] = quat[0]; + dest[1] = quat[1]; + dest[2] = quat[2]; + dest[3] = quat[3]; + + return dest; +}; + +/* + * quat4.calculateW + * Calculates the W component of a quat4 from the X, Y, and Z components. + * Assumes that quaternion is 1 unit in length. + * Any existing W component will be ignored. + * + * Params: + * quat - quat4 to calculate W component of + * dest - Optional, quat4 receiving calculated values. If not specified result is written to quat + * + * Returns: + * dest if specified, quat otherwise + */ +quat4.calculateW = function(quat, dest) { + var x = quat[0], y = quat[1], z = quat[2]; + + if(!dest || quat == dest) { + quat[3] = -Math.sqrt(Math.abs(1.0 - x*x - y*y - z*z)); + return quat; + } + dest[0] = x; + dest[1] = y; + dest[2] = z; + dest[3] = -Math.sqrt(Math.abs(1.0 - x*x - y*y - z*z)); + return dest; +}; + +/* + * quat4.inverse + * Calculates the inverse of a quat4 + * + * Params: + * quat - quat4 to calculate inverse of + * dest - Optional, quat4 receiving inverse values. If not specified result is written to quat + * + * Returns: + * dest if specified, quat otherwise + */ +quat4.inverse = function(quat, dest) { + if(!dest || quat == dest) { + quat[0] *= -1; + quat[1] *= -1; + quat[2] *= -1; + return quat; + } + dest[0] = -quat[0]; + dest[1] = -quat[1]; + dest[2] = -quat[2]; + dest[3] = quat[3]; + return dest; +}; + +/* + * quat4.length + * Calculates the length of a quat4 + * + * Params: + * quat - quat4 to calculate length of + * + * Returns: + * Length of quat + */ +quat4.length = function(quat) { + var x = quat[0], y = quat[1], z = quat[2], w = quat[3]; + return Math.sqrt(x*x + y*y + z*z + w*w); +}; + +/* + * quat4.normalize + * Generates a unit quaternion of the same direction as the provided quat4 + * If quaternion length is 0, returns [0, 0, 0, 0] + * + * Params: + * quat - quat4 to normalize + * dest - Optional, quat4 receiving operation result. If not specified result is written to quat + * + * Returns: + * dest if specified, quat otherwise + */ +quat4.normalize = function(quat, dest) { + if(!dest) { dest = quat; } + + var x = quat[0], y = quat[1], z = quat[2], w = quat[3]; + var len = Math.sqrt(x*x + y*y + z*z + w*w); + if(len == 0) { + dest[0] = 0; + dest[1] = 0; + dest[2] = 0; + dest[3] = 0; + return dest; + } + len = 1/len; + dest[0] = x * len; + dest[1] = y * len; + dest[2] = z * len; + dest[3] = w * len; + + return dest; +}; + +/* + * quat4.multiply + * Performs a quaternion multiplication + * + * Params: + * quat - quat4, first operand + * quat2 - quat4, second operand + * dest - Optional, quat4 receiving operation result. If not specified result is written to quat + * + * Returns: + * dest if specified, quat otherwise + */ +quat4.multiply = function(quat, quat2, dest) { + if(!dest) { dest = quat; } + + var qax = quat[0], qay = quat[1], qaz = quat[2], qaw = quat[3]; + var qbx = quat2[0], qby = quat2[1], qbz = quat2[2], qbw = quat2[3]; + + dest[0] = qax*qbw + qaw*qbx + qay*qbz - qaz*qby; + dest[1] = qay*qbw + qaw*qby + qaz*qbx - qax*qbz; + dest[2] = qaz*qbw + qaw*qbz + qax*qby - qay*qbx; + dest[3] = qaw*qbw - qax*qbx - qay*qby - qaz*qbz; + + return dest; +}; + +/* + * quat4.multiplyVec3 + * Transforms a vec3 with the given quaternion + * + * Params: + * quat - quat4 to transform the vector with + * vec - vec3 to transform + * dest - Optional, vec3 receiving operation result. If not specified result is written to vec + * + * Returns: + * dest if specified, vec otherwise + */ +quat4.multiplyVec3 = function(quat, vec, dest) { + if(!dest) { dest = vec; } + + var x = vec[0], y = vec[1], z = vec[2]; + var qx = quat[0], qy = quat[1], qz = quat[2], qw = quat[3]; + + // calculate quat * vec + var ix = qw*x + qy*z - qz*y; + var iy = qw*y + qz*x - qx*z; + var iz = qw*z + qx*y - qy*x; + var iw = -qx*x - qy*y - qz*z; + + // calculate result * inverse quat + dest[0] = ix*qw + iw*-qx + iy*-qz - iz*-qy; + dest[1] = iy*qw + iw*-qy + iz*-qx - ix*-qz; + dest[2] = iz*qw + iw*-qz + ix*-qy - iy*-qx; + + return dest; +}; + +/* + * quat4.toMat3 + * Calculates a 3x3 matrix from the given quat4 + * + * Params: + * quat - quat4 to create matrix from + * dest - Optional, mat3 receiving operation result + * + * Returns: + * dest if specified, a new mat3 otherwise + */ +quat4.toMat3 = function(quat, dest) { + if(!dest) { dest = mat3.create(); } + + var x = quat[0], y = quat[1], z = quat[2], w = quat[3]; + + var x2 = x + x; + var y2 = y + y; + var z2 = z + z; + + var xx = x*x2; + var xy = x*y2; + var xz = x*z2; + + var yy = y*y2; + var yz = y*z2; + var zz = z*z2; + + var wx = w*x2; + var wy = w*y2; + var wz = w*z2; + + dest[0] = 1 - (yy + zz); + dest[1] = xy - wz; + dest[2] = xz + wy; + + dest[3] = xy + wz; + dest[4] = 1 - (xx + zz); + dest[5] = yz - wx; + + dest[6] = xz - wy; + dest[7] = yz + wx; + dest[8] = 1 - (xx + yy); + + return dest; +}; + +/* + * quat4.toMat4 + * Calculates a 4x4 matrix from the given quat4 + * + * Params: + * quat - quat4 to create matrix from + * dest - Optional, mat4 receiving operation result + * + * Returns: + * dest if specified, a new mat4 otherwise + */ +quat4.toMat4 = function(quat, dest) { + if(!dest) { dest = mat4.create(); } + + var x = quat[0], y = quat[1], z = quat[2], w = quat[3]; + + var x2 = x + x; + var y2 = y + y; + var z2 = z + z; + + var xx = x*x2; + var xy = x*y2; + var xz = x*z2; + + var yy = y*y2; + var yz = y*z2; + var zz = z*z2; + + var wx = w*x2; + var wy = w*y2; + var wz = w*z2; + + dest[0] = 1 - (yy + zz); + dest[1] = xy - wz; + dest[2] = xz + wy; + dest[3] = 0; + + dest[4] = xy + wz; + dest[5] = 1 - (xx + zz); + dest[6] = yz - wx; + dest[7] = 0; + + dest[8] = xz - wy; + dest[9] = yz + wx; + dest[10] = 1 - (xx + yy); + dest[11] = 0; + + dest[12] = 0; + dest[13] = 0; + dest[14] = 0; + dest[15] = 1; + + return dest; +}; + +/* + * quat4.slerp + * Performs a spherical linear interpolation between two quat4 + * + * Params: + * quat - quat4, first quaternion + * quat2 - quat4, second quaternion + * slerp - interpolation amount between the two inputs + * dest - Optional, quat4 receiving operation result. If not specified result is written to quat + * + * Returns: + * dest if specified, quat otherwise + */ +quat4.slerp = function(quat, quat2, slerp, dest) { + if(!dest) { dest = quat; } + + var cosHalfTheta = quat[0]*quat2[0] + quat[1]*quat2[1] + quat[2]*quat2[2] + quat[3]*quat2[3]; + + if (Math.abs(cosHalfTheta) >= 1.0){ + if(dest != quat) { + dest[0] = quat[0]; + dest[1] = quat[1]; + dest[2] = quat[2]; + dest[3] = quat[3]; + } + return dest; + } + + var halfTheta = Math.acos(cosHalfTheta); + var sinHalfTheta = Math.sqrt(1.0 - cosHalfTheta*cosHalfTheta); + + if (Math.abs(sinHalfTheta) < 0.001){ + dest[0] = (quat[0]*0.5 + quat2[0]*0.5); + dest[1] = (quat[1]*0.5 + quat2[1]*0.5); + dest[2] = (quat[2]*0.5 + quat2[2]*0.5); + dest[3] = (quat[3]*0.5 + quat2[3]*0.5); + return dest; + } + + var ratioA = Math.sin((1 - slerp)*halfTheta) / sinHalfTheta; + var ratioB = Math.sin(slerp*halfTheta) / sinHalfTheta; + + dest[0] = (quat[0]*ratioA + quat2[0]*ratioB); + dest[1] = (quat[1]*ratioA + quat2[1]*ratioB); + dest[2] = (quat[2]*ratioA + quat2[2]*ratioB); + dest[3] = (quat[3]*ratioA + quat2[3]*ratioB); + + return dest; +}; + + +/* + * quat4.str + * Returns a string representation of a quaternion + * + * Params: + * quat - quat4 to represent as a string + * + * Returns: + * string representation of quat + */ +quat4.str = function(quat) { + return '[' + quat[0] + ', ' + quat[1] + ', ' + quat[2] + ', ' + quat[3] + ']'; +}; + + +define("glMatrix", ["typedefs"], (function (global) { + return function () { + var ret, fn; + return ret || global.glMatrix; + }; +}(this))); + +/* + +Copyright (C) 2011 + - Christoph Oberhofer (ar.oberhofer@gmail.com) + - Jens Grubert (jg@jensgrubert.de) + - Gerhard Reitmayr (reitmayr@icg.tugraz.at) +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . +*/ + + +/* + * glMatrixAddon.js + * Extension to the glMatrix library. The original glMatrix library + * was created by Brandon Jones. + */ + + +mat4.xVec4 = function(mat, vec, dest){ + if(!dest) { dest = vec; } + var x = vec[0], y = vec[1], z = vec[2], w = vec[3]; + + dest[0] = mat[0]*x + mat[1]*y + mat[2]*z + mat[3]*w; + dest[1] = mat[4]*x + mat[5]*y + mat[6]*z + mat[7]*w; + dest[2] = mat[8]*x + mat[9]*y + mat[10]*z + mat[11]*w; + dest[3] = mat[12]*x + mat[13]*y + mat[14]*z + mat[15]*w; + + return dest; +}; + +mat3.scale = function(mat, scalar, dest){ + if(!dest || mat == dest) { + mat[0] *= scalar; + mat[1] *= scalar; + mat[2] *= scalar; + mat[3] *= scalar; + mat[4] *= scalar; + mat[5] *= scalar; + mat[6] *= scalar; + mat[7] *= scalar; + mat[8] *= scalar; + return mat; + } + dest = mat3.create(); + dest[0] = mat[0]*scalar; + dest[1] = mat[1]*scalar; + dest[2] = mat[2]*scalar; + dest[3] = mat[3]*scalar; + dest[4] = mat[4]*scalar; + dest[5] = mat[5]*scalar; + dest[6] = mat[6]*scalar; + dest[7] = mat[7]*scalar; + dest[8] = mat[8]*scalar; + return dest; +}; + +mat3.inverse = function(mat, dest){ + if(!dest) { dest = mat; } + + var ha00 = mat[0], ha01 = mat[1], ha02 = mat[2]; + var ha10 = mat[3], ha11 = mat[4], ha12 = mat[5]; + var ha20 = mat[6], ha21 = mat[7], ha22 = mat[8]; + + var invDetA = 1/(ha00*ha11*ha22 + ha01*ha12*ha20 + ha02*ha10*ha21 - ha02*ha11*ha20 - ha01*ha10*ha22 - ha00*ha12*ha21); + dest[0] = (ha11*ha22 - ha12*ha21)*invDetA; + dest[1] = (ha02*ha21 - ha01*ha22)*invDetA; + dest[2] = (ha01*ha12 - ha02*ha11)*invDetA; + dest[3] = (ha12*ha20 - ha10*ha22)*invDetA; + dest[4] = (ha00*ha22 - ha02*ha20)*invDetA; + dest[5] = (ha02*ha10 - ha00*ha12)*invDetA; + dest[6] = (ha10*ha21 - ha11*ha20)*invDetA; + dest[7] = (ha01*ha20 - ha00*ha21)*invDetA; + dest[8] = (ha00*ha11 - ha01*ha10)*invDetA; + return dest; +}; + +mat3.multiply = function(mat, mat2, dest) { + if(!dest) { dest = mat; } + + var ha00 = mat[0], ha01 = mat[1], ha02 = mat[2]; + var ha10 = mat[3], ha11 = mat[4], ha12 = mat[5]; + var ha20 = mat[6], ha21 = mat[7], ha22 = mat[8]; + + var hb00 = mat2[0], hb01 = mat2[1], hb02 = mat2[2]; + var hb10 = mat2[3], hb11 = mat2[4], hb12 = mat2[5]; + var hb20 = mat2[6], hb21 = mat2[7], hb22 = mat2[8]; + + dest[0] = ha00*hb00 + ha01*hb10 + ha02*hb20; + dest[1] = ha00*hb01 + ha01*hb11 + ha02*hb21; + dest[2] = ha00*hb02 + ha01*hb12 + ha02*hb22; + + dest[3] = ha10*hb00 + ha11*hb10 + ha12*hb20; + dest[4] = ha10*hb01 + ha11*hb11 + ha12*hb21; + dest[5] = ha10*hb02 + ha11*hb12 + ha12*hb22; + + dest[6] = ha20*hb00 + ha21*hb10 + ha22*hb20; + dest[7] = ha20*hb01 + ha21*hb11 + ha22*hb21; + dest[8] = ha20*hb02 + ha21*hb12 + ha22*hb22; + return dest; +}; + +mat3.xVec3 = function(mat, vec, dest){ + if(!dest) { dest = vec; } + var x = vec[0], y = vec[1], z = vec[2]; + + dest[0] = mat[0]*x + mat[1]*y + mat[2]*z; + dest[1] = mat[3]*x + mat[4]*y + mat[5]*z; + dest[2] = mat[6]*x + mat[7]*y + mat[8]*z; + + return dest; +}; + +var vec4={}; + +vec4.create = function(vec){ + var dest; + + if(vec) { + dest = new glMatrixArrayType(4); + dest[0] = vec[0]; + dest[1] = vec[1]; + dest[2] = vec[2]; + dest[3] = vec[3]; + } else { + if(glMatrixArrayType === Array) + dest = new glMatrixArrayType([0,0,0,0]); + else + dest = new glMatrixArrayType(4); + } + + return dest; +}; + +vec4.project = function(vec, dest){ + if(!dest) { dest = vec; } + + dest[0] = vec[0]/vec[3]; + dest[1] = vec[1]/vec[3]; + dest[2] = vec[2]/vec[3]; + return dest; +}; + +vec4.scale = function(vec, val, dest){ + if(!dest || vec == dest) { + vec[0] *= val; + vec[1] *= val; + vec[2] *= val; + vec[4] *= val; + return vec; + } + + dest[0] = vec[0]*val; + dest[1] = vec[1]*val; + dest[2] = vec[2]*val; + dest[3] = vec[3]*val; + return dest; +}; + +vec4.xMat4 = function(vec, mat, dest){ + if(!dest) { dest = vec; } + + var x = vec[0], y = vec[1], z = vec[2], w = vec[3]; + + dest[0] = mat[0]*x + mat[4]*y + mat[8]*z + mat[12]*w; + dest[1] = mat[1]*x + mat[5]*y + mat[9]*z + mat[13]*w; + dest[2] = mat[2]*x + mat[6]*y + mat[10]*z + mat[14]*w; + dest[3] = mat[3]*x + mat[7]*y + mat[11]*z + mat[15]*w; + + return dest; +}; + + +var mat2 = {}; + +mat2.create = function(mat){ + var dest; + + if(mat) { + dest = new glMatrixArrayType(4); + dest[0] = mat[0]; + dest[1] = mat[1]; + dest[2] = mat[2]; + dest[3] = mat[3]; + } else { + if(glMatrixArrayType === Array) + dest = new glMatrixArrayType([0,0,0,0]); + else + dest = new glMatrixArrayType(4); + } + + return dest; +}; + +mat2.xVec2 = function(mat, vec, dest){ + if(!dest) { dest = vec; } + var x = vec[0], y = vec[1]; + + dest[0] = mat[0]*x + mat[1]*y; + dest[1] = mat[2]*x + mat[3]*y; + + return dest; +}; + +mat2.scale = function(mat, scale, dest){ + if(!dest || mat == dest) { + mat[0] *= scale; + mat[1] *= scale; + mat[2] *= scale; + mat[3] *= scale; + return mat; + } + + dest[0] = mat[0]*scale; + dest[1] = mat[1]*scale; + dest[2] = mat[2]*scale; + dest[3] = mat[3]*scale; + return dest; +}; + +mat2.determinant = function(mat){ + return mat[0]*mat[3] - mat[1]*mat[2]; +}; + +mat2.inverse = function(mat){ + var scale = 1/(mat2.determinant(mat)); + var a = mat[3]*scale, + b = -mat[1]*scale, + c = -mat[2]*scale, + d = mat[0]; + mat[0] = a; + mat[1] = b; + mat[2] = c; + mat[3] = d; + return mat; +}; + +var vec2 = {}; +vec2.create = function(vec){ + var dest; + + if(vec) { + dest = new glMatrixArrayType(2); + dest[0] = vec[0]; + dest[1] = vec[1]; + } else { + if(glMatrixArrayType === Array) + dest = new glMatrixArrayType([0,0]); + else + dest = new glMatrixArrayType(2); + } + + return dest; +}; + +vec2.subtract = function(vec, vec2, dest) { + if(!dest || vec == dest) { + vec[0] -= vec2[0]; + vec[1] -= vec2[1]; + return vec; + } + + dest[0] = vec[0] - vec2[0]; + dest[1] = vec[1] - vec2[1]; + return dest; +}; + +vec2.add = function(vec, vec2, dest) { + if(!dest || vec == dest) { + vec[0] += vec2[0]; + vec[1] += vec2[1]; + return vec; + } + + dest[0] = vec[0] + vec2[0]; + dest[1] = vec[1] + vec2[1]; + return dest; +}; + +vec2.scale = function(vec, val, dest) { + if(!dest || vec == dest) { + vec[0] *= val; + vec[1] *= val; + return vec; + } + + dest[0] = vec[0]*val; + dest[1] = vec[1]*val; + return dest; +}; + +vec2.normalize = function(vec, dest) { + if(!dest) { dest = vec; } + + var x = vec[0], y = vec[1]; + var len = Math.sqrt(x*x + y*y); + + if (!len) { + dest[0] = 0; + dest[1] = 0; + return dest; + } else if (len == 1) { + dest[0] = x; + dest[1] = y; + return dest; + } + + len = 1 / len; + dest[0] = x*len; + dest[1] = y*len; + return dest; +}; + +vec2.dot = function(vec, vec2){ + return vec[0]*vec2[0] + vec[1]*vec2[1]; +}; + +vec2.multiply = function(vec, vec2, dest){ + if(!dest) { dest = vec; } + + dest[0] = vec[0]*vec2[0]; + dest[1] = vec[1]*vec2[1]; + return dest; +}; + +/** + * @param vec vec2 to be unprojected [x,y] -> [x,y,1] + * @returns vec3 unprojected vector + */ +vec2.unproject = function(vec){ + return vec3.create([vec[0], vec[1], 1]); +}; + +vec2.length = function(vec){ + return Math.sqrt(vec[0]*vec[0] + vec[1]*vec[1]); +}; + +vec2.perspectiveProject = function(vec){ + var result = vec2.create(vec); + return vec2.scale(result, 1/vec[2]); +}; + +/** + * @param vec vec3 to be projected [x,y,z] -> [x/z,y/z] + * @returns vec2 projected vector + */ +vec3.project = function(vec){ + return vec2.scale(vec2.create(vec), 1/vec[2]); +}; + +var vec6 = {}; +vec6.scale = function(vec, val, dest){ + if(!dest || vec == dest) { + vec[0] *= val; + vec[1] *= val; + vec[2] *= val; + vec[3] *= val; + vec[4] *= val; + vec[5] *= val; + return vec; + } + + dest[0] = vec[0]*val; + dest[1] = vec[1]*val; + dest[2] = vec[2]*val; + dest[3] = vec[3]*val; + dest[4] = vec[4]*val; + dest[5] = vec[5]*val; + return dest; +}; + +vec6.subtract = function(vec, vec2, dest){ + if(!dest || vec == dest) { + vec[0] -= vec2[0]; + vec[1] -= vec2[1]; + vec[2] -= vec2[2]; + vec[3] -= vec2[3]; + vec[4] -= vec2[4]; + vec[5] -= vec2[5]; + return vec; + } + + dest[0] = vec[0] - vec2[0]; + dest[1] = vec[1] - vec2[1]; + dest[2] = vec[2] - vec2[2]; + dest[3] = vec[3] - vec2[3]; + dest[4] = vec[4] - vec2[4]; + dest[5] = vec[5] - vec2[5]; + return dest; +}; + +vec6.dot = function(vec, vec2){ + return vec[0]*vec2[0] + vec[1]*vec2[1] + vec[2]*vec2[2] + vec[3]*vec2[3] + vec[4]*vec2[4] + vec[5]*vec2[5]; +}; + +var mat6 = {}; +mat6.xVec6 = function(mat, vec, dest){ + if(!dest) { dest = vec; } + var x = vec[0], y = vec[1], z = vec[2], u = vec[3], w = vec[4], v = vec[5]; + + dest[0] = mat[0]*x + mat[1]*y + mat[2]*z + mat[3]*u + mat[4]*w + mat[5]*v; + dest[1] = mat[6]*x + mat[7]*y + mat[8]*z + mat[9]*u + mat[10]*w + mat[11]*v; + dest[2] = mat[12]*x + mat[13]*y + mat[14]*z + mat[15]*u + mat[16]*w + mat[17]*v; + dest[3] = mat[18]*x + mat[19]*y + mat[20]*z + mat[21]*u + mat[22]*w + mat[23]*v; + dest[4] = mat[24]*x + mat[25]*y + mat[26]*z + mat[27]*u + mat[28]*w + mat[29]*v; + dest[5] = mat[30]*x + mat[31]*y + mat[32]*z + mat[33]*u + mat[34]*w + mat[35]*v; + + return dest; +}; + +mat3.xVec3 = function(mat, vec, dest){ + if(!dest) { dest = vec; } + var x = vec[0], y = vec[1], z = vec[2]; + + dest[0] = mat[0]*x + mat[1]*y + mat[2]*z; + dest[1] = mat[3]*x + mat[4]*y + mat[5]*z; + dest[2] = mat[6]*x + mat[7]*y + mat[8]*z; + + return dest; +}; +define("glMatrixAddon", ["glMatrix"], (function (global) { + return function () { + var ret, fn; + return ret || global.glMatrixAddon; + }; +}(this))); + +/* jshint undef: true, unused: true, browser:true, devel: true */ +/* global define */ + +define('array_helper',[],function() { + + + return { + init : function(arr, val) { + var l = arr.length; + while (l--) { + arr[l] = val; + } + }, + + /** + * Shuffles the content of an array + * @return {Array} the array itself shuffled + */ + shuffle : function(arr) { + var i = arr.length - 1, j, x; + for (i; i >= 0; i--) { + j = Math.floor(Math.random() * i); + x = arr[i]; + arr[i] = arr[j]; + arr[j] = x; + } + return arr; + }, + + toPointList : function(arr) { + var i, j, row = [], rows = []; + for ( i = 0; i < arr.length; i++) { + row = []; + for ( j = 0; j < arr[i].length; j++) { + row[j] = arr[i][j]; + } + rows[i] = "[" + row.join(",") + "]"; + } + return "[" + rows.join(",\r\n") + "]"; + }, + + /** + * returns the elements which's score is bigger than the threshold + * @return {Array} the reduced array + */ + threshold : function(arr, threshold, scoreFunc) { + var i, queue = []; + for ( i = 0; i < arr.length; i++) { + if (scoreFunc.apply(arr, [arr[i]]) >= threshold) { + queue.push(arr[i]); + } + } + return queue; + }, + + maxIndex : function(arr) { + var i, max = 0; + for ( i = 0; i < arr.length; i++) { + if (arr[i] > arr[max]) { + max = i; + } + } + return max; + }, + + max : function(arr) { + var i, max = 0; + for ( i = 0; i < arr.length; i++) { + if (arr[i] > max) { + max = arr[i]; + } + } + return max; + } + }; +}); +/* jshint undef: true, unused: true, browser:true, devel: true */ +/* global define, vec2, vec3 */ + +define('cv_utils',['cluster', 'glMatrixAddon', "array_helper"], function(Cluster2, glMatrixAddon, ArrayHelper) { + + + /* + * cv_utils.js + * Collection of CV functions and libraries + */ + + /** + * Namespace for various CV alorithms + * @class Represents a collection of useful CV algorithms/functions + */ + + var CVUtils = {}; + + /** + * @param x x-coordinate + * @param y y-coordinate + * @return ImageReference {x,y} Coordinate + */ + CVUtils.imageRef = function(x, y) { + var that = { + x : x, + y : y, + toVec2 : function() { + return vec2.create([this.x, this.y]); + }, + toVec3 : function() { + return vec3.create([this.x, this.y, 1]); + }, + round : function() { + this.x = this.x > 0.0 ? Math.floor(this.x + 0.5) : Math.floor(this.x - 0.5); + this.y = this.y > 0.0 ? Math.floor(this.y + 0.5) : Math.floor(this.y - 0.5); + return this; + } + }; + return that; + }; + + /** + * Computes an integral image of a given grayscale image. + * @param imageDataContainer {ImageDataContainer} the image to be integrated + */ + CVUtils.computeIntegralImage2 = function(imageWrapper, integralWrapper) { + var imageData = imageWrapper.data; + var width = imageWrapper.size.x; + var height = imageWrapper.size.y; + var integralImageData = integralWrapper.data; + var sum = 0, posA = 0, posB = 0, posC = 0, posD = 0, x, y; + + // sum up first column + posB = width; + sum = 0; + for ( y = 1; y < height; y++) { + sum += imageData[posA]; + integralImageData[posB] += sum; + posA += width; + posB += width; + } + + posA = 0; + posB = 1; + sum = 0; + for ( x = 1; x < width; x++) { + sum += imageData[posA]; + integralImageData[posB] += sum; + posA++; + posB++; + } + + for ( y = 1; y < height; y++) { + posA = y * width + 1; + posB = (y - 1) * width + 1; + posC = y * width; + posD = (y - 1) * width; + for ( x = 1; x < width; x++) { + integralImageData[posA] += imageData[posA] + integralImageData[posB] + integralImageData[posC] - integralImageData[posD]; + posA++; + posB++; + posC++; + posD++; + } + } + }; + + CVUtils.computeIntegralImage = function(imageWrapper, integralWrapper) { + var imageData = imageWrapper.data; + var width = imageWrapper.size.x; + var height = imageWrapper.size.y; + var integralImageData = integralWrapper.data; + var sum = 0; + + // sum up first row + for (var i = 0; i < width; i++) { + sum += imageData[i]; + integralImageData[i] = sum; + } + + for (var v = 1; v < height; v++) { + sum = 0; + for (var u = 0; u < width; u++) { + sum += imageData[v * width + u]; + integralImageData[((v) * width) + u] = sum + integralImageData[(v - 1) * width + u]; + } + } + }; + + CVUtils.thresholdImage = function(imageWrapper, threshold, targetWrapper) { + if (!targetWrapper) { + targetWrapper = imageWrapper; + } + var imageData = imageWrapper.data, length = imageData.length, targetData = targetWrapper.data; + + while (length--) { + targetData[length] = imageData[length] < threshold ? 1 : 0; + } + }; + + CVUtils.computeHistogram = function(imageWrapper) { + var imageData = imageWrapper.data, length = imageData.length, i, hist = new Int32Array(256); + + // init histogram + for ( i = 0; i < 256; i++) { + hist[i] = 0; + } + + while (length--) { + hist[imageData[length]]++; + } + return hist; + }; + + CVUtils.otsuThreshold = function(imageWrapper, targetWrapper) { + var hist, threshold; + + function px(init, end) { + var sum = 0, i; + for ( i = init; i <= end; i++) { + sum += hist[i]; + } + return sum; + } + + function mx(init, end) { + var i, sum = 0; + + for ( i = init; i <= end; i++) { + sum += i * hist[i]; + } + + return sum; + } + + function determineThreshold() { + var vet = [0], p1, p2, p12, k, m1, m2, m12; + + hist = CVUtils.computeHistogram(imageWrapper); + for ( k = 1; k < 255; k++) { + p1 = px(0, k); + p2 = px(k + 1, 255); + p12 = p1 * p2; + if (p12 === 0) { + p12 = 1; + } + m1 = mx(0, k) * p2; + m2 = mx(k + 1, 255) * p1; + m12 = m1 - m2; + vet[k] = m12 * m12 / p12; + } + return ArrayHelper.maxIndex(vet); + } + + threshold = determineThreshold(); + CVUtils.thresholdImage(imageWrapper, threshold, targetWrapper); + return threshold; + }; + + // local thresholding + CVUtils.computeBinaryImage = function(imageWrapper, integralWrapper, targetWrapper) { + CVUtils.computeIntegralImage(imageWrapper, integralWrapper); + + if (!targetWrapper) { + targetWrapper = imageWrapper; + } + var imageData = imageWrapper.data; + var targetData = targetWrapper.data; + var width = imageWrapper.size.x; + var height = imageWrapper.size.y; + var integralImageData = integralWrapper.data; + var sum = 0, v, u, kernel = 3, A, B, C, D, avg, size = (kernel * 2 + 1) * (kernel * 2 + 1); + + // clear out top & bottom-border + for ( v = 0; v <= kernel; v++) { + for ( u = 0; u < width; u++) { + targetData[((v) * width) + u] = 0; + targetData[(((height - 1) - v) * width) + u] = 0; + } + } + + // clear out left & right border + for ( v = kernel; v < height - kernel; v++) { + for ( u = 0; u <= kernel; u++) { + targetData[((v) * width) + u] = 0; + targetData[((v) * width) + (width - 1 - u)] = 0; + } + } + + for ( v = kernel + 1; v < height - kernel - 1; v++) { + for ( u = kernel + 1; u < width - kernel; u++) { + A = integralImageData[(v - kernel - 1) * width + (u - kernel - 1)]; + B = integralImageData[(v - kernel - 1) * width + (u + kernel)]; + C = integralImageData[(v + kernel) * width + (u - kernel - 1)]; + D = integralImageData[(v + kernel) * width + (u + kernel)]; + sum = D - C - B + A; + avg = sum / (size); + targetData[v * width + u] = imageData[v * width + u] > (avg + 5) ? 0 : 1; + } + } + }; + + CVUtils.cluster = function(points, threshold, property) { + var i, k, cluster, point, clusters = []; + + if (!property) { + property = "rad"; + } + + function addToCluster(point) { + var found = false; + for ( k = 0; k < clusters.length; k++) { + cluster = clusters[k]; + if (cluster.fits(point)) { + cluster.add(point); + found = true; + } + } + return found; + } + + // iterate over each cloud + for ( i = 0; i < points.length; i++) { + point = Cluster2.createPoint(points[i], i, property); + if (!addToCluster(point)) { + clusters.push(Cluster2.create(point, threshold)); + } + } + + return clusters; + + }; + + CVUtils.Tracer = { + trace : function(points, vec) { + var iteration, maxIterations = 10, top = [], result = [], centerPos = 0, currentPos = 0; + + function trace(idx, forward) { + var from, to, toIdx, predictedPos, thresholdX = 1, thresholdY = Math.abs(vec[1] / 10), found = false; + + function match(pos, predicted) { + if (pos.x > (predicted.x - thresholdX) && pos.x < (predicted.x + thresholdX) && pos.y > (predicted.y - thresholdY) && pos.y < (predicted.y + thresholdY)) { + return true; + } else { + return false; + } + } + + // check if the next index is within the vec specifications + // if not, check as long as the threshold is met + + from = points[idx]; + if (forward) { + predictedPos = { + x : from.x + vec[0], + y : from.y + vec[1] + }; + } else { + predictedPos = { + x : from.x - vec[0], + y : from.y - vec[1] + }; + } + + toIdx = forward ? idx + 1 : idx - 1; + to = points[toIdx]; + while (to && ( found = match(to, predictedPos)) !== true && (Math.abs(to.y - from.y) < vec[1])) { + toIdx = forward ? toIdx + 1 : toIdx - 1; + to = points[toIdx]; + } + + return found ? toIdx : null; + } + + for ( iteration = 0; iteration < maxIterations; iteration++) { + // randomly select point to start with + centerPos = Math.floor(Math.random() * points.length); + + // trace forward + top = []; + currentPos = centerPos; + top.push(points[currentPos]); + while (( currentPos = trace(currentPos, true)) !== null) { + top.push(points[currentPos]); + } + if (centerPos > 0) { + currentPos = centerPos; + while (( currentPos = trace(currentPos, false)) !== null) { + top.push(points[currentPos]); + } + } + + if (top.length > result.length) { + result = top; + } + } + + return result; + + } + }; + + CVUtils.DILATE = 1; + CVUtils.ERODE = 2; + + CVUtils.dilate = function(inImageWrapper, outImageWrapper) { + var v, u, inImageData = inImageWrapper.data, outImageData = outImageWrapper.data, height = inImageWrapper.size.y, width = inImageWrapper.size.x, sum, yStart1, yStart2, xStart1, xStart2; + + for ( v = 1; v < height - 1; v++) { + for ( u = 1; u < width - 1; u++) { + yStart1 = v - 1; + yStart2 = v + 1; + xStart1 = u - 1; + xStart2 = u + 1; + sum = inImageData[yStart1 * width + xStart1]/* + inImageData[yStart1*width+u] */ + inImageData[yStart1 * width + xStart2] + + /* inImageData[v*width+xStart1] + */ + inImageData[v * width + u] + /* inImageData[v*width+xStart2] +*/ + inImageData[yStart2 * width + xStart1]/* + inImageData[yStart2*width+u]*/ + inImageData[yStart2 * width + xStart2]; + outImageData[v * width + u] = sum > 0 ? 1 : 0; + } + } + }; + + CVUtils.erode = function(inImageWrapper, outImageWrapper) { + var v, u, inImageData = inImageWrapper.data, outImageData = outImageWrapper.data, height = inImageWrapper.size.y, width = inImageWrapper.size.x, sum, yStart1, yStart2, xStart1, xStart2; + + for ( v = 1; v < height - 1; v++) { + for ( u = 1; u < width - 1; u++) { + yStart1 = v - 1; + yStart2 = v + 1; + xStart1 = u - 1; + xStart2 = u + 1; + sum = inImageData[yStart1 * width + xStart1]/* + inImageData[yStart1*width+u] */ + inImageData[yStart1 * width + xStart2] + + /* inImageData[v*width+xStart1] + */ + inImageData[v * width + u] + /* inImageData[v*width+xStart2] +*/ + inImageData[yStart2 * width + xStart1]/* + inImageData[yStart2*width+u]*/ + inImageData[yStart2 * width + xStart2]; + outImageData[v * width + u] = sum === 5 ? 1 : 0; + } + } + }; + + CVUtils.subtract = function(aImageWrapper, bImageWrapper, resultImageWrapper) { + if (!resultImageWrapper) { + resultImageWrapper = aImageWrapper; + } + var length = aImageWrapper.data.length, aImageData = aImageWrapper.data, bImageData = bImageWrapper.data, cImageData = resultImageWrapper.data; + + while (length--) { + cImageData[length] = aImageData[length] - bImageData[length]; + } + }; + + CVUtils.bitwiseOr = function(aImageWrapper, bImageWrapper, resultImageWrapper) { + if (!resultImageWrapper) { + resultImageWrapper = aImageWrapper; + } + var length = aImageWrapper.data.length, aImageData = aImageWrapper.data, bImageData = bImageWrapper.data, cImageData = resultImageWrapper.data; + + while (length--) { + cImageData[length] = aImageData[length] || bImageData[length]; + } + }; + + CVUtils.countNonZero = function(imageWrapper) { + var length = imageWrapper.data.length, data = imageWrapper.data, sum = 0; + + while (length--) { + sum += data[length]; + } + return sum; + }; + + CVUtils.topGeneric = function(list, top, scoreFunc) { + var i, minIdx = 0, min = 0, queue = [], score, hit, pos; + + for ( i = 0; i < top; i++) { + queue[i] = { + score : 0, + item : null + }; + } + + for ( i = 0; i < list.length; i++) { + score = scoreFunc.apply(this, [list[i]]); + if (score > min) { + hit = queue[minIdx]; + hit.score = score; + hit.item = list[i]; + min = Number.MAX_VALUE; + for ( pos = 0; pos < top; pos++) { + if (queue[pos].score < min) { + min = queue[pos].score; + minIdx = pos; + } + } + } + } + + return queue; + }; + + CVUtils.grayArrayFromImage = function(htmlImage, offsetX, ctx, array) { + ctx.drawImage(htmlImage, offsetX, 0, htmlImage.width, htmlImage.height); + var ctxData = ctx.getImageData(offsetX, 0, htmlImage.width, htmlImage.height).data; + CVUtils.computeGray(ctxData, array); + }; + + CVUtils.grayArrayFromContext = function(ctx, size, offset, array) { + var ctxData = ctx.getImageData(offset.x, offset.y, size.x, size.y).data; + CVUtils.computeGray(ctxData, array); + }; + + CVUtils.grayAndHalfSampleFromCanvasData = function(canvasData, size, outArray) { + var topRowIdx = 0; + var bottomRowIdx = size.x; + var endIdx = Math.floor(canvasData.length / 4); + var outWidth = size.x / 2; + var outImgIdx = 0; + var inWidth = size.x; + var i; + + while (bottomRowIdx < endIdx) { + for ( i = 0; i < outWidth; i++) { + outArray[outImgIdx] = Math.floor(((0.299 * canvasData[topRowIdx * 4 + 0] + 0.587 * canvasData[topRowIdx * 4 + 1] + 0.114 * canvasData[topRowIdx * 4 + 2]) + (0.299 * canvasData[(topRowIdx + 1) * 4 + 0] + 0.587 * canvasData[(topRowIdx + 1) * 4 + 1] + 0.114 * canvasData[(topRowIdx + 1) * 4 + 2]) + (0.299 * canvasData[(bottomRowIdx) * 4 + 0] + 0.587 * canvasData[(bottomRowIdx) * 4 + 1] + 0.114 * canvasData[(bottomRowIdx) * 4 + 2]) + (0.299 * canvasData[(bottomRowIdx + 1) * 4 + 0] + 0.587 * canvasData[(bottomRowIdx + 1) * 4 + 1] + 0.114 * canvasData[(bottomRowIdx + 1) * 4 + 2])) / 4); + outImgIdx++; + topRowIdx = topRowIdx + 2; + bottomRowIdx = bottomRowIdx + 2; + } + topRowIdx = topRowIdx + inWidth; + bottomRowIdx = bottomRowIdx + inWidth; + } + + }; + + CVUtils.computeGray = function(imageData, outArray) { + var l = imageData.length / 4; + var i = 0; + for ( i = 0; i < l; i++) { + //outArray[i] = (0.299*imageData[i*4+0] + 0.587*imageData[i*4+1] + 0.114*imageData[i*4+2]); + + outArray[i] = Math.floor(0.299 * imageData[i * 4 + 0] + 0.587 * imageData[i * 4 + 1] + 0.114 * imageData[i * 4 + 2]); + } + }; + + CVUtils.loadImageArray = function(src, callback, canvas) { + if (!canvas) + canvas = document.createElement('canvas'); + var img = new Image(); + img.callback = callback; + img.onload = function() { + canvas.width = this.width; + canvas.height = this.height; + var ctx = canvas.getContext('2d'); + ctx.drawImage(this, 0, 0); + var array = new Uint8Array(this.width * this.height); + ctx.drawImage(this, 0, 0); + var data = ctx.getImageData(0, 0, this.width, this.height).data; + CVUtils.computeGray(data, array); + this.callback(array, { + x : this.width, + y : this.height + }, this); + }; + img.src = src; + }; + + /** + * @param inImg {ImageWrapper} input image to be sampled + * @param outImg {ImageWrapper} to be stored in + */ + CVUtils.halfSample = function(inImgWrapper, outImgWrapper) { + var inImg = inImgWrapper.data; + var inWidth = inImgWrapper.size.x; + var outImg = outImgWrapper.data; + var topRowIdx = 0; + var bottomRowIdx = inWidth; + var endIdx = inImg.length; + var outWidth = inWidth / 2; + var outImgIdx = 0; + while (bottomRowIdx < endIdx) { + for (var i = 0; i < outWidth; i++) { + outImg[outImgIdx] = Math.floor((inImg[topRowIdx] + inImg[topRowIdx + 1] + inImg[bottomRowIdx] + inImg[bottomRowIdx + 1]) / 4); + outImgIdx++; + topRowIdx = topRowIdx + 2; + bottomRowIdx = bottomRowIdx + 2; + } + topRowIdx = topRowIdx + inWidth; + bottomRowIdx = bottomRowIdx + inWidth; + } + }; + + CVUtils.hsv2rgb = function(hsv, rgb) { + var h = hsv[0], s = hsv[1], v = hsv[2], c = v * s, x = c * (1 - Math.abs((h / 60) % 2 - 1)), m = v - c, r = 0, g = 0, b = 0; + rgb = rgb || [0, 0, 0]; + + if (h < 60) { + r = c; + g = x; + } else if (h < 120) { + r = x; + g = c; + } else if (h < 180) { + g = c; + b = x; + } else if (h < 240) { + g = x; + b = c; + } else if (h < 300) { + r = x; + b = c; + } else if (h < 360) { + r = c; + b = x; + } + rgb[0] = ((r + m) * 255) | 0; + rgb[1] = ((g + m) * 255) | 0; + rgb[2] = ((b + m) * 255) | 0; + return rgb; + }; + + return (CVUtils); +}); + + +/* jshint undef: true, unused: true, browser:true, devel: true */ +/* global define, vec2, mat2 */ + +define('image_wrapper',[ + "subImage", + "cv_utils", + "array_helper" + ], + function(SubImage, CVUtils, ArrayHelper) { + + + + /** + * Represents a basic image combining the data and size. + * In addition, some methods for manipulation are contained. + * @param size {x,y} The size of the image in pixel + * @param data {Array} If given, a flat array containing the pixel data + * @param ArrayType {Type} If given, the desired DataType of the Array (may be typed/non-typed) + * @param initialize {Boolean} Indicating if the array should be initialized on creation. + * @returns {ImageWrapper} + */ + function ImageWrapper(size, data, ArrayType, initialize) { + if (!data) { + if (ArrayType) { + this.data = new ArrayType(size.x * size.y); + if (ArrayType === Array && initialize) { + ArrayHelper.init(this.data, 0); + } + } else { + this.data = new Uint8Array(size.x * size.y); + if (Uint8Array === Array && initialize) { + ArrayHelper.init(this.data, 0); + } + } + + } else { + this.data = data; + } + this.size = size; + } + + /** + * tests if a position is within the image with a given offset + * @param imgRef {x, y} The location to test + * @param border Number the padding value in pixel + * @returns {Boolean} true if location inside the image's border, false otherwise + * @see cvd/image.h + */ + ImageWrapper.prototype.inImageWithBorder = function(imgRef, border) { + return (imgRef.x >= border) && (imgRef.y >= border) && (imgRef.x < (this.size.x - border)) && (imgRef.y < (this.size.y - border)); + }; + + /** + * Transforms an image according to the given affine-transformation matrix. + * @param inImg ImageWrapper a image containing the information to be extracted. + * @param outImg ImageWrapper the image to be filled. The whole image out image is filled by the in image. + * @param M mat2 the matrix used to map point in the out matrix to those in the in matrix + * @param inOrig vec2 origin in the in image + * @param outOrig vec2 origin in the out image + * @returns Number the number of pixels not in the in image + * @see cvd/vision.h + */ + ImageWrapper.transform = function(inImg, outImg, M, inOrig, outOrig) { + var w = outImg.size.x, h = outImg.size.y, iw = inImg.size.x, ih = inImg.size.y; + var across = vec2.create([M[0], M[2]]); + var down = vec2.create([M[1], M[3]]); + var defaultValue = 0; + + var p0 = vec2.subtract(inOrig, mat2.xVec2(M, outOrig, vec2.create()), vec2.create()); + + var min_x = p0[0], min_y = p0[1]; + var max_x = min_x, max_y = min_y; + var p, i, j; + + var sampleFunc = ImageWrapper.sample; + + if (across[0] < 0) + min_x += w * across[0]; + else + max_x += w * across[0]; + + if (down[0] < 0) + min_x += h * down[0]; + else + max_x += h * down[0]; + + if (across[1] < 0) + min_y += w * across[1]; + else + max_y += w * across[1]; + + if (down[1] < 0) + min_y += h * down[1]; + else + max_y += h * down[1]; + + var carrigeReturn = vec2.subtract(down, vec2.scale(across, w, vec2.create()), vec2.create()); + + if (min_x >= 0 && min_y >= 0 && max_x < iw - 1 && max_y < ih - 1) { + p = p0; + for ( i = 0; i < h; ++i, vec2.add(p, carrigeReturn)) + for ( j = 0; j < w; ++j, vec2.add(p, across)) + outImg.set(j, i, sampleFunc(inImg, p[0], p[1])); + return 0; + } else { + var x_bound = iw - 1; + var y_bound = ih - 1; + var count = 0; + p = p0; + for ( i = 0; i < h; ++i, vec2.add(p, carrigeReturn)) { + for ( j = 0; j < w; ++j, vec2.add(p, across)) { + if (0 <= p[0] && 0 <= p[1] && p[0] < x_bound && p[1] < y_bound) { + outImg.set(j, i, sampleFunc(inImg, p[0], p[1])); + } else { + outImg.set(j, i, defaultValue); ++count; + } + } + } + return count; + } + }; + + /** + * Performs bilinear sampling + * @param inImg Image to extract sample from + * @param x the x-coordinate + * @param y the y-coordinate + * @returns the sampled value + * @see cvd/vision.h + */ + ImageWrapper.sample = function(inImg, x, y) { + var lx = Math.floor(x); + var ly = Math.floor(y); + var w = inImg.size.x; + var base = ly * inImg.size.x + lx; + var a = inImg.data[base + 0]; + var b = inImg.data[base + 1]; + var c = inImg.data[base + w]; + var d = inImg.data[base + w + 1]; + var e = a - b; + x -= lx; + y -= ly; + + var result = Math.floor(x * (y * (e - c + d) - e) + y * (c - a) + a); + return result; + }; + + /** + * Initializes a given array. Sets each element to zero. + * @param array {Array} The array to initialize + */ + ImageWrapper.clearArray = function(array) { + var l = array.length; + while (l--) { + array[l] = 0; + } + }; + + /** + * Creates a {SubImage} from the current image ({this}). + * @param from {ImageRef} The position where to start the {SubImage} from. (top-left corner) + * @param size {ImageRef} The size of the resulting image + * @returns {SubImage} A shared part of the original image + */ + ImageWrapper.prototype.subImage = function(from, size) { + return new SubImage(from, size, this); + }; + + /** + * Creates an {ImageWrapper) and copies the needed underlying image-data area + * @param imageWrapper {ImageWrapper} The target {ImageWrapper} where the data should be copied + * @param from {ImageRef} The location where to copy from (top-left location) + */ + ImageWrapper.prototype.subImageAsCopy = function(imageWrapper, from) { + var sizeY = imageWrapper.size.y, sizeX = imageWrapper.size.x; + var x, y; + for ( x = 0; x < sizeX; x++) { + for ( y = 0; y < sizeY; y++) { + imageWrapper.data[y * sizeX + x] = this.data[(from.y + y) * this.size.x + from.x + x]; + } + } + }; + + ImageWrapper.prototype.copyTo = function(imageWrapper) { + var length = this.data.length, srcData = this.data, dstData = imageWrapper.data; + + while (length--) { + dstData[length] = srcData[length]; + } + }; + + /** + * Retrieves a given pixel position from the image + * @param x {Number} The x-position + * @param y {Number} The y-position + * @returns {Number} The grayscale value at the pixel-position + */ + ImageWrapper.prototype.get = function(x, y) { + return this.data[y * this.size.x + x]; + }; + + /** + * Retrieves a given pixel position from the image + * @param x {Number} The x-position + * @param y {Number} The y-position + * @returns {Number} The grayscale value at the pixel-position + */ + ImageWrapper.prototype.getSafe = function(x, y) { + var i; + + if (!this.indexMapping) { + this.indexMapping = { + x : [], + y : [] + }; + for (i = 0; i < this.size.x; i++) { + this.indexMapping.x[i] = i; + this.indexMapping.x[i + this.size.x] = i; + } + for (i = 0; i < this.size.y; i++) { + this.indexMapping.y[i] = i; + this.indexMapping.y[i + this.size.y] = i; + } + } + return this.data[(this.indexMapping.y[y + this.size.y]) * this.size.x + this.indexMapping.x[x + this.size.x]]; + }; + + /** + * Sets a given pixel position in the image + * @param x {Number} The x-position + * @param y {Number} The y-position + * @param value {Number} The grayscale value to set + * @returns {ImageWrapper} The Image itself (for possible chaining) + */ + ImageWrapper.prototype.set = function(x, y, value) { + this.data[y * this.size.x + x] = value; + return this; + }; + + /** + * Sets the border of the image (1 pixel) to zero + */ + ImageWrapper.prototype.zeroBorder = function() { + var i, width = this.size.x, height = this.size.y, data = this.data; + for ( i = 0; i < width; i++) { + data[i] = data[(height - 1) * width + i] = 0; + } + for ( i = 1; i < height - 1; i++) { + data[i * width] = data[i * width + (width - 1)] = 0; + } + }; + + /** + * Inverts a binary image in place + */ + ImageWrapper.prototype.invert = function() { + var data = this.data, length = data.length; + + while (length--) { + data[length] = data[length] ? 0 : 1; + } + + }; + + ImageWrapper.prototype.convolve = function(kernel) { + var x, y, kx, ky, kSize = (kernel.length / 2) | 0, accu = 0; + for ( y = 0; y < this.size.y; y++) { + for ( x = 0; x < this.size.x; x++) { + accu = 0; + for ( ky = -kSize; ky <= kSize; ky++) { + for ( kx = -kSize; kx <= kSize; kx++) { + accu += kernel[ky+kSize][kx + kSize] * this.getSafe(x + kx, y + ky); + } + } + this.data[y * this.size.x + x] = accu; + } + } + }; + + ImageWrapper.prototype.moments = function(labelcount) { + var data = this.data, + x, + y, + height = this.size.y, + width = this.size.x, + val, + ysq, + labelsum = [], + i, + label, + mu11, + mu02, + mu20, + x_, + y_, + tmp, + result = [], + PI = Math.PI, + PI_4 = PI / 4; + + if (labelcount <= 0) { + return result; + } + + for ( i = 0; i < labelcount; i++) { + labelsum[i] = { + m00 : 0, + m01 : 0, + m10 : 0, + m11 : 0, + m02 : 0, + m20 : 0, + theta : 0, + rad : 0 + }; + } + + for ( y = 0; y < height; y++) { + ysq = y * y; + for ( x = 0; x < width; x++) { + val = data[y * width + x]; + if (val > 0) { + label = labelsum[val - 1]; + label.m00 += 1; + label.m01 += y; + label.m10 += x; + label.m11 += x * y; + label.m02 += ysq; + label.m20 += x * x; + } + } + } + + for ( i = 0; i < labelcount; i++) { + label = labelsum[i]; + if (!isNaN(label.m00) && label.m00 !== 0) { + x_ = label.m10 / label.m00; + y_ = label.m01 / label.m00; + mu11 = label.m11 / label.m00 - x_ * y_; + mu02 = label.m02 / label.m00 - y_ * y_; + mu20 = label.m20 / label.m00 - x_ * x_; + tmp = (mu02 - mu20) / (2 * mu11); + tmp = 0.5 * Math.atan(tmp) + (mu11 >= 0 ? PI_4 : -PI_4 ) + PI; + label.theta = (tmp * 180 / PI + 90) % 180 - 90; + if (label.theta < 0) { + label.theta += 180; + } + label.rad = tmp > PI ? tmp - PI : tmp; + label.vec = vec2.create([Math.cos(tmp), Math.sin(tmp)]); + result.push(label); + } + } + + return result; + }; + + /** + * Displays the {ImageWrapper} in a given canvas + * @param canvas {Canvas} The canvas element to write to + * @param scale {Number} Scale which is applied to each pixel-value + */ + ImageWrapper.prototype.show = function(canvas, scale) { + var ctx, + frame, + data, + current, + pixel, + x, + y; + + if (!scale) { + scale = 1.0; + } + ctx = canvas.getContext('2d'); + canvas.width = this.size.x; + canvas.height = this.size.y; + frame = ctx.getImageData(0, 0, canvas.width, canvas.height); + data = frame.data; + current = 0; + for (y = 0; y < this.size.y; y++) { + for (x = 0; x < this.size.x; x++) { + pixel = y * this.size.x + x; + current = this.get(x, y) * scale; + data[pixel * 4 + 0] = current; + data[pixel * 4 + 1] = current; + data[pixel * 4 + 2] = current; + data[pixel * 4 + 3] = 255; + } + } + //frame.data = data; + ctx.putImageData(frame, 0, 0); + }; + + /** + * Displays the {SubImage} in a given canvas + * @param canvas {Canvas} The canvas element to write to + * @param scale {Number} Scale which is applied to each pixel-value + */ + ImageWrapper.prototype.overlay = function(canvas, scale, from) { + if (!scale || scale < 0 || scale > 360) { + scale = 360; + } + var hsv = [0, 1, 1]; + var rgb = [0, 0, 0]; + var whiteRgb = [255, 255, 255]; + var blackRgb = [0, 0, 0]; + var result = []; + var ctx = canvas.getContext('2d'); + var frame = ctx.getImageData(from.x, from.y, this.size.x, this.size.y); + var data = frame.data; + var length = this.data.length; + while (length--) { + hsv[0] = this.data[length] * scale; + result = hsv[0] <= 0 ? whiteRgb : hsv[0] >= 360 ? blackRgb : CVUtils.hsv2rgb(hsv, rgb); + data[length * 4 + 0] = result[0]; + data[length * 4 + 1] = result[1]; + data[length * 4 + 2] = result[2]; + data[length * 4 + 3] = 255; + } + ctx.putImageData(frame, from.x, from.y); + }; + + return (ImageWrapper); +}); +/* jshint undef: true, unused: true, browser:true, devel: true */ +/* global define */ + +/** + * http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization + */ +define('tracer',[],function() { + + + var Tracer = { + searchDirections : [[0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1, -1], [-1, 0], [-1, 1]], + create : function(imageWrapper, labelWrapper) { + var imageData = imageWrapper.data, + labelData = labelWrapper.data, + searchDirections = this.searchDirections, + width = imageWrapper.size.x, + pos; + + function trace(current, color, label, edgelabel) { + var i, + y, + x; + + for ( i = 0; i < 7; i++) { + y = current.cy + searchDirections[current.dir][0]; + x = current.cx + searchDirections[current.dir][1]; + pos = y * width + x; + if ((imageData[pos] === color) && ((labelData[pos] === 0) || (labelData[pos] === label))) { + labelData[pos] = label; + current.cy = y; + current.cx = x; + return true; + } else { + if (labelData[pos] === 0) { + labelData[pos] = edgelabel; + } + current.dir = (current.dir + 1) % 8; + } + } + return false; + } + + function vertex2D(x, y, dir) { + return { + dir : dir, + x : x, + y : y, + next : null, + prev : null + }; + } + + function contourTracing(sy, sx, label, color, edgelabel) { + var Fv = null, + Cv, + P, + ldir, + current = { + cx : sx, + cy : sy, + dir : 0 + }; + + if (trace(current, color, label, edgelabel)) { + Fv = vertex2D(sx, sy, current.dir); + Cv = Fv; + ldir = current.dir; + P = vertex2D(current.cx, current.cy, 0); + P.prev = Cv; + Cv.next = P; + P.next = null; + Cv = P; + do { + current.dir = (current.dir + 6) % 8; + trace(current, color, label, edgelabel); + if (ldir != current.dir) { + Cv.dir = current.dir; + P = vertex2D(current.cx, current.cy, 0); + P.prev = Cv; + Cv.next = P; + P.next = null; + Cv = P; + } else { + Cv.dir = ldir; + Cv.x = current.cx; + Cv.y = current.cy; + } + ldir = current.dir; + } while(current.cx != sx || current.cy != sy); + Fv.prev = Cv.prev; + Cv.prev.next = Fv; + } + return Fv; + } + + return { + trace : function(current, color, label, edgelabel) { + return trace(current, color, label, edgelabel); + }, + contourTracing : function(sy, sx, label, color, edgelabel) { + return contourTracing(sy, sx, label, color, edgelabel); + } + }; + } + }; + + return (Tracer); +}); + +/* jshint undef: true, unused: true, browser:true, devel: true */ +/* global define */ + +/** + * http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization + */ +define('rasterizer',["tracer"], function(Tracer) { + + + var Rasterizer = { + createContour2D : function() { + return { + dir : null, + index : null, + firstVertex : null, + insideContours : null, + nextpeer : null, + prevpeer : null + }; + }, + CONTOUR_DIR : { + CW_DIR : 0, + CCW_DIR : 1, + UNKNOWN_DIR : 2 + }, + DIR : { + OUTSIDE_EDGE : -32767, + INSIDE_EDGE : -32766 + }, + create : function(imageWrapper, labelWrapper) { + var imageData = imageWrapper.data, + labelData = labelWrapper.data, + width = imageWrapper.size.x, + height = imageWrapper.size.y, + tracer = Tracer.create(imageWrapper, labelWrapper); + + return { + rasterize : function(depthlabel) { + var color, + bc, + lc, + labelindex, + cx, + cy, + colorMap = [], + vertex, + p, + cc, + sc, + pos, + connectedCount = 0, + i; + + for ( i = 0; i < 400; i++) { + colorMap[i] = 0; + } + + colorMap[0] = imageData[0]; + cc = null; + for ( cy = 1; cy < height - 1; cy++) { + labelindex = 0; + bc = colorMap[0]; + for ( cx = 1; cx < width - 1; cx++) { + pos = cy * width + cx; + if (labelData[pos] === 0) { + color = imageData[pos]; + if (color !== bc) { + if (labelindex === 0) { + lc = connectedCount + 1; + colorMap[lc] = color; + bc = color; + vertex = tracer.contourTracing(cy, cx, lc, color, Rasterizer.DIR.OUTSIDE_EDGE); + if (vertex !== null) { + connectedCount++; + labelindex = lc; + p = Rasterizer.createContour2D(); + p.dir = Rasterizer.CONTOUR_DIR.CW_DIR; + p.index = labelindex; + p.firstVertex = vertex; + p.nextpeer = cc; + p.insideContours = null; + if (cc !== null) { + cc.prevpeer = p; + } + cc = p; + } + } else { + vertex = tracer.contourTracing(cy, cx, Rasterizer.DIR.INSIDE_EDGE, color, labelindex); + if (vertex !== null) { + p = Rasterizer.createContour2D(); + p.firstVertex = vertex; + p.insideContours = null; + if (depthlabel === 0) { + p.dir = Rasterizer.CONTOUR_DIR.CCW_DIR; + } else { + p.dir = Rasterizer.CONTOUR_DIR.CW_DIR; + } + p.index = depthlabel; + sc = cc; + while ((sc !== null) && sc.index !== labelindex) { + sc = sc.nextpeer; + } + if (sc !== null) { + p.nextpeer = sc.insideContours; + if (sc.insideContours !== null) { + sc.insideContours.prevpeer = p; + } + sc.insideContours = p; + } + } + } + } else { + labelData[pos] = labelindex; + } + } else if (labelData[pos] === Rasterizer.DIR.OUTSIDE_EDGE || labelData[pos] === Rasterizer.DIR.INSIDE_EDGE) { + labelindex = 0; + if (labelData[pos] === Rasterizer.DIR.INSIDE_EDGE) { + bc = imageData[pos]; + } else { + bc = colorMap[0]; + } + } else { + labelindex = labelData[pos]; + bc = colorMap[labelindex]; + } + } + } + sc = cc; + while (sc !== null) { + sc.index = depthlabel; + sc = sc.nextpeer; + } + return { + cc : cc, + count : connectedCount + }; + }, + debug: { + drawContour : function(canvas, firstContour) { + var ctx = canvas.getContext("2d"), + pq = firstContour, + iq, + q, + p; + + ctx.strokeStyle = "red"; + ctx.fillStyle = "red"; + ctx.lineWidth = 1; + + if (pq !== null) { + iq = pq.insideContours; + } else { + iq = null; + } + + while (pq !== null) { + if (iq !== null) { + q = iq; + iq = iq.nextpeer; + } else { + q = pq; + pq = pq.nextpeer; + if (pq !== null) { + iq = pq.insideContours; + } else { + iq = null; + } + } + + switch(q.dir) { + case Rasterizer.CONTOUR_DIR.CW_DIR: + ctx.strokeStyle = "red"; + break; + case Rasterizer.CONTOUR_DIR.CCW_DIR: + ctx.strokeStyle = "blue"; + break; + case Rasterizer.CONTOUR_DIR.UNKNOWN_DIR: + ctx.strokeStyle = "green"; + break; + } + + p = q.firstVertex; + ctx.beginPath(); + ctx.moveTo(p.x, p.y); + do { + p = p.next; + ctx.lineTo(p.x, p.y); + } while(p !== q.firstVertex); + ctx.stroke(); + } + } + } + }; + } + }; + + return (Rasterizer); +}); + +/* jshint undef: true, unused: true, browser:true, devel: true, -W041: false */ +/* global define */ + +define('skeletonizer',[],function() { + + + function Skeletonizer(stdlib, foreign, buffer) { + "use asm"; + + var images = new stdlib.Uint8Array(buffer), + size = foreign.size | 0, + imul = stdlib.Math.imul; + + function erode(inImagePtr, outImagePtr) { + inImagePtr = inImagePtr | 0; + outImagePtr = outImagePtr | 0; + + var v = 0, + u = 0, + sum = 0, + yStart1 = 0, + yStart2 = 0, + xStart1 = 0, + xStart2 = 0, + offset = 0; + + for ( v = 1; (v | 0) < ((size - 1) | 0); v = (v + 1) | 0) { + offset = (offset + size) | 0; + for ( u = 1; (u | 0) < ((size - 1) | 0); u = (u + 1) | 0) { + yStart1 = (offset - size) | 0; + yStart2 = (offset + size) | 0; + xStart1 = (u - 1) | 0; + xStart2 = (u + 1) | 0; + sum = ((images[(inImagePtr + yStart1 + xStart1) | 0] | 0) + (images[(inImagePtr + yStart1 + xStart2) | 0] | 0) + (images[(inImagePtr + offset + u) | 0] | 0) + (images[(inImagePtr + yStart2 + xStart1) | 0] | 0) + (images[(inImagePtr + yStart2 + xStart2) | 0] | 0)) | 0; + if ((sum | 0) == (5 | 0)) { + images[(outImagePtr + offset + u) | 0] = 1; + } else { + images[(outImagePtr + offset + u) | 0] = 0; + } + } + } + return; + } + + function subtract(aImagePtr, bImagePtr, outImagePtr) { + aImagePtr = aImagePtr | 0; + bImagePtr = bImagePtr | 0; + outImagePtr = outImagePtr | 0; + + var length = 0; + + length = imul(size, size) | 0; + + while ((length | 0) > 0) { + length = (length - 1) | 0; + images[(outImagePtr + length) | 0] = ((images[(aImagePtr + length) | 0] | 0) - (images[(bImagePtr + length) | 0] | 0)) | 0; + } + } + + function bitwiseOr(aImagePtr, bImagePtr, outImagePtr) { + aImagePtr = aImagePtr | 0; + bImagePtr = bImagePtr | 0; + outImagePtr = outImagePtr | 0; + + var length = 0; + + length = imul(size, size) | 0; + + while ((length | 0) > 0) { + length = (length - 1) | 0; + images[(outImagePtr + length) | 0] = ((images[(aImagePtr + length) | 0] | 0) | (images[(bImagePtr + length) | 0] | 0)) | 0; + } + } + + function countNonZero(imagePtr) { + imagePtr = imagePtr | 0; + + var sum = 0, + length = 0; + + length = imul(size, size) | 0; + + while ((length | 0) > 0) { + length = (length - 1) | 0; + sum = ((sum | 0) + (images[(imagePtr + length) | 0] | 0)) | 0; + } + + return (sum | 0); + } + + function init(imagePtr, value) { + imagePtr = imagePtr | 0; + value = value | 0; + + var length = 0; + + length = imul(size, size) | 0; + + while ((length | 0) > 0) { + length = (length - 1) | 0; + images[(imagePtr + length) | 0] = value; + } + } + + function dilate(inImagePtr, outImagePtr) { + inImagePtr = inImagePtr | 0; + outImagePtr = outImagePtr | 0; + + var v = 0, + u = 0, + sum = 0, + yStart1 = 0, + yStart2 = 0, + xStart1 = 0, + xStart2 = 0, + offset = 0; + + for ( v = 1; (v | 0) < ((size - 1) | 0); v = (v + 1) | 0) { + offset = (offset + size) | 0; + for ( u = 1; (u | 0) < ((size - 1) | 0); u = (u + 1) | 0) { + yStart1 = (offset - size) | 0; + yStart2 = (offset + size) | 0; + xStart1 = (u - 1) | 0; + xStart2 = (u + 1) | 0; + sum = ((images[(inImagePtr + yStart1 + xStart1) | 0] | 0) + (images[(inImagePtr + yStart1 + xStart2) | 0] | 0) + (images[(inImagePtr + offset + u) | 0] | 0) + (images[(inImagePtr + yStart2 + xStart1) | 0] | 0) + (images[(inImagePtr + yStart2 + xStart2) | 0] | 0)) | 0; + if ((sum | 0) > (0 | 0)) { + images[(outImagePtr + offset + u) | 0] = 1; + } else { + images[(outImagePtr + offset + u) | 0] = 0; + } + } + } + return; + } + + function memcpy(srcImagePtr, dstImagePtr) { + srcImagePtr = srcImagePtr | 0; + dstImagePtr = dstImagePtr | 0; + + var length = 0; + + length = imul(size, size) | 0; + + while ((length | 0) > 0) { + length = (length - 1) | 0; + images[(dstImagePtr + length) | 0] = (images[(srcImagePtr + length) | 0] | 0); + } + } + + function zeroBorder(imagePtr) { + imagePtr = imagePtr | 0; + + var x = 0, + y = 0; + + for ( x = 0; (x | 0) < ((size - 1) | 0); x = (x + 1) | 0) { + images[(imagePtr + x) | 0] = 0; + images[(imagePtr + y) | 0] = 0; + y = ((y + size) - 1) | 0; + images[(imagePtr + y) | 0] = 0; + y = (y + 1) | 0; + } + for ( x = 0; (x | 0) < (size | 0); x = (x + 1) | 0) { + images[(imagePtr + y) | 0] = 0; + y = (y + 1) | 0; + } + } + + function skeletonize() { + var subImagePtr = 0, + erodedImagePtr = 0, + tempImagePtr = 0, + skelImagePtr = 0, + sum = 0, + done = 0; + + erodedImagePtr = imul(size, size) | 0; + tempImagePtr = (erodedImagePtr + erodedImagePtr) | 0; + skelImagePtr = (tempImagePtr + erodedImagePtr) | 0; + + // init skel-image + init(skelImagePtr, 0); + zeroBorder(subImagePtr); + + do { + erode(subImagePtr, erodedImagePtr); + dilate(erodedImagePtr, tempImagePtr); + subtract(subImagePtr, tempImagePtr, tempImagePtr); + bitwiseOr(skelImagePtr, tempImagePtr, skelImagePtr); + memcpy(erodedImagePtr, subImagePtr); + sum = countNonZero(subImagePtr) | 0; + done = ((sum | 0) == 0 | 0); + } while(!done); + } + + return { + skeletonize : skeletonize + }; + } + + return Skeletonizer; +}); + +/* jshint undef: true, unused: true, browser:true, devel: true */ +/* global define */ + +define('image_debug',[],function() { + + + return { + drawRect: function(pos, size, ctx, style){ + ctx.strokeStyle = style.color; + ctx.fillStyle = style.color; + ctx.lineWidth = 1; + ctx.beginPath(); + ctx.strokeRect(pos.x, pos.y, size.x, size.y); + }, + drawPath: function(path, def, ctx, style) { + ctx.strokeStyle = style.color; + ctx.fillStyle = style.color; + ctx.lineWidth = style.lineWidth; + ctx.beginPath(); + ctx.moveTo(path[0][def.x], path[0][def.y]); + for (var j = 1; j < path.length; j++) { + ctx.lineTo(path[j][def.x], path[j][def.y]); + } + ctx.closePath(); + ctx.stroke(); + } + }; + +}); + +/* jshint undef: true, unused: true, browser:true, devel: true */ +/* global define, mat2, vec2 */ + +define('barcode_locator',["image_wrapper", "cv_utils", "rasterizer", "tracer", "skeletonizer", "array_helper", "image_debug"], +function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, ImageDebug) { + + + var _config, + _currentImageWrapper, + _skelImageWrapper, + _subImageWrapper, + _labelImageWrapper, + _patchGrid, + _patchLabelGrid, + _imageToPatchGrid, + _binaryImageWrapper, + _halfSample = true, + _patchSize, + _canvasContainer = { + ctx : { + binary : null + }, + dom : { + binary : null + } + }, + _numPatches = {x: 0, y: 0}, + _inputImageWrapper, + _skeletonizer, + self = this, + _worker, + _locatedCb, + _initialized; + + function initBuffers() { + var skeletonImageData; + + if (_halfSample) { + _currentImageWrapper = new ImageWrapper({ + x : _inputImageWrapper.size.x / 2 | 0, + y : _inputImageWrapper.size.y / 2 | 0 + }); + } else { + _currentImageWrapper = _inputImageWrapper; + } + + _patchSize = { + x : 16 * ( _halfSample ? 1 : 2), + y : 16 * ( _halfSample ? 1 : 2) + }; + + _numPatches.x = _currentImageWrapper.size.x / _patchSize.x | 0; + _numPatches.y = _currentImageWrapper.size.y / _patchSize.y | 0; + + _binaryImageWrapper = new ImageWrapper(_currentImageWrapper.size, undefined, Uint8Array, false); + + _labelImageWrapper = new ImageWrapper(_patchSize, undefined, Array, true); + + skeletonImageData = new ArrayBuffer(64*1024); + _subImageWrapper = new ImageWrapper(_patchSize, new Uint8Array(skeletonImageData, 0, _patchSize.x * _patchSize.y)); + _skelImageWrapper = new ImageWrapper(_patchSize, new Uint8Array(skeletonImageData, _patchSize.x * _patchSize.y * 3, _patchSize.x * _patchSize.y), undefined, true); + _skeletonizer = skeletonizer(self, { + size : _patchSize.x + }, skeletonImageData); + + _imageToPatchGrid = new ImageWrapper({ + x : (_currentImageWrapper.size.x / _subImageWrapper.size.x) | 0, + y : (_currentImageWrapper.size.y / _subImageWrapper.size.y) | 0 + }, undefined, Array, true); + _patchGrid = new ImageWrapper(_imageToPatchGrid.size, undefined, undefined, true); + _patchLabelGrid = new ImageWrapper(_imageToPatchGrid.size, undefined, Int32Array, true); + } + + function initCanvas() { + if (_config.useWorker || typeof document === 'undefined') { + return; + } + _canvasContainer.dom.binary = document.createElement("canvas"); + _canvasContainer.dom.binary.className = "binaryBuffer"; + if (_config.showCanvas === true) { + document.querySelector("#debug").appendChild(_canvasContainer.dom.binary); + } + _canvasContainer.ctx.binary = _canvasContainer.dom.binary.getContext("2d"); + _canvasContainer.dom.binary.width = _binaryImageWrapper.size.x; + _canvasContainer.dom.binary.height = _binaryImageWrapper.size.y; + } + + /** + * Creates a bounding box which encloses all the given patches + * @returns {Array} The minimal bounding box + */ + function boxFromPatches(patches) { + var overAvg, i, j, patch, transMat, minx = _binaryImageWrapper.size.x, miny = _binaryImageWrapper.size.y, maxx = -_binaryImageWrapper.size.x, maxy = -_binaryImageWrapper.size.y, box, scale; + + // draw all patches which are to be taken into consideration + overAvg = 0; + for ( i = 0; i < patches.length; i++) { + patch = patches[i]; + overAvg += patch.rad; + if (_config.showPatches) { + ImageDebug.drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary, {color: "red"}); + } + } + + overAvg /= patches.length; + overAvg = (overAvg * 180 / Math.PI + 90) % 180 - 90; + if (overAvg < 0) { + overAvg += 180; + } + + //console.log(overAvg); + overAvg = (180 - overAvg) * Math.PI / 180; + transMat = mat2.create([Math.cos(overAvg), -Math.sin(overAvg), Math.sin(overAvg), Math.cos(overAvg)]); + + // iterate over patches and rotate by angle + for ( i = 0; i < patches.length; i++) { + patch = patches[i]; + for ( j = 0; j < 4; j++) { + mat2.xVec2(transMat, patch.box[j]); + } + + if (_config.boxFromPatches.showTransformed) { + ImageDebug.drawPath(patch.box, {x: 0, y: 1}, _canvasContainer.ctx.binary, {color: '#99ff00', lineWidth: 2}); + } + } + + // find bounding box + for ( i = 0; i < patches.length; i++) { + patch = patches[i]; + for ( j = 0; j < 4; j++) { + if (patch.box[j][0] < minx) { + minx = patch.box[j][0]; + } + if (patch.box[j][0] > maxx) { + maxx = patch.box[j][0]; + } + if (patch.box[j][1] < miny) { + miny = patch.box[j][1]; + } + if (patch.box[j][1] > maxy) { + maxy = patch.box[j][1]; + } + } + } + + box = [[minx, miny], [maxx, miny], [maxx, maxy], [minx, maxy]]; + + if (_config.boxFromPatches.showTransformedBox) { + ImageDebug.drawPath(box, {x: 0, y: 1}, _canvasContainer.ctx.binary, {color: '#ff0000', lineWidth: 2}); + } + + scale = _halfSample ? 2 : 1; + // reverse rotation; + transMat = mat2.inverse(transMat); + for ( j = 0; j < 4; j++) { + mat2.xVec2(transMat, box[j]); + } + + if (_config.boxFromPatches.showBB) { + ImageDebug.drawPath(box, {x: 0, y: 1}, _canvasContainer.ctx.binary, {color: '#ff0000', lineWidth: 2}); + } + + for ( j = 0; j < 4; j++) { + vec2.scale(box[j], scale); + } + + return box; + } + + /** + * Creates a binary image of the current image + */ + function binarizeImage() { + CVUtils.otsuThreshold(_currentImageWrapper, _binaryImageWrapper); + _binaryImageWrapper.zeroBorder(); + if (_config.showCanvas) { + _binaryImageWrapper.show(_canvasContainer.dom.binary, 255); + } + } + + /** + * Iterate over the entire image + * extract patches + */ + function findPatches() { + var i, + j, + x, + y, + moments, + patchesFound = [], + rasterizer, + rasterResult, + patch; + for ( i = 0; i < _numPatches.x; i++) { + for ( j = 0; j < _numPatches.y; j++) { + + x = _subImageWrapper.size.x * i; + y = _subImageWrapper.size.y * j; + + // seperate parts + skeletonize(x, y); + + // Rasterize, find individual bars + _skelImageWrapper.zeroBorder(); + ArrayHelper.init(_labelImageWrapper.data, 0); + rasterizer = Rasterizer.create(_skelImageWrapper, _labelImageWrapper); + rasterResult = rasterizer.rasterize(0); + + if (_config.showLabels) { + _labelImageWrapper.overlay(_canvasContainer.dom.binary, Math.floor(360 / rasterResult.count), {x : x, y : y}); + } + + // calculate moments from the skeletonized patch + moments = _labelImageWrapper.moments(rasterResult.count); + + // extract eligible patches + patchesFound = patchesFound.concat(describePatch(moments, [i, j], x, y)); + } + } + + if (_config.showFoundPatches) { + for ( i = 0; i < patchesFound.length; i++) { + patch = patchesFound[i]; + ImageDebug.drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary, {color: "#99ff00", lineWidth: 2}); + } + } + + return patchesFound; + } + + /** + * Finds those connected areas which contain at least 6 patches + * and returns them ordered DESC by the number of contained patches + * @param {Number} maxLabel + */ + function findBiggestConnectedAreas(maxLabel){ + var i, + sum, + labelHist = [], + topLabels = []; + + for ( i = 0; i < maxLabel; i++) { + labelHist.push(0); + } + sum = _patchLabelGrid.data.length; + while (sum--) { + if (_patchLabelGrid.data[sum] > 0) { + labelHist[_patchLabelGrid.data[sum] - 1]++; + } + } + + labelHist = labelHist.map(function(val, idx) { + return { + val : val, + label : idx + 1 + }; + }); + + labelHist.sort(function(a, b) { + return b.val - a.val; + }); + + // extract top areas with at least 6 patches present + topLabels = labelHist.filter(function(el) { + return el.val >= 5; + }); + + return topLabels; + } + + /** + * + */ + function findBoxes(topLabels, maxLabel) { + var i, + j, + sum, + patches = [], + patch, + box, + boxes = [], + hsv = [0, 1, 1], + rgb = [0, 0, 0]; + + for ( i = 0; i < topLabels.length; i++) { + sum = _patchLabelGrid.data.length; + patches.length = 0; + while (sum--) { + if (_patchLabelGrid.data[sum] === topLabels[i].label) { + patch = _imageToPatchGrid.data[sum]; + patches.push(patch); + } + } + box = boxFromPatches(patches); + if (box) { + boxes.push(box); + + // draw patch-labels if requested + if (_config.showRemainingPatchLabels) { + for ( j = 0; j < patches.length; j++) { + patch = patches[j]; + hsv[0] = (topLabels[i].label / (maxLabel + 1)) * 360; + CVUtils.hsv2rgb(hsv, rgb); + ImageDebug.drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary, {color: "rgb(" + rgb.join(",") + ")", lineWidth: 2}); + } + } + } + } + return boxes; + } + + /** + * Find similar moments (via cluster) + * @param {Object} moments + */ + function similarMoments(moments) { + var clusters = CVUtils.cluster(moments, 0.90); + var topCluster = CVUtils.topGeneric(clusters, 1, function(e) { + return e.getPoints().length; + }); + var points = [], result = []; + if (topCluster.length === 1) { + points = topCluster[0].item.getPoints(); + for (var i = 0; i < points.length; i++) { + result.push(points[i].point); + } + } + return result; + } + + function skeletonize(x, y) { + _binaryImageWrapper.subImageAsCopy(_subImageWrapper, CVUtils.imageRef(x, y)); + _skeletonizer.skeletonize(); + + // Show skeleton if requested + if (_config.showSkeleton) { + _skelImageWrapper.overlay(_canvasContainer.dom.binary, 360, CVUtils.imageRef(x, y)); + } + } + + /** + * Extracts and describes those patches which seem to contain a barcode pattern + * @param {Array} moments + * @param {Object} patchPos, + * @param {Number} x + * @param {Number} y + * @returns {Array} list of patches + */ + function describePatch(moments, patchPos, x, y) { + var k, avg, sum = 0, eligibleMoments = [], matchingMoments, patch, patchesFound = []; + if (moments.length >= 2) { + // only collect moments which's area covers at least 6 pixels. + for ( k = 0; k < moments.length; k++) { + if (moments[k].m00 > 6) { + eligibleMoments.push(moments[k]); + } + } + + // if at least 2 moments are found which have 6pixels covered + if (eligibleMoments.length >= 2) { + sum = eligibleMoments.length; + matchingMoments = similarMoments(eligibleMoments); + avg = 0; + // determine the similarity of the moments + for ( k = 0; k < matchingMoments.length; k++) { + avg += matchingMoments[k].rad; + } + + // Only two of the moments are allowed not to fit into the equation + // add the patch to the set + if (matchingMoments.length > 1 && matchingMoments.length >= (eligibleMoments.length / 4) * 3 && matchingMoments.length > moments.length / 4) { + avg /= matchingMoments.length; + patch = { + index : patchPos[1] * _numPatches.x + patchPos[0], + pos : { + x : x, + y : y + }, + box : [vec2.create([x, y]), vec2.create([x + _subImageWrapper.size.x, y]), vec2.create([x + _subImageWrapper.size.x, y + _subImageWrapper.size.y]), vec2.create([x, y + _subImageWrapper.size.y])], + moments : matchingMoments, + rad : avg, + vec : vec2.create([Math.cos(avg), Math.sin(avg)]) + }; + patchesFound.push(patch); + } + } + } + return patchesFound; + } + + /** + * finds patches which are connected and share the same orientation + * @param {Object} patchesFound + */ + function rasterizeAngularSimilarity(patchesFound) { + var label = 0, + threshold = 0.95, + currIdx = 0, + j, + patch, + hsv = [0, 1, 1], + rgb = [0, 0, 0]; + + function notYetProcessed() { + var i; + for ( i = 0; i < _patchLabelGrid.data.length; i++) { + if (_patchLabelGrid.data[i] === 0 && _patchGrid.data[i] === 1) { + return i; + } + } + return _patchLabelGrid.length; + } + + function trace(currentIdx) { + var x, y, currentPatch, patch, idx, dir, current = { + x : currentIdx % _patchLabelGrid.size.x, + y : (currentIdx / _patchLabelGrid.size.x) | 0 + }, similarity; + + if (currentIdx < _patchLabelGrid.data.length) { + currentPatch = _imageToPatchGrid.data[currentIdx]; + // assign label + _patchLabelGrid.data[currentIdx] = label; + for ( dir = 0; dir < Tracer.searchDirections.length; dir++) { + y = current.y + Tracer.searchDirections[dir][0]; + x = current.x + Tracer.searchDirections[dir][1]; + idx = y * _patchLabelGrid.size.x + x; + + // continue if patch empty + if (_patchGrid.data[idx] === 0) { + _patchLabelGrid.data[idx] = Number.MAX_VALUE; + continue; + } + + patch = _imageToPatchGrid.data[idx]; + if (_patchLabelGrid.data[idx] === 0) { + similarity = Math.abs(vec2.dot(patch.vec, currentPatch.vec)); + if (similarity > threshold) { + trace(idx); + } + } + } + } + } + + // prepare for finding the right patches + ArrayHelper.init(_patchGrid.data, 0); + ArrayHelper.init(_patchLabelGrid.data, 0); + ArrayHelper.init(_imageToPatchGrid.data, null); + + for ( j = 0; j < patchesFound.length; j++) { + patch = patchesFound[j]; + _imageToPatchGrid.data[patch.index] = patch; + _patchGrid.data[patch.index] = 1; + } + + // rasterize the patches found to determine area + _patchGrid.zeroBorder(); + + while (( currIdx = notYetProcessed()) < _patchLabelGrid.data.length) { + label++; + trace(currIdx); + } + + // draw patch-labels if requested + if (_config.showPatchLabels) { + for ( j = 0; j < _patchLabelGrid.data.length; j++) { + if (_patchLabelGrid.data[j] > 0 && _patchLabelGrid.data[j] <= label) { + patch = _imageToPatchGrid.data[j]; + hsv[0] = (_patchLabelGrid.data[j] / (label + 1)) * 360; + CVUtils.hsv2rgb(hsv, rgb); + ImageDebug.drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary, {color: "rgb(" + rgb.join(",") + ")", lineWidth: 2}); + } + } + } + + return label; + } + + function initWorker(cb) { + var tmpData; + + _worker = new Worker('../src/worker_locator.js'); + tmpData = _inputImageWrapper.data; + _inputImageWrapper.data = null; // do not send the data along + _worker.postMessage({cmd: 'init', inputImageWrapper: _inputImageWrapper}); + _inputImageWrapper.data = tmpData; + _worker.onmessage = function(e) { + if (e.data.event === 'initialized') { + _initialized = true; + cb(); + } else if (e.data.event === 'located') { + _inputImageWrapper.data = new Uint8Array(e.data.buffer); + _locatedCb(e.data.result); + } + }; + } + + return { + init : function(config, data, cb) { + _config = config; + _inputImageWrapper = data.inputImageWrapper; + + // 1. check config for web-worker + if (_config.useWorker) { + initWorker(cb); + } else { + initBuffers(); + initCanvas(); + cb(); + } + }, + locate : function(cb) { + var patchesFound, + topLabels = [], + boxes = []; + + if (_config.useWorker) { + _locatedCb = cb; + _worker.postMessage({cmd: 'locate', buffer: _inputImageWrapper.data}, [_inputImageWrapper.data.buffer]); + } else { + if (_halfSample) { + CVUtils.halfSample(_inputImageWrapper, _currentImageWrapper); + } + + binarizeImage(); + patchesFound = findPatches(); + // return unless 5% or more patches are found + if (patchesFound.length < _numPatches.x * _numPatches.y * 0.05) { + return cb(null); + } + + // rasterrize area by comparing angular similarity; + var maxLabel = rasterizeAngularSimilarity(patchesFound); + if (maxLabel <= 1) { + return cb(null); + } + + // search for area with the most patches (biggest connected area) + topLabels = findBiggestConnectedAreas(maxLabel); + if (topLabels.length === 0) { + return cb(null); + } + + boxes = findBoxes(topLabels, maxLabel); + cb(boxes); + } + } + }; +}); + + + return require('barcode_locator'); +})); \ No newline at end of file diff --git a/dist/quagga.js b/dist/quagga.js index 79bcabd..d7df581 100644 --- a/dist/quagga.js +++ b/dist/quagga.js @@ -1621,21 +1621,22 @@ define('input_stream',["image_loader"], function(ImageLoader) { */ glMatrixArrayType = Float32Array; +if (typeof window !== 'undefined') { + window.requestAnimFrame = (function () { + return window.requestAnimationFrame || + window.webkitRequestAnimationFrame || + window.mozRequestAnimationFrame || + window.oRequestAnimationFrame || + window.msRequestAnimationFrame || + function (/* function FrameRequestCallback */ callback, /* DOMElement Element */ element) { + window.setTimeout(callback, 1000 / 60); + }; + })(); -window.requestAnimFrame = (function() { - return window.requestAnimationFrame || - window.webkitRequestAnimationFrame || - window.mozRequestAnimationFrame || - window.oRequestAnimationFrame || - window.msRequestAnimationFrame || - function(/* function FrameRequestCallback */ callback, /* DOMElement Element */ element) { - window.setTimeout(callback, 1000/60); - }; -})(); - + navigator.getUserMedia = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia || navigator.msGetUserMedia; + window.URL = window.URL || window.webkitURL || window.mozURL || window.msURL; +} -navigator.getUserMedia = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia || navigator.msGetUserMedia; -window.URL = window.URL || window.webkitURL || window.mozURL || window.msURL; define("typedefs", (function (global) { return function () { var ret, fn; @@ -5720,7 +5721,11 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I }, _numPatches = {x: 0, y: 0}, _inputImageWrapper, - _skeletonizer; + _skeletonizer, + self = this, + _worker, + _locatedCb, + _initialized; function initBuffers() { var skeletonImageData; @@ -5746,10 +5751,10 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I _labelImageWrapper = new ImageWrapper(_patchSize, undefined, Array, true); - skeletonImageData = new ArrayBuffer(_patchSize.x * _patchSize.y * 16); + skeletonImageData = new ArrayBuffer(64*1024); _subImageWrapper = new ImageWrapper(_patchSize, new Uint8Array(skeletonImageData, 0, _patchSize.x * _patchSize.y)); _skelImageWrapper = new ImageWrapper(_patchSize, new Uint8Array(skeletonImageData, _patchSize.x * _patchSize.y * 3, _patchSize.x * _patchSize.y), undefined, true); - _skeletonizer = skeletonizer(window, { + _skeletonizer = skeletonizer(self, { size : _patchSize.x }, skeletonImageData); @@ -5762,6 +5767,9 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I } function initCanvas() { + if (_config.useWorker || typeof document === 'undefined') { + return; + } _canvasContainer.dom.binary = document.createElement("canvas"); _canvasContainer.dom.binary.className = "binaryBuffer"; if (_config.showCanvas === true) { @@ -6165,44 +6173,74 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I return label; } + function initWorker(cb) { + var tmpData; + + _worker = new Worker('../src/worker_locator.js'); + tmpData = _inputImageWrapper.data; + _inputImageWrapper.data = null; // do not send the data along + _worker.postMessage({cmd: 'init', inputImageWrapper: _inputImageWrapper}); + _inputImageWrapper.data = tmpData; + _worker.onmessage = function(e) { + if (e.data.event === 'initialized') { + _initialized = true; + cb(); + } else if (e.data.event === 'located') { + _inputImageWrapper.data = new Uint8Array(e.data.buffer); + _locatedCb(e.data.result); + } + }; + } + return { - init : function(config, data) { + init : function(config, data, cb) { _config = config; _inputImageWrapper = data.inputImageWrapper; - initBuffers(); - initCanvas(); + + // 1. check config for web-worker + if (_config.useWorker) { + initWorker(cb); + } else { + initBuffers(); + initCanvas(); + cb(); + } }, - locate : function() { + locate : function(cb) { var patchesFound, topLabels = [], boxes = []; - if (_halfSample) { - CVUtils.halfSample(_inputImageWrapper, _currentImageWrapper); - } - - binarizeImage(); - patchesFound = findPatches(); - // return unless 5% or more patches are found - if (patchesFound.length < _numPatches.x * _numPatches.y * 0.05) { - return; - } - - // rasterrize area by comparing angular similarity; - var maxLabel = rasterizeAngularSimilarity(patchesFound); - if (maxLabel <= 1) { - return null; - } - - // search for area with the most patches (biggest connected area) - topLabels = findBiggestConnectedAreas(maxLabel); - if (topLabels.length === 0) { - return null; + if (_config.useWorker) { + _locatedCb = cb; + _worker.postMessage({cmd: 'locate', buffer: _inputImageWrapper.data}, [_inputImageWrapper.data.buffer]); + } else { + if (_halfSample) { + CVUtils.halfSample(_inputImageWrapper, _currentImageWrapper); + } + + binarizeImage(); + patchesFound = findPatches(); + // return unless 5% or more patches are found + if (patchesFound.length < _numPatches.x * _numPatches.y * 0.05) { + return cb(null); + } + + // rasterrize area by comparing angular similarity; + var maxLabel = rasterizeAngularSimilarity(patchesFound); + if (maxLabel <= 1) { + return cb(null); + } + + // search for area with the most patches (biggest connected area) + topLabels = findBiggestConnectedAreas(maxLabel); + if (topLabels.length === 0) { + return cb(null); + } + + boxes = findBoxes(topLabels, maxLabel); + cb(boxes); } - - boxes = findBoxes(topLabels, maxLabel); - - return boxes; } }; }); @@ -6820,6 +6858,7 @@ define('config',[],function(){ ] }, locator: { + useWorker: true, showCanvas: false, showPatches: false, showFoundPatches: false, @@ -7111,18 +7150,19 @@ function(Code128Reader, EANReader, InputStream, ImageWrapper, BarcodeLocator, Ba } function canRecord() { - initBuffers(); - initCanvas(); - _decoder = BarcodeDecoder.create(_config.decoder, _inputImageWrapper); - _framegrabber = FrameGrabber.create(_inputStream, _canvasContainer.dom.image); - _framegrabber.attachData(_inputImageWrapper.data); - - initConfig(); - _inputStream.play(); - _initialized = true; - if (_config.readyFunc) { - _config.readyFunc.apply(); - } + initBuffers(function() { + initCanvas(); + _decoder = BarcodeDecoder.create(_config.decoder, _inputImageWrapper); + _framegrabber = FrameGrabber.create(_inputStream, _canvasContainer.dom.image); + _framegrabber.attachData(_inputImageWrapper.data); + + initConfig(); + _inputStream.play(); + _initialized = true; + if (_config.readyFunc) { + _config.readyFunc.apply(); + } + }); } function initCanvas() { @@ -7157,7 +7197,7 @@ function(Code128Reader, EANReader, InputStream, ImageWrapper, BarcodeLocator, Ba _canvasContainer.dom.overlay.height = _inputImageWrapper.size.y; } - function initBuffers() { + function initBuffers(cb) { _inputImageWrapper = new ImageWrapper({ x : _inputStream.getWidth(), y : _inputStream.getHeight() @@ -7170,35 +7210,34 @@ function(Code128Reader, EANReader, InputStream, ImageWrapper, BarcodeLocator, Ba vec2.create([_inputStream.getWidth() - 20, _inputStream.getHeight() / 2 + 100]), vec2.create([_inputStream.getWidth() - 20, _inputStream.getHeight() / 2 - 100]) ]; - BarcodeLocator.init(_config.locator, { - inputImageWrapper : _inputImageWrapper - }); + BarcodeLocator.init(_config.locator, {inputImageWrapper : _inputImageWrapper}, cb); } - function getBoundingBoxes() { - var boxes; - + function getBoundingBoxes(cb) { if (_config.locate) { - boxes = BarcodeLocator.locate(); + BarcodeLocator.locate(cb); } else { - boxes = [_boxSize]; + cb([_boxSize]); } - return boxes; } function update() { - var result, - boxes; + var result; if (_framegrabber.grab()) { _canvasContainer.ctx.overlay.clearRect(0, 0, _inputImageWrapper.size.x, _inputImageWrapper.size.y); - boxes = getBoundingBoxes(); - if (boxes) { - result = _decoder.decodeFromBoundingBoxes(boxes); - if (result && result.codeResult) { - Events.publish("detected", result.codeResult.code); + console.time("getBoundingBoxes"); + getBoundingBoxes(function(boxes) { + console.timeEnd("getBoundingBoxes"); + // attach data back to grabber + _framegrabber.attachData(_inputImageWrapper.data); + if (boxes) { + result = _decoder.decodeFromBoundingBoxes(boxes); + if (result && result.codeResult) { + Events.publish("detected", result.codeResult.code); + } } - } + }); } } diff --git a/src/barcode_locator.js b/src/barcode_locator.js index 35cec3f..8f68ed7 100644 --- a/src/barcode_locator.js +++ b/src/barcode_locator.js @@ -26,7 +26,11 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I }, _numPatches = {x: 0, y: 0}, _inputImageWrapper, - _skeletonizer; + _skeletonizer, + self = this, + _worker, + _locatedCb, + _initialized; function initBuffers() { var skeletonImageData; @@ -52,10 +56,10 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I _labelImageWrapper = new ImageWrapper(_patchSize, undefined, Array, true); - skeletonImageData = new ArrayBuffer(_patchSize.x * _patchSize.y * 16); + skeletonImageData = new ArrayBuffer(64*1024); _subImageWrapper = new ImageWrapper(_patchSize, new Uint8Array(skeletonImageData, 0, _patchSize.x * _patchSize.y)); _skelImageWrapper = new ImageWrapper(_patchSize, new Uint8Array(skeletonImageData, _patchSize.x * _patchSize.y * 3, _patchSize.x * _patchSize.y), undefined, true); - _skeletonizer = skeletonizer(window, { + _skeletonizer = skeletonizer(self, { size : _patchSize.x }, skeletonImageData); @@ -68,6 +72,9 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I } function initCanvas() { + if (_config.useWorker || typeof document === 'undefined') { + return; + } _canvasContainer.dom.binary = document.createElement("canvas"); _canvasContainer.dom.binary.className = "binaryBuffer"; if (_config.showCanvas === true) { @@ -471,44 +478,74 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I return label; } + function initWorker(cb) { + var tmpData; + + _worker = new Worker('../src/worker_locator.js'); + tmpData = _inputImageWrapper.data; + _inputImageWrapper.data = null; // do not send the data along + _worker.postMessage({cmd: 'init', inputImageWrapper: _inputImageWrapper}); + _inputImageWrapper.data = tmpData; + _worker.onmessage = function(e) { + if (e.data.event === 'initialized') { + _initialized = true; + cb(); + } else if (e.data.event === 'located') { + _inputImageWrapper.data = new Uint8Array(e.data.buffer); + _locatedCb(e.data.result); + } + }; + } + return { - init : function(config, data) { + init : function(config, data, cb) { _config = config; _inputImageWrapper = data.inputImageWrapper; - initBuffers(); - initCanvas(); + + // 1. check config for web-worker + if (_config.useWorker) { + initWorker(cb); + } else { + initBuffers(); + initCanvas(); + cb(); + } }, - locate : function() { + locate : function(cb) { var patchesFound, topLabels = [], boxes = []; - if (_halfSample) { - CVUtils.halfSample(_inputImageWrapper, _currentImageWrapper); - } - - binarizeImage(); - patchesFound = findPatches(); - // return unless 5% or more patches are found - if (patchesFound.length < _numPatches.x * _numPatches.y * 0.05) { - return; - } - - // rasterrize area by comparing angular similarity; - var maxLabel = rasterizeAngularSimilarity(patchesFound); - if (maxLabel <= 1) { - return null; - } - - // search for area with the most patches (biggest connected area) - topLabels = findBiggestConnectedAreas(maxLabel); - if (topLabels.length === 0) { - return null; + if (_config.useWorker) { + _locatedCb = cb; + _worker.postMessage({cmd: 'locate', buffer: _inputImageWrapper.data}, [_inputImageWrapper.data.buffer]); + } else { + if (_halfSample) { + CVUtils.halfSample(_inputImageWrapper, _currentImageWrapper); + } + + binarizeImage(); + patchesFound = findPatches(); + // return unless 5% or more patches are found + if (patchesFound.length < _numPatches.x * _numPatches.y * 0.05) { + return cb(null); + } + + // rasterrize area by comparing angular similarity; + var maxLabel = rasterizeAngularSimilarity(patchesFound); + if (maxLabel <= 1) { + return cb(null); + } + + // search for area with the most patches (biggest connected area) + topLabels = findBiggestConnectedAreas(maxLabel); + if (topLabels.length === 0) { + return cb(null); + } + + boxes = findBoxes(topLabels, maxLabel); + cb(boxes); } - - boxes = findBoxes(topLabels, maxLabel); - - return boxes; } }; }); diff --git a/src/config.js b/src/config.js index d2a7048..2b5f217 100644 --- a/src/config.js +++ b/src/config.js @@ -24,6 +24,7 @@ define(function(){ ] }, locator: { + useWorker: true, showCanvas: false, showPatches: false, showFoundPatches: false, diff --git a/src/quagga.js b/src/quagga.js index 11d3e7f..6407df1 100644 --- a/src/quagga.js +++ b/src/quagga.js @@ -78,18 +78,19 @@ function(Code128Reader, EANReader, InputStream, ImageWrapper, BarcodeLocator, Ba } function canRecord() { - initBuffers(); - initCanvas(); - _decoder = BarcodeDecoder.create(_config.decoder, _inputImageWrapper); - _framegrabber = FrameGrabber.create(_inputStream, _canvasContainer.dom.image); - _framegrabber.attachData(_inputImageWrapper.data); - - initConfig(); - _inputStream.play(); - _initialized = true; - if (_config.readyFunc) { - _config.readyFunc.apply(); - } + initBuffers(function() { + initCanvas(); + _decoder = BarcodeDecoder.create(_config.decoder, _inputImageWrapper); + _framegrabber = FrameGrabber.create(_inputStream, _canvasContainer.dom.image); + _framegrabber.attachData(_inputImageWrapper.data); + + initConfig(); + _inputStream.play(); + _initialized = true; + if (_config.readyFunc) { + _config.readyFunc.apply(); + } + }); } function initCanvas() { @@ -124,7 +125,7 @@ function(Code128Reader, EANReader, InputStream, ImageWrapper, BarcodeLocator, Ba _canvasContainer.dom.overlay.height = _inputImageWrapper.size.y; } - function initBuffers() { + function initBuffers(cb) { _inputImageWrapper = new ImageWrapper({ x : _inputStream.getWidth(), y : _inputStream.getHeight() @@ -137,35 +138,34 @@ function(Code128Reader, EANReader, InputStream, ImageWrapper, BarcodeLocator, Ba vec2.create([_inputStream.getWidth() - 20, _inputStream.getHeight() / 2 + 100]), vec2.create([_inputStream.getWidth() - 20, _inputStream.getHeight() / 2 - 100]) ]; - BarcodeLocator.init(_config.locator, { - inputImageWrapper : _inputImageWrapper - }); + BarcodeLocator.init(_config.locator, {inputImageWrapper : _inputImageWrapper}, cb); } - function getBoundingBoxes() { - var boxes; - + function getBoundingBoxes(cb) { if (_config.locate) { - boxes = BarcodeLocator.locate(); + BarcodeLocator.locate(cb); } else { - boxes = [_boxSize]; + cb([_boxSize]); } - return boxes; } function update() { - var result, - boxes; + var result; if (_framegrabber.grab()) { _canvasContainer.ctx.overlay.clearRect(0, 0, _inputImageWrapper.size.x, _inputImageWrapper.size.y); - boxes = getBoundingBoxes(); - if (boxes) { - result = _decoder.decodeFromBoundingBoxes(boxes); - if (result && result.codeResult) { - Events.publish("detected", result.codeResult.code); + console.time("getBoundingBoxes"); + getBoundingBoxes(function(boxes) { + console.timeEnd("getBoundingBoxes"); + // attach data back to grabber + _framegrabber.attachData(_inputImageWrapper.data); + if (boxes) { + result = _decoder.decodeFromBoundingBoxes(boxes); + if (result && result.codeResult) { + Events.publish("detected", result.codeResult.code); + } } - } + }); } } diff --git a/src/typedefs.js b/src/typedefs.js index 151fe89..585dfb6 100644 --- a/src/typedefs.js +++ b/src/typedefs.js @@ -4,18 +4,18 @@ */ glMatrixArrayType = Float32Array; +if (typeof window !== 'undefined') { + window.requestAnimFrame = (function () { + return window.requestAnimationFrame || + window.webkitRequestAnimationFrame || + window.mozRequestAnimationFrame || + window.oRequestAnimationFrame || + window.msRequestAnimationFrame || + function (/* function FrameRequestCallback */ callback, /* DOMElement Element */ element) { + window.setTimeout(callback, 1000 / 60); + }; + })(); -window.requestAnimFrame = (function() { - return window.requestAnimationFrame || - window.webkitRequestAnimationFrame || - window.mozRequestAnimationFrame || - window.oRequestAnimationFrame || - window.msRequestAnimationFrame || - function(/* function FrameRequestCallback */ callback, /* DOMElement Element */ element) { - window.setTimeout(callback, 1000/60); - }; -})(); - - -navigator.getUserMedia = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia || navigator.msGetUserMedia; -window.URL = window.URL || window.webkitURL || window.mozURL || window.msURL; \ No newline at end of file + navigator.getUserMedia = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia || navigator.msGetUserMedia; + window.URL = window.URL || window.webkitURL || window.mozURL || window.msURL; +} diff --git a/src/worker_locator.js b/src/worker_locator.js new file mode 100644 index 0000000..1a6c60b --- /dev/null +++ b/src/worker_locator.js @@ -0,0 +1,39 @@ +/* jshint undef: true, unused: true, browser:true, devel: true */ +/* global importScripts, self, Locator */ + +importScripts('../dist/locator.js'); +var inputImageWrapper = null; +self.onmessage = function(e) { + if (e.data.cmd === 'init') { + inputImageWrapper = e.data.inputImageWrapper; + init(function() { + self.postMessage({'event': 'initialized'}); + }); + } else if (e.data.cmd === 'locate') { + locate(new Uint8Array(e.data.buffer), function(result) { + self.postMessage({'event': 'located', result: result, buffer : inputImageWrapper.data}, [inputImageWrapper.data.buffer]); + }); + } +}; +function init(cb) { + Locator.init({ + showCanvas: false, + showPatches: false, + showFoundPatches: false, + showSkeleton: false, + showLabels: false, + showPatchLabels: false, + showRemainingPatchLabels: false, + boxFromPatches: { + showTransformed: false, + showTransformedBox: false, + showBB: false + } + }, { + inputImageWrapper : inputImageWrapper + }, cb); +} +function locate(buffer, cb) { + inputImageWrapper.data = buffer; + Locator.locate(cb); +} \ No newline at end of file From 63993dfa8c7932a2e6b2e4a16665cf7c9cf60533 Mon Sep 17 00:00:00 2001 From: Christoph Oberhofer Date: Sun, 18 Jan 2015 11:56:34 +0100 Subject: [PATCH 2/9] Web-Worker now working for live-streams. Passing config to worker --- dist/locator.js | 17 ++++++++--------- dist/quagga.js | 34 +++++++++++++++++----------------- example/live_w_locator.html | 1 + example/live_w_locator.js | 6 ++++++ example/static_images.js | 2 +- src/barcode_locator.js | 17 ++++++++--------- src/config.js | 1 + src/quagga.js | 16 ++++++++-------- src/worker_locator.js | 36 ++++++++++-------------------------- 9 files changed, 60 insertions(+), 70 deletions(-) diff --git a/dist/locator.js b/dist/locator.js index 53196b7..c823c80 100644 --- a/dist/locator.js +++ b/dist/locator.js @@ -4528,7 +4528,6 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I _patchLabelGrid, _imageToPatchGrid, _binaryImageWrapper, - _halfSample = true, _patchSize, _canvasContainer = { ctx : { @@ -4549,7 +4548,7 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I function initBuffers() { var skeletonImageData; - if (_halfSample) { + if (_config.halfSample) { _currentImageWrapper = new ImageWrapper({ x : _inputImageWrapper.size.x / 2 | 0, y : _inputImageWrapper.size.y / 2 | 0 @@ -4559,8 +4558,8 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I } _patchSize = { - x : 16 * ( _halfSample ? 1 : 2), - y : 16 * ( _halfSample ? 1 : 2) + x : 16 * ( _config.halfSample ? 1 : 2), + y : 16 * ( _config.halfSample ? 1 : 2) }; _numPatches.x = _currentImageWrapper.size.x / _patchSize.x | 0; @@ -4663,7 +4662,7 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I ImageDebug.drawPath(box, {x: 0, y: 1}, _canvasContainer.ctx.binary, {color: '#ff0000', lineWidth: 2}); } - scale = _halfSample ? 2 : 1; + scale = _config.halfSample ? 2 : 1; // reverse rotation; transMat = mat2.inverse(transMat); for ( j = 0; j < 4; j++) { @@ -4998,7 +4997,7 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I _worker = new Worker('../src/worker_locator.js'); tmpData = _inputImageWrapper.data; _inputImageWrapper.data = null; // do not send the data along - _worker.postMessage({cmd: 'init', inputImageWrapper: _inputImageWrapper}); + _worker.postMessage({cmd: 'init', inputImageWrapper: _inputImageWrapper, config: _config}); _inputImageWrapper.data = tmpData; _worker.onmessage = function(e) { if (e.data.event === 'initialized') { @@ -5012,9 +5011,9 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I } return { - init : function(config, data, cb) { + init : function(inputImageWrapper, config, cb) { _config = config; - _inputImageWrapper = data.inputImageWrapper; + _inputImageWrapper = inputImageWrapper; // 1. check config for web-worker if (_config.useWorker) { @@ -5034,7 +5033,7 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I _locatedCb = cb; _worker.postMessage({cmd: 'locate', buffer: _inputImageWrapper.data}, [_inputImageWrapper.data.buffer]); } else { - if (_halfSample) { + if (_config.halfSample) { CVUtils.halfSample(_inputImageWrapper, _currentImageWrapper); } diff --git a/dist/quagga.js b/dist/quagga.js index d7df581..964aa47 100644 --- a/dist/quagga.js +++ b/dist/quagga.js @@ -5709,7 +5709,6 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I _patchLabelGrid, _imageToPatchGrid, _binaryImageWrapper, - _halfSample = true, _patchSize, _canvasContainer = { ctx : { @@ -5730,7 +5729,7 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I function initBuffers() { var skeletonImageData; - if (_halfSample) { + if (_config.halfSample) { _currentImageWrapper = new ImageWrapper({ x : _inputImageWrapper.size.x / 2 | 0, y : _inputImageWrapper.size.y / 2 | 0 @@ -5740,8 +5739,8 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I } _patchSize = { - x : 16 * ( _halfSample ? 1 : 2), - y : 16 * ( _halfSample ? 1 : 2) + x : 16 * ( _config.halfSample ? 1 : 2), + y : 16 * ( _config.halfSample ? 1 : 2) }; _numPatches.x = _currentImageWrapper.size.x / _patchSize.x | 0; @@ -5844,7 +5843,7 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I ImageDebug.drawPath(box, {x: 0, y: 1}, _canvasContainer.ctx.binary, {color: '#ff0000', lineWidth: 2}); } - scale = _halfSample ? 2 : 1; + scale = _config.halfSample ? 2 : 1; // reverse rotation; transMat = mat2.inverse(transMat); for ( j = 0; j < 4; j++) { @@ -6179,7 +6178,7 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I _worker = new Worker('../src/worker_locator.js'); tmpData = _inputImageWrapper.data; _inputImageWrapper.data = null; // do not send the data along - _worker.postMessage({cmd: 'init', inputImageWrapper: _inputImageWrapper}); + _worker.postMessage({cmd: 'init', inputImageWrapper: _inputImageWrapper, config: _config}); _inputImageWrapper.data = tmpData; _worker.onmessage = function(e) { if (e.data.event === 'initialized') { @@ -6193,9 +6192,9 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I } return { - init : function(config, data, cb) { + init : function(inputImageWrapper, config, cb) { _config = config; - _inputImageWrapper = data.inputImageWrapper; + _inputImageWrapper = inputImageWrapper; // 1. check config for web-worker if (_config.useWorker) { @@ -6215,7 +6214,7 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I _locatedCb = cb; _worker.postMessage({cmd: 'locate', buffer: _inputImageWrapper.data}, [_inputImageWrapper.data.buffer]); } else { - if (_halfSample) { + if (_config.halfSample) { CVUtils.halfSample(_inputImageWrapper, _currentImageWrapper); } @@ -6858,6 +6857,7 @@ define('config',[],function(){ ] }, locator: { + halfSample: true, useWorker: true, showCanvas: false, showPatches: false, @@ -7210,7 +7210,7 @@ function(Code128Reader, EANReader, InputStream, ImageWrapper, BarcodeLocator, Ba vec2.create([_inputStream.getWidth() - 20, _inputStream.getHeight() / 2 + 100]), vec2.create([_inputStream.getWidth() - 20, _inputStream.getHeight() / 2 - 100]) ]; - BarcodeLocator.init(_config.locator, {inputImageWrapper : _inputImageWrapper}, cb); + BarcodeLocator.init(_inputImageWrapper, _config.locator, cb); } function getBoundingBoxes(cb) { @@ -7221,14 +7221,12 @@ function(Code128Reader, EANReader, InputStream, ImageWrapper, BarcodeLocator, Ba } } - function update() { + function update(cb) { var result; if (_framegrabber.grab()) { _canvasContainer.ctx.overlay.clearRect(0, 0, _inputImageWrapper.size.x, _inputImageWrapper.size.y); - console.time("getBoundingBoxes"); getBoundingBoxes(function(boxes) { - console.timeEnd("getBoundingBoxes"); // attach data back to grabber _framegrabber.attachData(_inputImageWrapper.data); if (boxes) { @@ -7237,6 +7235,7 @@ function(Code128Reader, EANReader, InputStream, ImageWrapper, BarcodeLocator, Ba Events.publish("detected", result.codeResult.code); } } + return cb(); }); } } @@ -7245,10 +7244,11 @@ function(Code128Reader, EANReader, InputStream, ImageWrapper, BarcodeLocator, Ba _stopped = false; ( function frame() { if (!_stopped) { - if (_config.inputStream.type == "LiveStream") { - window.requestAnimFrame(frame); - } - update(); + update(function() { + if (_config.inputStream.type == "LiveStream") { + window.requestAnimFrame(frame); + } + }); } }()); } diff --git a/example/live_w_locator.html b/example/live_w_locator.html index 10ef63f..9849539 100644 --- a/example/live_w_locator.html +++ b/example/live_w_locator.html @@ -27,6 +27,7 @@ It works best if your camera has built-in auto-focus.

+
diff --git a/example/live_w_locator.js b/example/live_w_locator.js index af46b6d..42b8551 100644 --- a/example/live_w_locator.js +++ b/example/live_w_locator.js @@ -20,9 +20,15 @@ $(function() { e.preventDefault(); Quagga.setReaders([e.target.value + "_reader"]); }); + + $(".controls").on("click", "button.stop", function(e) { + e.preventDefault(); + Quagga.stop(); + }); }, detachListeners : function() { $(".controls .reader-group").off("change", "input"); + $(".controls").off("click", "button.stop"); }, lastResult : null }; diff --git a/example/static_images.js b/example/static_images.js index cda493c..7165986 100644 --- a/example/static_images.js +++ b/example/static_images.js @@ -4,7 +4,7 @@ $(function() { Quagga.init({ inputStream: { name: "Test", type: "ImageStream", - src: "/test/fixtures/" + App.config.reader + "/", + src: "../test/fixtures/" + App.config.reader + "/", length: App.config.length }, decoder : { diff --git a/src/barcode_locator.js b/src/barcode_locator.js index 8f68ed7..3c8da8e 100644 --- a/src/barcode_locator.js +++ b/src/barcode_locator.js @@ -14,7 +14,6 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I _patchLabelGrid, _imageToPatchGrid, _binaryImageWrapper, - _halfSample = true, _patchSize, _canvasContainer = { ctx : { @@ -35,7 +34,7 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I function initBuffers() { var skeletonImageData; - if (_halfSample) { + if (_config.halfSample) { _currentImageWrapper = new ImageWrapper({ x : _inputImageWrapper.size.x / 2 | 0, y : _inputImageWrapper.size.y / 2 | 0 @@ -45,8 +44,8 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I } _patchSize = { - x : 16 * ( _halfSample ? 1 : 2), - y : 16 * ( _halfSample ? 1 : 2) + x : 16 * ( _config.halfSample ? 1 : 2), + y : 16 * ( _config.halfSample ? 1 : 2) }; _numPatches.x = _currentImageWrapper.size.x / _patchSize.x | 0; @@ -149,7 +148,7 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I ImageDebug.drawPath(box, {x: 0, y: 1}, _canvasContainer.ctx.binary, {color: '#ff0000', lineWidth: 2}); } - scale = _halfSample ? 2 : 1; + scale = _config.halfSample ? 2 : 1; // reverse rotation; transMat = mat2.inverse(transMat); for ( j = 0; j < 4; j++) { @@ -484,7 +483,7 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I _worker = new Worker('../src/worker_locator.js'); tmpData = _inputImageWrapper.data; _inputImageWrapper.data = null; // do not send the data along - _worker.postMessage({cmd: 'init', inputImageWrapper: _inputImageWrapper}); + _worker.postMessage({cmd: 'init', inputImageWrapper: _inputImageWrapper, config: _config}); _inputImageWrapper.data = tmpData; _worker.onmessage = function(e) { if (e.data.event === 'initialized') { @@ -498,9 +497,9 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I } return { - init : function(config, data, cb) { + init : function(inputImageWrapper, config, cb) { _config = config; - _inputImageWrapper = data.inputImageWrapper; + _inputImageWrapper = inputImageWrapper; // 1. check config for web-worker if (_config.useWorker) { @@ -520,7 +519,7 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I _locatedCb = cb; _worker.postMessage({cmd: 'locate', buffer: _inputImageWrapper.data}, [_inputImageWrapper.data.buffer]); } else { - if (_halfSample) { + if (_config.halfSample) { CVUtils.halfSample(_inputImageWrapper, _currentImageWrapper); } diff --git a/src/config.js b/src/config.js index 2b5f217..b535d66 100644 --- a/src/config.js +++ b/src/config.js @@ -24,6 +24,7 @@ define(function(){ ] }, locator: { + halfSample: true, useWorker: true, showCanvas: false, showPatches: false, diff --git a/src/quagga.js b/src/quagga.js index 6407df1..e404d74 100644 --- a/src/quagga.js +++ b/src/quagga.js @@ -138,7 +138,7 @@ function(Code128Reader, EANReader, InputStream, ImageWrapper, BarcodeLocator, Ba vec2.create([_inputStream.getWidth() - 20, _inputStream.getHeight() / 2 + 100]), vec2.create([_inputStream.getWidth() - 20, _inputStream.getHeight() / 2 - 100]) ]; - BarcodeLocator.init(_config.locator, {inputImageWrapper : _inputImageWrapper}, cb); + BarcodeLocator.init(_inputImageWrapper, _config.locator, cb); } function getBoundingBoxes(cb) { @@ -149,14 +149,12 @@ function(Code128Reader, EANReader, InputStream, ImageWrapper, BarcodeLocator, Ba } } - function update() { + function update(cb) { var result; if (_framegrabber.grab()) { _canvasContainer.ctx.overlay.clearRect(0, 0, _inputImageWrapper.size.x, _inputImageWrapper.size.y); - console.time("getBoundingBoxes"); getBoundingBoxes(function(boxes) { - console.timeEnd("getBoundingBoxes"); // attach data back to grabber _framegrabber.attachData(_inputImageWrapper.data); if (boxes) { @@ -165,6 +163,7 @@ function(Code128Reader, EANReader, InputStream, ImageWrapper, BarcodeLocator, Ba Events.publish("detected", result.codeResult.code); } } + return cb(); }); } } @@ -173,10 +172,11 @@ function(Code128Reader, EANReader, InputStream, ImageWrapper, BarcodeLocator, Ba _stopped = false; ( function frame() { if (!_stopped) { - if (_config.inputStream.type == "LiveStream") { - window.requestAnimFrame(frame); - } - update(); + update(function() { + if (_config.inputStream.type == "LiveStream") { + window.requestAnimFrame(frame); + } + }); } }()); } diff --git a/src/worker_locator.js b/src/worker_locator.js index 1a6c60b..bb6b512 100644 --- a/src/worker_locator.js +++ b/src/worker_locator.js @@ -2,38 +2,22 @@ /* global importScripts, self, Locator */ importScripts('../dist/locator.js'); -var inputImageWrapper = null; +var inputImageWrapper, + config; + self.onmessage = function(e) { if (e.data.cmd === 'init') { inputImageWrapper = e.data.inputImageWrapper; - init(function() { + config = e.data.config; + + config.useWorker = false; + Locator.init(inputImageWrapper, config, function() { self.postMessage({'event': 'initialized'}); }); } else if (e.data.cmd === 'locate') { - locate(new Uint8Array(e.data.buffer), function(result) { + inputImageWrapper.data = new Uint8Array(e.data.buffer); + Locator.locate(function(result) { self.postMessage({'event': 'located', result: result, buffer : inputImageWrapper.data}, [inputImageWrapper.data.buffer]); }); } -}; -function init(cb) { - Locator.init({ - showCanvas: false, - showPatches: false, - showFoundPatches: false, - showSkeleton: false, - showLabels: false, - showPatchLabels: false, - showRemainingPatchLabels: false, - boxFromPatches: { - showTransformed: false, - showTransformedBox: false, - showBB: false - } - }, { - inputImageWrapper : inputImageWrapper - }, cb); -} -function locate(buffer, cb) { - inputImageWrapper.data = buffer; - Locator.locate(cb); -} \ No newline at end of file +}; \ No newline at end of file From b7b4711a7e3f64d65bf97f5103baad810810975b Mon Sep 17 00:00:00 2001 From: Christoph Oberhofer Date: Sun, 18 Jan 2015 13:55:18 +0100 Subject: [PATCH 3/9] Use worker without external file --- Gruntfile.js | 37 +- dist/locator.js | 5068 ---------------------------------------- dist/quagga.js | 56 +- dist/quagga.min.js | 3 - src/barcode_locator.js | 52 +- src/config.js | 1 + src/quagga.js | 3 +- src/worker_locator.js | 23 - 8 files changed, 107 insertions(+), 5136 deletions(-) delete mode 100644 dist/locator.js delete mode 100644 dist/quagga.min.js delete mode 100644 src/worker_locator.js diff --git a/Gruntfile.js b/Gruntfile.js index f5b0e1f..c3f88ad 100644 --- a/Gruntfile.js +++ b/Gruntfile.js @@ -21,7 +21,7 @@ module.exports = function(grunt) { all : ['Gruntfile.js', 'src/*.js'] }, requirejs : { - quagga : { + compile : { options : { almond : true, wrap : { @@ -51,41 +51,6 @@ module.exports = function(grunt) { } }, - "paths" : { - "typedefs" : "typedefs", - "glMatrix" : "vendor/glMatrix", - "glMatrixAddon" : "glMatrixAddon" - } - } - }, - locator : { - options : { - almond : true, - wrap : { - startFile : 'build/locator_start.frag', - endFile : 'build/locator_end.frag' - }, - "baseUrl" : "src", - "name" : "barcode_locator", - "out" : "dist/locator.js", - "include" : ['barcode_locator'], - "optimize" : "none", - "findNestedDependencies" : true, - "skipSemiColonInsertion" : true, - "shim" : { - "typedefs" : { - "deps" : [], - "exports" : "typedefs" - }, - "glMatrix" : { - "deps" : ["typedefs"], - "exports" : "glMatrix" - }, - "glMatrixAddon" : { - "deps" : ["glMatrix"], - "exports" : "glMatrixAddon" - } - }, "paths" : { "typedefs" : "typedefs", "glMatrix" : "vendor/glMatrix", diff --git a/dist/locator.js b/dist/locator.js deleted file mode 100644 index c823c80..0000000 --- a/dist/locator.js +++ /dev/null @@ -1,5068 +0,0 @@ -(function (root, factory) { - if (typeof define === 'function' && define.amd) { - //Allow using this built library as an AMD module - //in another project. That other project will only - //see this AMD call, not the internal modules in - //the closure below. - define([], factory); - } else { - //Browser globals case. Just assign the - //result to a property on the global. - root.Locator = factory(); - } -}(this, function () {/** - * @license almond 0.2.9 Copyright (c) 2011-2014, The Dojo Foundation All Rights Reserved. - * Available via the MIT or new BSD license. - * see: http://github.com/jrburke/almond for details - */ -//Going sloppy to avoid 'use strict' string cost, but strict practices should -//be followed. -/*jslint sloppy: true */ -/*global setTimeout: false */ - -var requirejs, require, define; -(function (undef) { - var main, req, makeMap, handlers, - defined = {}, - waiting = {}, - config = {}, - defining = {}, - hasOwn = Object.prototype.hasOwnProperty, - aps = [].slice, - jsSuffixRegExp = /\.js$/; - - function hasProp(obj, prop) { - return hasOwn.call(obj, prop); - } - - /** - * Given a relative module name, like ./something, normalize it to - * a real name that can be mapped to a path. - * @param {String} name the relative name - * @param {String} baseName a real name that the name arg is relative - * to. - * @returns {String} normalized name - */ - function normalize(name, baseName) { - var nameParts, nameSegment, mapValue, foundMap, lastIndex, - foundI, foundStarMap, starI, i, j, part, - baseParts = baseName && baseName.split("/"), - map = config.map, - starMap = (map && map['*']) || {}; - - //Adjust any relative paths. - if (name && name.charAt(0) === ".") { - //If have a base name, try to normalize against it, - //otherwise, assume it is a top-level require that will - //be relative to baseUrl in the end. - if (baseName) { - //Convert baseName to array, and lop off the last part, - //so that . matches that "directory" and not name of the baseName's - //module. For instance, baseName of "one/two/three", maps to - //"one/two/three.js", but we want the directory, "one/two" for - //this normalization. - baseParts = baseParts.slice(0, baseParts.length - 1); - name = name.split('/'); - lastIndex = name.length - 1; - - // Node .js allowance: - if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) { - name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, ''); - } - - name = baseParts.concat(name); - - //start trimDots - for (i = 0; i < name.length; i += 1) { - part = name[i]; - if (part === ".") { - name.splice(i, 1); - i -= 1; - } else if (part === "..") { - if (i === 1 && (name[2] === '..' || name[0] === '..')) { - //End of the line. Keep at least one non-dot - //path segment at the front so it can be mapped - //correctly to disk. Otherwise, there is likely - //no path mapping for a path starting with '..'. - //This can still fail, but catches the most reasonable - //uses of .. - break; - } else if (i > 0) { - name.splice(i - 1, 2); - i -= 2; - } - } - } - //end trimDots - - name = name.join("/"); - } else if (name.indexOf('./') === 0) { - // No baseName, so this is ID is resolved relative - // to baseUrl, pull off the leading dot. - name = name.substring(2); - } - } - - //Apply map config if available. - if ((baseParts || starMap) && map) { - nameParts = name.split('/'); - - for (i = nameParts.length; i > 0; i -= 1) { - nameSegment = nameParts.slice(0, i).join("/"); - - if (baseParts) { - //Find the longest baseName segment match in the config. - //So, do joins on the biggest to smallest lengths of baseParts. - for (j = baseParts.length; j > 0; j -= 1) { - mapValue = map[baseParts.slice(0, j).join('/')]; - - //baseName segment has config, find if it has one for - //this name. - if (mapValue) { - mapValue = mapValue[nameSegment]; - if (mapValue) { - //Match, update name to the new value. - foundMap = mapValue; - foundI = i; - break; - } - } - } - } - - if (foundMap) { - break; - } - - //Check for a star map match, but just hold on to it, - //if there is a shorter segment match later in a matching - //config, then favor over this star map. - if (!foundStarMap && starMap && starMap[nameSegment]) { - foundStarMap = starMap[nameSegment]; - starI = i; - } - } - - if (!foundMap && foundStarMap) { - foundMap = foundStarMap; - foundI = starI; - } - - if (foundMap) { - nameParts.splice(0, foundI, foundMap); - name = nameParts.join('/'); - } - } - - return name; - } - - function makeRequire(relName, forceSync) { - return function () { - //A version of a require function that passes a moduleName - //value for items that may need to - //look up paths relative to the moduleName - return req.apply(undef, aps.call(arguments, 0).concat([relName, forceSync])); - }; - } - - function makeNormalize(relName) { - return function (name) { - return normalize(name, relName); - }; - } - - function makeLoad(depName) { - return function (value) { - defined[depName] = value; - }; - } - - function callDep(name) { - if (hasProp(waiting, name)) { - var args = waiting[name]; - delete waiting[name]; - defining[name] = true; - main.apply(undef, args); - } - - if (!hasProp(defined, name) && !hasProp(defining, name)) { - throw new Error('No ' + name); - } - return defined[name]; - } - - //Turns a plugin!resource to [plugin, resource] - //with the plugin being undefined if the name - //did not have a plugin prefix. - function splitPrefix(name) { - var prefix, - index = name ? name.indexOf('!') : -1; - if (index > -1) { - prefix = name.substring(0, index); - name = name.substring(index + 1, name.length); - } - return [prefix, name]; - } - - /** - * Makes a name map, normalizing the name, and using a plugin - * for normalization if necessary. Grabs a ref to plugin - * too, as an optimization. - */ - makeMap = function (name, relName) { - var plugin, - parts = splitPrefix(name), - prefix = parts[0]; - - name = parts[1]; - - if (prefix) { - prefix = normalize(prefix, relName); - plugin = callDep(prefix); - } - - //Normalize according - if (prefix) { - if (plugin && plugin.normalize) { - name = plugin.normalize(name, makeNormalize(relName)); - } else { - name = normalize(name, relName); - } - } else { - name = normalize(name, relName); - parts = splitPrefix(name); - prefix = parts[0]; - name = parts[1]; - if (prefix) { - plugin = callDep(prefix); - } - } - - //Using ridiculous property names for space reasons - return { - f: prefix ? prefix + '!' + name : name, //fullName - n: name, - pr: prefix, - p: plugin - }; - }; - - function makeConfig(name) { - return function () { - return (config && config.config && config.config[name]) || {}; - }; - } - - handlers = { - require: function (name) { - return makeRequire(name); - }, - exports: function (name) { - var e = defined[name]; - if (typeof e !== 'undefined') { - return e; - } else { - return (defined[name] = {}); - } - }, - module: function (name) { - return { - id: name, - uri: '', - exports: defined[name], - config: makeConfig(name) - }; - } - }; - - main = function (name, deps, callback, relName) { - var cjsModule, depName, ret, map, i, - args = [], - callbackType = typeof callback, - usingExports; - - //Use name if no relName - relName = relName || name; - - //Call the callback to define the module, if necessary. - if (callbackType === 'undefined' || callbackType === 'function') { - //Pull out the defined dependencies and pass the ordered - //values to the callback. - //Default to [require, exports, module] if no deps - deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps; - for (i = 0; i < deps.length; i += 1) { - map = makeMap(deps[i], relName); - depName = map.f; - - //Fast path CommonJS standard dependencies. - if (depName === "require") { - args[i] = handlers.require(name); - } else if (depName === "exports") { - //CommonJS module spec 1.1 - args[i] = handlers.exports(name); - usingExports = true; - } else if (depName === "module") { - //CommonJS module spec 1.1 - cjsModule = args[i] = handlers.module(name); - } else if (hasProp(defined, depName) || - hasProp(waiting, depName) || - hasProp(defining, depName)) { - args[i] = callDep(depName); - } else if (map.p) { - map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {}); - args[i] = defined[depName]; - } else { - throw new Error(name + ' missing ' + depName); - } - } - - ret = callback ? callback.apply(defined[name], args) : undefined; - - if (name) { - //If setting exports via "module" is in play, - //favor that over return value and exports. After that, - //favor a non-undefined return value over exports use. - if (cjsModule && cjsModule.exports !== undef && - cjsModule.exports !== defined[name]) { - defined[name] = cjsModule.exports; - } else if (ret !== undef || !usingExports) { - //Use the return value from the function. - defined[name] = ret; - } - } - } else if (name) { - //May just be an object definition for the module. Only - //worry about defining if have a module name. - defined[name] = callback; - } - }; - - requirejs = require = req = function (deps, callback, relName, forceSync, alt) { - if (typeof deps === "string") { - if (handlers[deps]) { - //callback in this case is really relName - return handlers[deps](callback); - } - //Just return the module wanted. In this scenario, the - //deps arg is the module name, and second arg (if passed) - //is just the relName. - //Normalize module name, if it contains . or .. - return callDep(makeMap(deps, callback).f); - } else if (!deps.splice) { - //deps is a config object, not an array. - config = deps; - if (config.deps) { - req(config.deps, config.callback); - } - if (!callback) { - return; - } - - if (callback.splice) { - //callback is an array, which means it is a dependency list. - //Adjust args if there are dependencies - deps = callback; - callback = relName; - relName = null; - } else { - deps = undef; - } - } - - //Support require(['a']) - callback = callback || function () {}; - - //If relName is a function, it is an errback handler, - //so remove it. - if (typeof relName === 'function') { - relName = forceSync; - forceSync = alt; - } - - //Simulate async callback; - if (forceSync) { - main(undef, deps, callback, relName); - } else { - //Using a non-zero value because of concern for what old browsers - //do, and latest browsers "upgrade" to 4 if lower value is used: - //http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#dom-windowtimers-settimeout: - //If want a value immediately, use require('id') instead -- something - //that works in almond on the global level, but not guaranteed and - //unlikely to work in other AMD implementations. - setTimeout(function () { - main(undef, deps, callback, relName); - }, 4); - } - - return req; - }; - - /** - * Just drops the config on the floor, but returns req in case - * the config return value is used. - */ - req.config = function (cfg) { - return req(cfg); - }; - - /** - * Expose module registry for debugging and tooling - */ - requirejs._defined = defined; - - define = function (name, deps, callback) { - - //This module may not have dependencies - if (!deps.splice) { - //deps is not an array, so probably means - //an object literal or factory function for - //the value. Adjust args. - callback = deps; - deps = []; - } - - if (!hasProp(defined, name) && !hasProp(waiting, name)) { - waiting[name] = [name, deps, callback]; - } - }; - - define.amd = { - jQuery: true - }; -}()); - -define("almond", function(){}); - -/* - * typedefs.js - * Normalizes browser-specific prefixes - */ - -glMatrixArrayType = Float32Array; -if (typeof window !== 'undefined') { - window.requestAnimFrame = (function () { - return window.requestAnimationFrame || - window.webkitRequestAnimationFrame || - window.mozRequestAnimationFrame || - window.oRequestAnimationFrame || - window.msRequestAnimationFrame || - function (/* function FrameRequestCallback */ callback, /* DOMElement Element */ element) { - window.setTimeout(callback, 1000 / 60); - }; - })(); - - navigator.getUserMedia = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia || navigator.msGetUserMedia; - window.URL = window.URL || window.webkitURL || window.mozURL || window.msURL; -} - -define("typedefs", (function (global) { - return function () { - var ret, fn; - return ret || global.typedefs; - }; -}(this))); - -/* jshint undef: true, unused: true, browser:true, devel: true */ -/* global define */ - -define('subImage',["typedefs"], function() { - - - /** - * Construct representing a part of another {ImageWrapper}. Shares data - * between the parent and the child. - * @param from {ImageRef} The position where to start the {SubImage} from. (top-left corner) - * @param size {ImageRef} The size of the resulting image - * @param I {ImageWrapper} The {ImageWrapper} to share from - * @returns {SubImage} A shared part of the original image - */ - function SubImage(from, size, I) { - if (!I) { - I = { - data : null, - size : size - }; - } - this.data = I.data; - this.originalSize = I.size; - this.I = I; - - this.from = from; - this.size = size; - } - - /** - * Displays the {SubImage} in a given canvas - * @param canvas {Canvas} The canvas element to write to - * @param scale {Number} Scale which is applied to each pixel-value - */ - SubImage.prototype.show = function(canvas, scale) { - var ctx, - frame, - data, - current, - y, - x, - pixel; - - if (!scale) { - scale = 1.0; - } - ctx = canvas.getContext('2d'); - canvas.width = this.size.x; - canvas.height = this.size.y; - frame = ctx.getImageData(0, 0, canvas.width, canvas.height); - data = frame.data; - current = 0; - for (y = 0; y < this.size.y; y++) { - for (x = 0; x < this.size.x; x++) { - pixel = y * this.size.x + x; - current = this.get(x, y) * scale; - data[pixel * 4 + 0] = current; - data[pixel * 4 + 1] = current; - data[pixel * 4 + 2] = current; - data[pixel * 4 + 3] = 255; - } - } - frame.data = data; - ctx.putImageData(frame, 0, 0); - }; - - /** - * Retrieves a given pixel position from the {SubImage} - * @param x {Number} The x-position - * @param y {Number} The y-position - * @returns {Number} The grayscale value at the pixel-position - */ - SubImage.prototype.get = function(x, y) { - return this.data[(this.from.y + y) * this.originalSize.x + this.from.x + x]; - }; - - /** - * Updates the underlying data from a given {ImageWrapper} - * @param image {ImageWrapper} The updated image - */ - SubImage.prototype.updateData = function(image) { - this.originalSize = image.size; - this.data = image.data; - }; - - /** - * Updates the position of the shared area - * @param from {x,y} The new location - * @returns {SubImage} returns {this} for possible chaining - */ - SubImage.prototype.updateFrom = function(from) { - this.from = from; - return this; - }; - - return (SubImage); -}); -/* jshint undef: true, unused: true, browser:true, devel: true */ -/* global define, vec2 */ - -define('cluster',[],function() { - - - /** - * Creates a cluster for grouping similar orientations of datapoints - */ - var Cluster = { - create : function(point, threshold) { - var points = [], center = { - rad : 0, - vec : vec2.create([0, 0]) - }, pointMap = {}; - - function init() { - add(point); - updateCenter(); - } - - function add(point) { - pointMap[point.id] = point; - points.push(point); - } - - function updateCenter() { - var i, sum = 0; - for ( i = 0; i < points.length; i++) { - sum += points[i].rad; - } - center.rad = sum / points.length; - center.vec = vec2.create([Math.cos(center.rad), Math.sin(center.rad)]); - } - - init(); - - return { - add : function(point) { - if (!pointMap[point.id]) { - add(point); - updateCenter(); - } - }, - fits : function(point) { - // check cosine similarity to center-angle - var similarity = Math.abs(vec2.dot(point.point.vec, center.vec)); - if (similarity > threshold) { - return true; - } - return false; - }, - getPoints : function() { - return points; - }, - getCenter : function() { - return center; - } - }; - }, - createPoint : function(point, id, property) { - return { - rad : point[property], - point : point, - id : id - }; - } - }; - - return (Cluster); -}); - -/* - * glMatrix.js - High performance matrix and vector operations for WebGL - * version 0.9.6 - */ - -/* - * Copyright (c) 2011 Brandon Jones - * - * This software is provided 'as-is', without any express or implied - * warranty. In no event will the authors be held liable for any damages - * arising from the use of this software. - * - * Permission is granted to anyone to use this software for any purpose, - * including commercial applications, and to alter it and redistribute it - * freely, subject to the following restrictions: - * - * 1. The origin of this software must not be misrepresented; you must not - * claim that you wrote the original software. If you use this software - * in a product, an acknowledgment in the product documentation would be - * appreciated but is not required. - * - * 2. Altered source versions must be plainly marked as such, and must not - * be misrepresented as being the original software. - * - * 3. This notice may not be removed or altered from any source - * distribution. - */ - - - -/* - * vec3 - 3 Dimensional Vector - */ -var vec3 = {}; - -/* - * vec3.create - * Creates a new instance of a vec3 using the default array type - * Any javascript array containing at least 3 numeric elements can serve as a vec3 - * - * Params: - * vec - Optional, vec3 containing values to initialize with - * - * Returns: - * New vec3 - */ -vec3.create = function(vec) { - var dest; - if(vec) { - dest = new glMatrixArrayType(3); - dest[0] = vec[0]; - dest[1] = vec[1]; - dest[2] = vec[2]; - } else { - if(glMatrixArrayType === Array) - dest = new glMatrixArrayType([0,0,0]); - else - dest = new glMatrixArrayType(3); - } - - return dest; -}; - -/* - * vec3.set - * Copies the values of one vec3 to another - * - * Params: - * vec - vec3 containing values to copy - * dest - vec3 receiving copied values - * - * Returns: - * dest - */ -vec3.set = function(vec, dest) { - dest[0] = vec[0]; - dest[1] = vec[1]; - dest[2] = vec[2]; - - return dest; -}; - -/* - * vec3.add - * Performs a vector addition - * - * Params: - * vec - vec3, first operand - * vec2 - vec3, second operand - * dest - Optional, vec3 receiving operation result. If not specified result is written to vec - * - * Returns: - * dest if specified, vec otherwise - */ -vec3.add = function(vec, vec2, dest) { - if(!dest || vec == dest) { - vec[0] += vec2[0]; - vec[1] += vec2[1]; - vec[2] += vec2[2]; - return vec; - } - - dest[0] = vec[0] + vec2[0]; - dest[1] = vec[1] + vec2[1]; - dest[2] = vec[2] + vec2[2]; - return dest; -}; - -/* - * vec3.subtract - * Performs a vector subtraction - * - * Params: - * vec - vec3, first operand - * vec2 - vec3, second operand - * dest - Optional, vec3 receiving operation result. If not specified result is written to vec - * - * Returns: - * dest if specified, vec otherwise - */ -vec3.subtract = function(vec, vec2, dest) { - if(!dest || vec == dest) { - vec[0] -= vec2[0]; - vec[1] -= vec2[1]; - vec[2] -= vec2[2]; - return vec; - } - - dest[0] = vec[0] - vec2[0]; - dest[1] = vec[1] - vec2[1]; - dest[2] = vec[2] - vec2[2]; - return dest; -}; - -/* - * vec3.negate - * Negates the components of a vec3 - * - * Params: - * vec - vec3 to negate - * dest - Optional, vec3 receiving operation result. If not specified result is written to vec - * - * Returns: - * dest if specified, vec otherwise - */ -vec3.negate = function(vec, dest) { - if(!dest) { dest = vec; } - - dest[0] = -vec[0]; - dest[1] = -vec[1]; - dest[2] = -vec[2]; - return dest; -}; - -/* - * vec3.scale - * Multiplies the components of a vec3 by a scalar value - * - * Params: - * vec - vec3 to scale - * val - Numeric value to scale by - * dest - Optional, vec3 receiving operation result. If not specified result is written to vec - * - * Returns: - * dest if specified, vec otherwise - */ -vec3.scale = function(vec, val, dest) { - if(!dest || vec == dest) { - vec[0] *= val; - vec[1] *= val; - vec[2] *= val; - return vec; - } - - dest[0] = vec[0]*val; - dest[1] = vec[1]*val; - dest[2] = vec[2]*val; - return dest; -}; - -/* - * vec3.normalize - * Generates a unit vector of the same direction as the provided vec3 - * If vector length is 0, returns [0, 0, 0] - * - * Params: - * vec - vec3 to normalize - * dest - Optional, vec3 receiving operation result. If not specified result is written to vec - * - * Returns: - * dest if specified, vec otherwise - */ -vec3.normalize = function(vec, dest) { - if(!dest) { dest = vec; } - - var x = vec[0], y = vec[1], z = vec[2]; - var len = Math.sqrt(x*x + y*y + z*z); - - if (!len) { - dest[0] = 0; - dest[1] = 0; - dest[2] = 0; - return dest; - } else if (len == 1) { - dest[0] = x; - dest[1] = y; - dest[2] = z; - return dest; - } - - len = 1 / len; - dest[0] = x*len; - dest[1] = y*len; - dest[2] = z*len; - return dest; -}; - -/* - * vec3.cross - * Generates the cross product of two vec3s - * - * Params: - * vec - vec3, first operand - * vec2 - vec3, second operand - * dest - Optional, vec3 receiving operation result. If not specified result is written to vec - * - * Returns: - * dest if specified, vec otherwise - */ -vec3.cross = function(vec, vec2, dest){ - if(!dest) { dest = vec; } - - var x = vec[0], y = vec[1], z = vec[2]; - var x2 = vec2[0], y2 = vec2[1], z2 = vec2[2]; - - dest[0] = y*z2 - z*y2; - dest[1] = z*x2 - x*z2; - dest[2] = x*y2 - y*x2; - return dest; -}; - -/* - * vec3.length - * Caclulates the length of a vec3 - * - * Params: - * vec - vec3 to calculate length of - * - * Returns: - * Length of vec - */ -vec3.length = function(vec){ - var x = vec[0], y = vec[1], z = vec[2]; - return Math.sqrt(x*x + y*y + z*z); -}; - -/* - * vec3.dot - * Caclulates the dot product of two vec3s - * - * Params: - * vec - vec3, first operand - * vec2 - vec3, second operand - * - * Returns: - * Dot product of vec and vec2 - */ -vec3.dot = function(vec, vec2){ - return vec[0]*vec2[0] + vec[1]*vec2[1] + vec[2]*vec2[2]; -}; - -/* - * vec3.direction - * Generates a unit vector pointing from one vector to another - * - * Params: - * vec - origin vec3 - * vec2 - vec3 to point to - * dest - Optional, vec3 receiving operation result. If not specified result is written to vec - * - * Returns: - * dest if specified, vec otherwise - */ -vec3.direction = function(vec, vec2, dest) { - if(!dest) { dest = vec; } - - var x = vec[0] - vec2[0]; - var y = vec[1] - vec2[1]; - var z = vec[2] - vec2[2]; - - var len = Math.sqrt(x*x + y*y + z*z); - if (!len) { - dest[0] = 0; - dest[1] = 0; - dest[2] = 0; - return dest; - } - - len = 1 / len; - dest[0] = x * len; - dest[1] = y * len; - dest[2] = z * len; - return dest; -}; - -/* - * vec3.lerp - * Performs a linear interpolation between two vec3 - * - * Params: - * vec - vec3, first vector - * vec2 - vec3, second vector - * lerp - interpolation amount between the two inputs - * dest - Optional, vec3 receiving operation result. If not specified result is written to vec - * - * Returns: - * dest if specified, vec otherwise - */ -vec3.lerp = function(vec, vec2, lerp, dest){ - if(!dest) { dest = vec; } - - dest[0] = vec[0] + lerp * (vec2[0] - vec[0]); - dest[1] = vec[1] + lerp * (vec2[1] - vec[1]); - dest[2] = vec[2] + lerp * (vec2[2] - vec[2]); - - return dest; -}; - -/* - * vec3.str - * Returns a string representation of a vector - * - * Params: - * vec - vec3 to represent as a string - * - * Returns: - * string representation of vec - */ -vec3.str = function(vec) { - return '[' + vec[0] + ', ' + vec[1] + ', ' + vec[2] + ']'; -}; - -/* - * mat3 - 3x3 Matrix - */ -var mat3 = {}; - -/* - * mat3.create - * Creates a new instance of a mat3 using the default array type - * Any javascript array containing at least 9 numeric elements can serve as a mat3 - * - * Params: - * mat - Optional, mat3 containing values to initialize with - * - * Returns: - * New mat3 - */ -mat3.create = function(mat) { - var dest; - - if(mat) { - dest = new glMatrixArrayType(9); - dest[0] = mat[0]; - dest[1] = mat[1]; - dest[2] = mat[2]; - dest[3] = mat[3]; - dest[4] = mat[4]; - dest[5] = mat[5]; - dest[6] = mat[6]; - dest[7] = mat[7]; - dest[8] = mat[8]; - } else { - if(glMatrixArrayType === Array) - dest = new glMatrixArrayType([0,0,0,0,0,0,0,0,0]); - else - dest = new glMatrixArrayType(9); - } - - return dest; -}; - -/* - * mat3.set - * Copies the values of one mat3 to another - * - * Params: - * mat - mat3 containing values to copy - * dest - mat3 receiving copied values - * - * Returns: - * dest - */ -mat3.set = function(mat, dest) { - dest[0] = mat[0]; - dest[1] = mat[1]; - dest[2] = mat[2]; - dest[3] = mat[3]; - dest[4] = mat[4]; - dest[5] = mat[5]; - dest[6] = mat[6]; - dest[7] = mat[7]; - dest[8] = mat[8]; - return dest; -}; - -/* - * mat3.identity - * Sets a mat3 to an identity matrix - * - * Params: - * dest - mat3 to set - * - * Returns: - * dest - */ -mat3.identity = function(dest) { - dest[0] = 1; - dest[1] = 0; - dest[2] = 0; - dest[3] = 0; - dest[4] = 1; - dest[5] = 0; - dest[6] = 0; - dest[7] = 0; - dest[8] = 1; - return dest; -}; - -/* - * mat4.transpose - * Transposes a mat3 (flips the values over the diagonal) - * - * Params: - * mat - mat3 to transpose - * dest - Optional, mat3 receiving transposed values. If not specified result is written to mat - * - * Returns: - * dest is specified, mat otherwise - */ -mat3.transpose = function(mat, dest) { - // If we are transposing ourselves we can skip a few steps but have to cache some values - if(!dest || mat == dest) { - var a01 = mat[1], a02 = mat[2]; - var a12 = mat[5]; - - mat[1] = mat[3]; - mat[2] = mat[6]; - mat[3] = a01; - mat[5] = mat[7]; - mat[6] = a02; - mat[7] = a12; - return mat; - } - - dest[0] = mat[0]; - dest[1] = mat[3]; - dest[2] = mat[6]; - dest[3] = mat[1]; - dest[4] = mat[4]; - dest[5] = mat[7]; - dest[6] = mat[2]; - dest[7] = mat[5]; - dest[8] = mat[8]; - return dest; -}; - -/* - * mat3.toMat4 - * Copies the elements of a mat3 into the upper 3x3 elements of a mat4 - * - * Params: - * mat - mat3 containing values to copy - * dest - Optional, mat4 receiving copied values - * - * Returns: - * dest if specified, a new mat4 otherwise - */ -mat3.toMat4 = function(mat, dest) { - if(!dest) { dest = mat4.create(); } - - dest[0] = mat[0]; - dest[1] = mat[1]; - dest[2] = mat[2]; - dest[3] = 0; - - dest[4] = mat[3]; - dest[5] = mat[4]; - dest[6] = mat[5]; - dest[7] = 0; - - dest[8] = mat[6]; - dest[9] = mat[7]; - dest[10] = mat[8]; - dest[11] = 0; - - dest[12] = 0; - dest[13] = 0; - dest[14] = 0; - dest[15] = 1; - - return dest; -}; - -/* - * mat3.str - * Returns a string representation of a mat3 - * - * Params: - * mat - mat3 to represent as a string - * - * Returns: - * string representation of mat - */ -mat3.str = function(mat) { - return '[' + mat[0] + ', ' + mat[1] + ', ' + mat[2] + - ', ' + mat[3] + ', '+ mat[4] + ', ' + mat[5] + - ', ' + mat[6] + ', ' + mat[7] + ', '+ mat[8] + ']'; -}; - -/* - * mat4 - 4x4 Matrix - */ -var mat4 = {}; - -/* - * mat4.create - * Creates a new instance of a mat4 using the default array type - * Any javascript array containing at least 16 numeric elements can serve as a mat4 - * - * Params: - * mat - Optional, mat4 containing values to initialize with - * - * Returns: - * New mat4 - */ -mat4.create = function(mat) { - var dest; - - if(mat) { - dest = new glMatrixArrayType(16); - dest[0] = mat[0]; - dest[1] = mat[1]; - dest[2] = mat[2]; - dest[3] = mat[3]; - dest[4] = mat[4]; - dest[5] = mat[5]; - dest[6] = mat[6]; - dest[7] = mat[7]; - dest[8] = mat[8]; - dest[9] = mat[9]; - dest[10] = mat[10]; - dest[11] = mat[11]; - dest[12] = mat[12]; - dest[13] = mat[13]; - dest[14] = mat[14]; - dest[15] = mat[15]; - } else { - if(glMatrixArrayType === Array) - dest = new glMatrixArrayType([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]); - else - dest = new glMatrixArrayType(16); - } - - return dest; -}; - -/* - * mat4.set - * Copies the values of one mat4 to another - * - * Params: - * mat - mat4 containing values to copy - * dest - mat4 receiving copied values - * - * Returns: - * dest - */ -mat4.set = function(mat, dest) { - dest[0] = mat[0]; - dest[1] = mat[1]; - dest[2] = mat[2]; - dest[3] = mat[3]; - dest[4] = mat[4]; - dest[5] = mat[5]; - dest[6] = mat[6]; - dest[7] = mat[7]; - dest[8] = mat[8]; - dest[9] = mat[9]; - dest[10] = mat[10]; - dest[11] = mat[11]; - dest[12] = mat[12]; - dest[13] = mat[13]; - dest[14] = mat[14]; - dest[15] = mat[15]; - return dest; -}; - -/* - * mat4.identity - * Sets a mat4 to an identity matrix - * - * Params: - * dest - mat4 to set - * - * Returns: - * dest - */ -mat4.identity = function(dest) { - dest[0] = 1; - dest[1] = 0; - dest[2] = 0; - dest[3] = 0; - dest[4] = 0; - dest[5] = 1; - dest[6] = 0; - dest[7] = 0; - dest[8] = 0; - dest[9] = 0; - dest[10] = 1; - dest[11] = 0; - dest[12] = 0; - dest[13] = 0; - dest[14] = 0; - dest[15] = 1; - return dest; -}; - -/* - * mat4.transpose - * Transposes a mat4 (flips the values over the diagonal) - * - * Params: - * mat - mat4 to transpose - * dest - Optional, mat4 receiving transposed values. If not specified result is written to mat - * - * Returns: - * dest is specified, mat otherwise - */ -mat4.transpose = function(mat, dest) { - // If we are transposing ourselves we can skip a few steps but have to cache some values - if(!dest || mat == dest) { - var a01 = mat[1], a02 = mat[2], a03 = mat[3]; - var a12 = mat[6], a13 = mat[7]; - var a23 = mat[11]; - - mat[1] = mat[4]; - mat[2] = mat[8]; - mat[3] = mat[12]; - mat[4] = a01; - mat[6] = mat[9]; - mat[7] = mat[13]; - mat[8] = a02; - mat[9] = a12; - mat[11] = mat[14]; - mat[12] = a03; - mat[13] = a13; - mat[14] = a23; - return mat; - } - - dest[0] = mat[0]; - dest[1] = mat[4]; - dest[2] = mat[8]; - dest[3] = mat[12]; - dest[4] = mat[1]; - dest[5] = mat[5]; - dest[6] = mat[9]; - dest[7] = mat[13]; - dest[8] = mat[2]; - dest[9] = mat[6]; - dest[10] = mat[10]; - dest[11] = mat[14]; - dest[12] = mat[3]; - dest[13] = mat[7]; - dest[14] = mat[11]; - dest[15] = mat[15]; - return dest; -}; - -/* - * mat4.determinant - * Calculates the determinant of a mat4 - * - * Params: - * mat - mat4 to calculate determinant of - * - * Returns: - * determinant of mat - */ -mat4.determinant = function(mat) { - // Cache the matrix values (makes for huge speed increases!) - var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3]; - var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7]; - var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11]; - var a30 = mat[12], a31 = mat[13], a32 = mat[14], a33 = mat[15]; - - return a30*a21*a12*a03 - a20*a31*a12*a03 - a30*a11*a22*a03 + a10*a31*a22*a03 + - a20*a11*a32*a03 - a10*a21*a32*a03 - a30*a21*a02*a13 + a20*a31*a02*a13 + - a30*a01*a22*a13 - a00*a31*a22*a13 - a20*a01*a32*a13 + a00*a21*a32*a13 + - a30*a11*a02*a23 - a10*a31*a02*a23 - a30*a01*a12*a23 + a00*a31*a12*a23 + - a10*a01*a32*a23 - a00*a11*a32*a23 - a20*a11*a02*a33 + a10*a21*a02*a33 + - a20*a01*a12*a33 - a00*a21*a12*a33 - a10*a01*a22*a33 + a00*a11*a22*a33; -}; - -/* - * mat4.inverse - * Calculates the inverse matrix of a mat4 - * - * Params: - * mat - mat4 to calculate inverse of - * dest - Optional, mat4 receiving inverse matrix. If not specified result is written to mat - * - * Returns: - * dest is specified, mat otherwise - */ -mat4.inverse = function(mat, dest) { - if(!dest) { dest = mat; } - - // Cache the matrix values (makes for huge speed increases!) - var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3]; - var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7]; - var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11]; - var a30 = mat[12], a31 = mat[13], a32 = mat[14], a33 = mat[15]; - - var b00 = a00*a11 - a01*a10; - var b01 = a00*a12 - a02*a10; - var b02 = a00*a13 - a03*a10; - var b03 = a01*a12 - a02*a11; - var b04 = a01*a13 - a03*a11; - var b05 = a02*a13 - a03*a12; - var b06 = a20*a31 - a21*a30; - var b07 = a20*a32 - a22*a30; - var b08 = a20*a33 - a23*a30; - var b09 = a21*a32 - a22*a31; - var b10 = a21*a33 - a23*a31; - var b11 = a22*a33 - a23*a32; - - // Calculate the determinant (inlined to avoid double-caching) - var invDet = 1/(b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06); - - dest[0] = (a11*b11 - a12*b10 + a13*b09)*invDet; - dest[1] = (-a01*b11 + a02*b10 - a03*b09)*invDet; - dest[2] = (a31*b05 - a32*b04 + a33*b03)*invDet; - dest[3] = (-a21*b05 + a22*b04 - a23*b03)*invDet; - dest[4] = (-a10*b11 + a12*b08 - a13*b07)*invDet; - dest[5] = (a00*b11 - a02*b08 + a03*b07)*invDet; - dest[6] = (-a30*b05 + a32*b02 - a33*b01)*invDet; - dest[7] = (a20*b05 - a22*b02 + a23*b01)*invDet; - dest[8] = (a10*b10 - a11*b08 + a13*b06)*invDet; - dest[9] = (-a00*b10 + a01*b08 - a03*b06)*invDet; - dest[10] = (a30*b04 - a31*b02 + a33*b00)*invDet; - dest[11] = (-a20*b04 + a21*b02 - a23*b00)*invDet; - dest[12] = (-a10*b09 + a11*b07 - a12*b06)*invDet; - dest[13] = (a00*b09 - a01*b07 + a02*b06)*invDet; - dest[14] = (-a30*b03 + a31*b01 - a32*b00)*invDet; - dest[15] = (a20*b03 - a21*b01 + a22*b00)*invDet; - - return dest; -}; - -/* - * mat4.toRotationMat - * Copies the upper 3x3 elements of a mat4 into another mat4 - * - * Params: - * mat - mat4 containing values to copy - * dest - Optional, mat4 receiving copied values - * - * Returns: - * dest is specified, a new mat4 otherwise - */ -mat4.toRotationMat = function(mat, dest) { - if(!dest) { dest = mat4.create(); } - - dest[0] = mat[0]; - dest[1] = mat[1]; - dest[2] = mat[2]; - dest[3] = mat[3]; - dest[4] = mat[4]; - dest[5] = mat[5]; - dest[6] = mat[6]; - dest[7] = mat[7]; - dest[8] = mat[8]; - dest[9] = mat[9]; - dest[10] = mat[10]; - dest[11] = mat[11]; - dest[12] = 0; - dest[13] = 0; - dest[14] = 0; - dest[15] = 1; - - return dest; -}; - -/* - * mat4.toMat3 - * Copies the upper 3x3 elements of a mat4 into a mat3 - * - * Params: - * mat - mat4 containing values to copy - * dest - Optional, mat3 receiving copied values - * - * Returns: - * dest is specified, a new mat3 otherwise - */ -mat4.toMat3 = function(mat, dest) { - if(!dest) { dest = mat3.create(); } - - dest[0] = mat[0]; - dest[1] = mat[1]; - dest[2] = mat[2]; - dest[3] = mat[4]; - dest[4] = mat[5]; - dest[5] = mat[6]; - dest[6] = mat[8]; - dest[7] = mat[9]; - dest[8] = mat[10]; - - return dest; -}; - -/* - * mat4.toInverseMat3 - * Calculates the inverse of the upper 3x3 elements of a mat4 and copies the result into a mat3 - * The resulting matrix is useful for calculating transformed normals - * - * Params: - * mat - mat4 containing values to invert and copy - * dest - Optional, mat3 receiving values - * - * Returns: - * dest is specified, a new mat3 otherwise - */ -mat4.toInverseMat3 = function(mat, dest) { - // Cache the matrix values (makes for huge speed increases!) - var a00 = mat[0], a01 = mat[1], a02 = mat[2]; - var a10 = mat[4], a11 = mat[5], a12 = mat[6]; - var a20 = mat[8], a21 = mat[9], a22 = mat[10]; - - var b01 = a22*a11-a12*a21; - var b11 = -a22*a10+a12*a20; - var b21 = a21*a10-a11*a20; - - var d = a00*b01 + a01*b11 + a02*b21; - if (!d) { return null; } - var id = 1/d; - - if(!dest) { dest = mat3.create(); } - - dest[0] = b01*id; - dest[1] = (-a22*a01 + a02*a21)*id; - dest[2] = (a12*a01 - a02*a11)*id; - dest[3] = b11*id; - dest[4] = (a22*a00 - a02*a20)*id; - dest[5] = (-a12*a00 + a02*a10)*id; - dest[6] = b21*id; - dest[7] = (-a21*a00 + a01*a20)*id; - dest[8] = (a11*a00 - a01*a10)*id; - - return dest; -}; - -/* - * mat4.multiply - * Performs a matrix multiplication - * - * Params: - * mat - mat4, first operand - * mat2 - mat4, second operand - * dest - Optional, mat4 receiving operation result. If not specified result is written to mat - * - * Returns: - * dest if specified, mat otherwise - */ -mat4.multiply = function(mat, mat2, dest) { - if(!dest) { dest = mat; } - - // Cache the matrix values (makes for huge speed increases!) - var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3]; - var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7]; - var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11]; - var a30 = mat[12], a31 = mat[13], a32 = mat[14], a33 = mat[15]; - - var b00 = mat2[0], b01 = mat2[1], b02 = mat2[2], b03 = mat2[3]; - var b10 = mat2[4], b11 = mat2[5], b12 = mat2[6], b13 = mat2[7]; - var b20 = mat2[8], b21 = mat2[9], b22 = mat2[10], b23 = mat2[11]; - var b30 = mat2[12], b31 = mat2[13], b32 = mat2[14], b33 = mat2[15]; - - dest[0] = b00*a00 + b01*a10 + b02*a20 + b03*a30; - dest[1] = b00*a01 + b01*a11 + b02*a21 + b03*a31; - dest[2] = b00*a02 + b01*a12 + b02*a22 + b03*a32; - dest[3] = b00*a03 + b01*a13 + b02*a23 + b03*a33; - dest[4] = b10*a00 + b11*a10 + b12*a20 + b13*a30; - dest[5] = b10*a01 + b11*a11 + b12*a21 + b13*a31; - dest[6] = b10*a02 + b11*a12 + b12*a22 + b13*a32; - dest[7] = b10*a03 + b11*a13 + b12*a23 + b13*a33; - dest[8] = b20*a00 + b21*a10 + b22*a20 + b23*a30; - dest[9] = b20*a01 + b21*a11 + b22*a21 + b23*a31; - dest[10] = b20*a02 + b21*a12 + b22*a22 + b23*a32; - dest[11] = b20*a03 + b21*a13 + b22*a23 + b23*a33; - dest[12] = b30*a00 + b31*a10 + b32*a20 + b33*a30; - dest[13] = b30*a01 + b31*a11 + b32*a21 + b33*a31; - dest[14] = b30*a02 + b31*a12 + b32*a22 + b33*a32; - dest[15] = b30*a03 + b31*a13 + b32*a23 + b33*a33; - - return dest; -}; - -/* - * mat4.multiplyVec3 - * Transforms a vec3 with the given matrix - * 4th vector component is implicitly '1' - * - * Params: - * mat - mat4 to transform the vector with - * vec - vec3 to transform - * dest - Optional, vec3 receiving operation result. If not specified result is written to vec - * - * Returns: - * dest if specified, vec otherwise - */ -mat4.multiplyVec3 = function(mat, vec, dest) { - if(!dest) { dest = vec; } - - var x = vec[0], y = vec[1], z = vec[2]; - - dest[0] = mat[0]*x + mat[4]*y + mat[8]*z + mat[12]; - dest[1] = mat[1]*x + mat[5]*y + mat[9]*z + mat[13]; - dest[2] = mat[2]*x + mat[6]*y + mat[10]*z + mat[14]; - - return dest; -}; - -/* - * mat4.multiplyVec4 - * Transforms a vec4 with the given matrix - * - * Params: - * mat - mat4 to transform the vector with - * vec - vec4 to transform - * dest - Optional, vec4 receiving operation result. If not specified result is written to vec - * - * Returns: - * dest if specified, vec otherwise - */ -mat4.multiplyVec4 = function(mat, vec, dest) { - if(!dest) { dest = vec; } - - var x = vec[0], y = vec[1], z = vec[2], w = vec[3]; - - dest[0] = mat[0]*x + mat[4]*y + mat[8]*z + mat[12]*w; - dest[1] = mat[1]*x + mat[5]*y + mat[9]*z + mat[13]*w; - dest[2] = mat[2]*x + mat[6]*y + mat[10]*z + mat[14]*w; - dest[3] = mat[3]*x + mat[7]*y + mat[11]*z + mat[15]*w; - - return dest; -}; - -/* - * mat4.translate - * Translates a matrix by the given vector - * - * Params: - * mat - mat4 to translate - * vec - vec3 specifying the translation - * dest - Optional, mat4 receiving operation result. If not specified result is written to mat - * - * Returns: - * dest if specified, mat otherwise - */ -mat4.translate = function(mat, vec, dest) { - var x = vec[0], y = vec[1], z = vec[2]; - - if(!dest || mat == dest) { - mat[12] = mat[0]*x + mat[4]*y + mat[8]*z + mat[12]; - mat[13] = mat[1]*x + mat[5]*y + mat[9]*z + mat[13]; - mat[14] = mat[2]*x + mat[6]*y + mat[10]*z + mat[14]; - mat[15] = mat[3]*x + mat[7]*y + mat[11]*z + mat[15]; - return mat; - } - - var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3]; - var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7]; - var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11]; - - dest[0] = a00; - dest[1] = a01; - dest[2] = a02; - dest[3] = a03; - dest[4] = a10; - dest[5] = a11; - dest[6] = a12; - dest[7] = a13; - dest[8] = a20; - dest[9] = a21; - dest[10] = a22; - dest[11] = a23; - - dest[12] = a00*x + a10*y + a20*z + mat[12]; - dest[13] = a01*x + a11*y + a21*z + mat[13]; - dest[14] = a02*x + a12*y + a22*z + mat[14]; - dest[15] = a03*x + a13*y + a23*z + mat[15]; - return dest; -}; - -/* - * mat4.scale - * Scales a matrix by the given vector - * - * Params: - * mat - mat4 to scale - * vec - vec3 specifying the scale for each axis - * dest - Optional, mat4 receiving operation result. If not specified result is written to mat - * - * Returns: - * dest if specified, mat otherwise - */ -mat4.scale = function(mat, vec, dest) { - var x = vec[0], y = vec[1], z = vec[2]; - - if(!dest || mat == dest) { - mat[0] *= x; - mat[1] *= x; - mat[2] *= x; - mat[3] *= x; - mat[4] *= y; - mat[5] *= y; - mat[6] *= y; - mat[7] *= y; - mat[8] *= z; - mat[9] *= z; - mat[10] *= z; - mat[11] *= z; - return mat; - } - - dest[0] = mat[0]*x; - dest[1] = mat[1]*x; - dest[2] = mat[2]*x; - dest[3] = mat[3]*x; - dest[4] = mat[4]*y; - dest[5] = mat[5]*y; - dest[6] = mat[6]*y; - dest[7] = mat[7]*y; - dest[8] = mat[8]*z; - dest[9] = mat[9]*z; - dest[10] = mat[10]*z; - dest[11] = mat[11]*z; - dest[12] = mat[12]; - dest[13] = mat[13]; - dest[14] = mat[14]; - dest[15] = mat[15]; - return dest; -}; - -/* - * mat4.rotate - * Rotates a matrix by the given angle around the specified axis - * If rotating around a primary axis (X,Y,Z) one of the specialized rotation functions should be used instead for performance - * - * Params: - * mat - mat4 to rotate - * angle - angle (in radians) to rotate - * axis - vec3 representing the axis to rotate around - * dest - Optional, mat4 receiving operation result. If not specified result is written to mat - * - * Returns: - * dest if specified, mat otherwise - */ -mat4.rotate = function(mat, angle, axis, dest) { - var x = axis[0], y = axis[1], z = axis[2]; - var len = Math.sqrt(x*x + y*y + z*z); - if (!len) { return null; } - if (len != 1) { - len = 1 / len; - x *= len; - y *= len; - z *= len; - } - - var s = Math.sin(angle); - var c = Math.cos(angle); - var t = 1-c; - - // Cache the matrix values (makes for huge speed increases!) - var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3]; - var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7]; - var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11]; - - // Construct the elements of the rotation matrix - var b00 = x*x*t + c, b01 = y*x*t + z*s, b02 = z*x*t - y*s; - var b10 = x*y*t - z*s, b11 = y*y*t + c, b12 = z*y*t + x*s; - var b20 = x*z*t + y*s, b21 = y*z*t - x*s, b22 = z*z*t + c; - - if(!dest) { - dest = mat; - } else if(mat != dest) { // If the source and destination differ, copy the unchanged last row - dest[12] = mat[12]; - dest[13] = mat[13]; - dest[14] = mat[14]; - dest[15] = mat[15]; - } - - // Perform rotation-specific matrix multiplication - dest[0] = a00*b00 + a10*b01 + a20*b02; - dest[1] = a01*b00 + a11*b01 + a21*b02; - dest[2] = a02*b00 + a12*b01 + a22*b02; - dest[3] = a03*b00 + a13*b01 + a23*b02; - - dest[4] = a00*b10 + a10*b11 + a20*b12; - dest[5] = a01*b10 + a11*b11 + a21*b12; - dest[6] = a02*b10 + a12*b11 + a22*b12; - dest[7] = a03*b10 + a13*b11 + a23*b12; - - dest[8] = a00*b20 + a10*b21 + a20*b22; - dest[9] = a01*b20 + a11*b21 + a21*b22; - dest[10] = a02*b20 + a12*b21 + a22*b22; - dest[11] = a03*b20 + a13*b21 + a23*b22; - return dest; -}; - -/* - * mat4.rotateX - * Rotates a matrix by the given angle around the X axis - * - * Params: - * mat - mat4 to rotate - * angle - angle (in radians) to rotate - * dest - Optional, mat4 receiving operation result. If not specified result is written to mat - * - * Returns: - * dest if specified, mat otherwise - */ -mat4.rotateX = function(mat, angle, dest) { - var s = Math.sin(angle); - var c = Math.cos(angle); - - // Cache the matrix values (makes for huge speed increases!) - var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7]; - var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11]; - - if(!dest) { - dest = mat; - } else if(mat != dest) { // If the source and destination differ, copy the unchanged rows - dest[0] = mat[0]; - dest[1] = mat[1]; - dest[2] = mat[2]; - dest[3] = mat[3]; - - dest[12] = mat[12]; - dest[13] = mat[13]; - dest[14] = mat[14]; - dest[15] = mat[15]; - } - - // Perform axis-specific matrix multiplication - dest[4] = a10*c + a20*s; - dest[5] = a11*c + a21*s; - dest[6] = a12*c + a22*s; - dest[7] = a13*c + a23*s; - - dest[8] = a10*-s + a20*c; - dest[9] = a11*-s + a21*c; - dest[10] = a12*-s + a22*c; - dest[11] = a13*-s + a23*c; - return dest; -}; - -/* - * mat4.rotateY - * Rotates a matrix by the given angle around the Y axis - * - * Params: - * mat - mat4 to rotate - * angle - angle (in radians) to rotate - * dest - Optional, mat4 receiving operation result. If not specified result is written to mat - * - * Returns: - * dest if specified, mat otherwise - */ -mat4.rotateY = function(mat, angle, dest) { - var s = Math.sin(angle); - var c = Math.cos(angle); - - // Cache the matrix values (makes for huge speed increases!) - var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3]; - var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11]; - - if(!dest) { - dest = mat; - } else if(mat != dest) { // If the source and destination differ, copy the unchanged rows - dest[4] = mat[4]; - dest[5] = mat[5]; - dest[6] = mat[6]; - dest[7] = mat[7]; - - dest[12] = mat[12]; - dest[13] = mat[13]; - dest[14] = mat[14]; - dest[15] = mat[15]; - } - - // Perform axis-specific matrix multiplication - dest[0] = a00*c + a20*-s; - dest[1] = a01*c + a21*-s; - dest[2] = a02*c + a22*-s; - dest[3] = a03*c + a23*-s; - - dest[8] = a00*s + a20*c; - dest[9] = a01*s + a21*c; - dest[10] = a02*s + a22*c; - dest[11] = a03*s + a23*c; - return dest; -}; - -/* - * mat4.rotateZ - * Rotates a matrix by the given angle around the Z axis - * - * Params: - * mat - mat4 to rotate - * angle - angle (in radians) to rotate - * dest - Optional, mat4 receiving operation result. If not specified result is written to mat - * - * Returns: - * dest if specified, mat otherwise - */ -mat4.rotateZ = function(mat, angle, dest) { - var s = Math.sin(angle); - var c = Math.cos(angle); - - // Cache the matrix values (makes for huge speed increases!) - var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3]; - var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7]; - - if(!dest) { - dest = mat; - } else if(mat != dest) { // If the source and destination differ, copy the unchanged last row - dest[8] = mat[8]; - dest[9] = mat[9]; - dest[10] = mat[10]; - dest[11] = mat[11]; - - dest[12] = mat[12]; - dest[13] = mat[13]; - dest[14] = mat[14]; - dest[15] = mat[15]; - } - - // Perform axis-specific matrix multiplication - dest[0] = a00*c + a10*s; - dest[1] = a01*c + a11*s; - dest[2] = a02*c + a12*s; - dest[3] = a03*c + a13*s; - - dest[4] = a00*-s + a10*c; - dest[5] = a01*-s + a11*c; - dest[6] = a02*-s + a12*c; - dest[7] = a03*-s + a13*c; - - return dest; -}; - -/* - * mat4.frustum - * Generates a frustum matrix with the given bounds - * - * Params: - * left, right - scalar, left and right bounds of the frustum - * bottom, top - scalar, bottom and top bounds of the frustum - * near, far - scalar, near and far bounds of the frustum - * dest - Optional, mat4 frustum matrix will be written into - * - * Returns: - * dest if specified, a new mat4 otherwise - */ -mat4.frustum = function(left, right, bottom, top, near, far, dest) { - if(!dest) { dest = mat4.create(); } - var rl = (right - left); - var tb = (top - bottom); - var fn = (far - near); - dest[0] = (near*2) / rl; - dest[1] = 0; - dest[2] = 0; - dest[3] = 0; - dest[4] = 0; - dest[5] = (near*2) / tb; - dest[6] = 0; - dest[7] = 0; - dest[8] = (right + left) / rl; - dest[9] = (top + bottom) / tb; - dest[10] = -(far + near) / fn; - dest[11] = -1; - dest[12] = 0; - dest[13] = 0; - dest[14] = -(far*near*2) / fn; - dest[15] = 0; - return dest; -}; - -/* - * mat4.perspective - * Generates a perspective projection matrix with the given bounds - * - * Params: - * fovy - scalar, vertical field of view - * aspect - scalar, aspect ratio. typically viewport width/height - * near, far - scalar, near and far bounds of the frustum - * dest - Optional, mat4 frustum matrix will be written into - * - * Returns: - * dest if specified, a new mat4 otherwise - */ -mat4.perspective = function(fovy, aspect, near, far, dest) { - var top = near*Math.tan(fovy*Math.PI / 360.0); - var right = top*aspect; - return mat4.frustum(-right, right, -top, top, near, far, dest); -}; - -/* - * mat4.ortho - * Generates a orthogonal projection matrix with the given bounds - * - * Params: - * left, right - scalar, left and right bounds of the frustum - * bottom, top - scalar, bottom and top bounds of the frustum - * near, far - scalar, near and far bounds of the frustum - * dest - Optional, mat4 frustum matrix will be written into - * - * Returns: - * dest if specified, a new mat4 otherwise - */ -mat4.ortho = function(left, right, bottom, top, near, far, dest) { - if(!dest) { dest = mat4.create(); } - var rl = (right - left); - var tb = (top - bottom); - var fn = (far - near); - dest[0] = 2 / rl; - dest[1] = 0; - dest[2] = 0; - dest[3] = 0; - dest[4] = 0; - dest[5] = 2 / tb; - dest[6] = 0; - dest[7] = 0; - dest[8] = 0; - dest[9] = 0; - dest[10] = -2 / fn; - dest[11] = 0; - dest[12] = -(left + right) / rl; - dest[13] = -(top + bottom) / tb; - dest[14] = -(far + near) / fn; - dest[15] = 1; - return dest; -}; - -/* - * mat4.ortho - * Generates a look-at matrix with the given eye position, focal point, and up axis - * - * Params: - * eye - vec3, position of the viewer - * center - vec3, point the viewer is looking at - * up - vec3 pointing "up" - * dest - Optional, mat4 frustum matrix will be written into - * - * Returns: - * dest if specified, a new mat4 otherwise - */ -mat4.lookAt = function(eye, center, up, dest) { - if(!dest) { dest = mat4.create(); } - - var eyex = eye[0], - eyey = eye[1], - eyez = eye[2], - upx = up[0], - upy = up[1], - upz = up[2], - centerx = center[0], - centery = center[1], - centerz = center[2]; - - if (eyex == centerx && eyey == centery && eyez == centerz) { - return mat4.identity(dest); - } - - var z0,z1,z2,x0,x1,x2,y0,y1,y2,len; - - //vec3.direction(eye, center, z); - z0 = eyex - center[0]; - z1 = eyey - center[1]; - z2 = eyez - center[2]; - - // normalize (no check needed for 0 because of early return) - len = 1/Math.sqrt(z0*z0 + z1*z1 + z2*z2); - z0 *= len; - z1 *= len; - z2 *= len; - - //vec3.normalize(vec3.cross(up, z, x)); - x0 = upy*z2 - upz*z1; - x1 = upz*z0 - upx*z2; - x2 = upx*z1 - upy*z0; - len = Math.sqrt(x0*x0 + x1*x1 + x2*x2); - if (!len) { - x0 = 0; - x1 = 0; - x2 = 0; - } else { - len = 1/len; - x0 *= len; - x1 *= len; - x2 *= len; - }; - - //vec3.normalize(vec3.cross(z, x, y)); - y0 = z1*x2 - z2*x1; - y1 = z2*x0 - z0*x2; - y2 = z0*x1 - z1*x0; - - len = Math.sqrt(y0*y0 + y1*y1 + y2*y2); - if (!len) { - y0 = 0; - y1 = 0; - y2 = 0; - } else { - len = 1/len; - y0 *= len; - y1 *= len; - y2 *= len; - } - - dest[0] = x0; - dest[1] = y0; - dest[2] = z0; - dest[3] = 0; - dest[4] = x1; - dest[5] = y1; - dest[6] = z1; - dest[7] = 0; - dest[8] = x2; - dest[9] = y2; - dest[10] = z2; - dest[11] = 0; - dest[12] = -(x0*eyex + x1*eyey + x2*eyez); - dest[13] = -(y0*eyex + y1*eyey + y2*eyez); - dest[14] = -(z0*eyex + z1*eyey + z2*eyez); - dest[15] = 1; - - return dest; -}; - -/* - * mat4.str - * Returns a string representation of a mat4 - * - * Params: - * mat - mat4 to represent as a string - * - * Returns: - * string representation of mat - */ -mat4.str = function(mat) { - return '[' + mat[0] + ', ' + mat[1] + ', ' + mat[2] + ', ' + mat[3] + - ',\n '+ mat[4] + ', ' + mat[5] + ', ' + mat[6] + ', ' + mat[7] + - ',\n '+ mat[8] + ', ' + mat[9] + ', ' + mat[10] + ', ' + mat[11] + - ',\n '+ mat[12] + ', ' + mat[13] + ', ' + mat[14] + ', ' + mat[15] + ']'; -}; - -/* - * quat4 - Quaternions - */ -quat4 = {}; - -/* - * quat4.create - * Creates a new instance of a quat4 using the default array type - * Any javascript array containing at least 4 numeric elements can serve as a quat4 - * - * Params: - * quat - Optional, quat4 containing values to initialize with - * - * Returns: - * New quat4 - */ -quat4.create = function(quat) { - var dest; - - if(quat) { - dest = new glMatrixArrayType(4); - dest[0] = quat[0]; - dest[1] = quat[1]; - dest[2] = quat[2]; - dest[3] = quat[3]; - } else { - if(glMatrixArrayType === Array) - dest = new glMatrixArrayType([0,0,0,0]); - else - dest = new glMatrixArrayType(4); - } - - return dest; -}; - -/* - * quat4.set - * Copies the values of one quat4 to another - * - * Params: - * quat - quat4 containing values to copy - * dest - quat4 receiving copied values - * - * Returns: - * dest - */ -quat4.set = function(quat, dest) { - dest[0] = quat[0]; - dest[1] = quat[1]; - dest[2] = quat[2]; - dest[3] = quat[3]; - - return dest; -}; - -/* - * quat4.calculateW - * Calculates the W component of a quat4 from the X, Y, and Z components. - * Assumes that quaternion is 1 unit in length. - * Any existing W component will be ignored. - * - * Params: - * quat - quat4 to calculate W component of - * dest - Optional, quat4 receiving calculated values. If not specified result is written to quat - * - * Returns: - * dest if specified, quat otherwise - */ -quat4.calculateW = function(quat, dest) { - var x = quat[0], y = quat[1], z = quat[2]; - - if(!dest || quat == dest) { - quat[3] = -Math.sqrt(Math.abs(1.0 - x*x - y*y - z*z)); - return quat; - } - dest[0] = x; - dest[1] = y; - dest[2] = z; - dest[3] = -Math.sqrt(Math.abs(1.0 - x*x - y*y - z*z)); - return dest; -}; - -/* - * quat4.inverse - * Calculates the inverse of a quat4 - * - * Params: - * quat - quat4 to calculate inverse of - * dest - Optional, quat4 receiving inverse values. If not specified result is written to quat - * - * Returns: - * dest if specified, quat otherwise - */ -quat4.inverse = function(quat, dest) { - if(!dest || quat == dest) { - quat[0] *= -1; - quat[1] *= -1; - quat[2] *= -1; - return quat; - } - dest[0] = -quat[0]; - dest[1] = -quat[1]; - dest[2] = -quat[2]; - dest[3] = quat[3]; - return dest; -}; - -/* - * quat4.length - * Calculates the length of a quat4 - * - * Params: - * quat - quat4 to calculate length of - * - * Returns: - * Length of quat - */ -quat4.length = function(quat) { - var x = quat[0], y = quat[1], z = quat[2], w = quat[3]; - return Math.sqrt(x*x + y*y + z*z + w*w); -}; - -/* - * quat4.normalize - * Generates a unit quaternion of the same direction as the provided quat4 - * If quaternion length is 0, returns [0, 0, 0, 0] - * - * Params: - * quat - quat4 to normalize - * dest - Optional, quat4 receiving operation result. If not specified result is written to quat - * - * Returns: - * dest if specified, quat otherwise - */ -quat4.normalize = function(quat, dest) { - if(!dest) { dest = quat; } - - var x = quat[0], y = quat[1], z = quat[2], w = quat[3]; - var len = Math.sqrt(x*x + y*y + z*z + w*w); - if(len == 0) { - dest[0] = 0; - dest[1] = 0; - dest[2] = 0; - dest[3] = 0; - return dest; - } - len = 1/len; - dest[0] = x * len; - dest[1] = y * len; - dest[2] = z * len; - dest[3] = w * len; - - return dest; -}; - -/* - * quat4.multiply - * Performs a quaternion multiplication - * - * Params: - * quat - quat4, first operand - * quat2 - quat4, second operand - * dest - Optional, quat4 receiving operation result. If not specified result is written to quat - * - * Returns: - * dest if specified, quat otherwise - */ -quat4.multiply = function(quat, quat2, dest) { - if(!dest) { dest = quat; } - - var qax = quat[0], qay = quat[1], qaz = quat[2], qaw = quat[3]; - var qbx = quat2[0], qby = quat2[1], qbz = quat2[2], qbw = quat2[3]; - - dest[0] = qax*qbw + qaw*qbx + qay*qbz - qaz*qby; - dest[1] = qay*qbw + qaw*qby + qaz*qbx - qax*qbz; - dest[2] = qaz*qbw + qaw*qbz + qax*qby - qay*qbx; - dest[3] = qaw*qbw - qax*qbx - qay*qby - qaz*qbz; - - return dest; -}; - -/* - * quat4.multiplyVec3 - * Transforms a vec3 with the given quaternion - * - * Params: - * quat - quat4 to transform the vector with - * vec - vec3 to transform - * dest - Optional, vec3 receiving operation result. If not specified result is written to vec - * - * Returns: - * dest if specified, vec otherwise - */ -quat4.multiplyVec3 = function(quat, vec, dest) { - if(!dest) { dest = vec; } - - var x = vec[0], y = vec[1], z = vec[2]; - var qx = quat[0], qy = quat[1], qz = quat[2], qw = quat[3]; - - // calculate quat * vec - var ix = qw*x + qy*z - qz*y; - var iy = qw*y + qz*x - qx*z; - var iz = qw*z + qx*y - qy*x; - var iw = -qx*x - qy*y - qz*z; - - // calculate result * inverse quat - dest[0] = ix*qw + iw*-qx + iy*-qz - iz*-qy; - dest[1] = iy*qw + iw*-qy + iz*-qx - ix*-qz; - dest[2] = iz*qw + iw*-qz + ix*-qy - iy*-qx; - - return dest; -}; - -/* - * quat4.toMat3 - * Calculates a 3x3 matrix from the given quat4 - * - * Params: - * quat - quat4 to create matrix from - * dest - Optional, mat3 receiving operation result - * - * Returns: - * dest if specified, a new mat3 otherwise - */ -quat4.toMat3 = function(quat, dest) { - if(!dest) { dest = mat3.create(); } - - var x = quat[0], y = quat[1], z = quat[2], w = quat[3]; - - var x2 = x + x; - var y2 = y + y; - var z2 = z + z; - - var xx = x*x2; - var xy = x*y2; - var xz = x*z2; - - var yy = y*y2; - var yz = y*z2; - var zz = z*z2; - - var wx = w*x2; - var wy = w*y2; - var wz = w*z2; - - dest[0] = 1 - (yy + zz); - dest[1] = xy - wz; - dest[2] = xz + wy; - - dest[3] = xy + wz; - dest[4] = 1 - (xx + zz); - dest[5] = yz - wx; - - dest[6] = xz - wy; - dest[7] = yz + wx; - dest[8] = 1 - (xx + yy); - - return dest; -}; - -/* - * quat4.toMat4 - * Calculates a 4x4 matrix from the given quat4 - * - * Params: - * quat - quat4 to create matrix from - * dest - Optional, mat4 receiving operation result - * - * Returns: - * dest if specified, a new mat4 otherwise - */ -quat4.toMat4 = function(quat, dest) { - if(!dest) { dest = mat4.create(); } - - var x = quat[0], y = quat[1], z = quat[2], w = quat[3]; - - var x2 = x + x; - var y2 = y + y; - var z2 = z + z; - - var xx = x*x2; - var xy = x*y2; - var xz = x*z2; - - var yy = y*y2; - var yz = y*z2; - var zz = z*z2; - - var wx = w*x2; - var wy = w*y2; - var wz = w*z2; - - dest[0] = 1 - (yy + zz); - dest[1] = xy - wz; - dest[2] = xz + wy; - dest[3] = 0; - - dest[4] = xy + wz; - dest[5] = 1 - (xx + zz); - dest[6] = yz - wx; - dest[7] = 0; - - dest[8] = xz - wy; - dest[9] = yz + wx; - dest[10] = 1 - (xx + yy); - dest[11] = 0; - - dest[12] = 0; - dest[13] = 0; - dest[14] = 0; - dest[15] = 1; - - return dest; -}; - -/* - * quat4.slerp - * Performs a spherical linear interpolation between two quat4 - * - * Params: - * quat - quat4, first quaternion - * quat2 - quat4, second quaternion - * slerp - interpolation amount between the two inputs - * dest - Optional, quat4 receiving operation result. If not specified result is written to quat - * - * Returns: - * dest if specified, quat otherwise - */ -quat4.slerp = function(quat, quat2, slerp, dest) { - if(!dest) { dest = quat; } - - var cosHalfTheta = quat[0]*quat2[0] + quat[1]*quat2[1] + quat[2]*quat2[2] + quat[3]*quat2[3]; - - if (Math.abs(cosHalfTheta) >= 1.0){ - if(dest != quat) { - dest[0] = quat[0]; - dest[1] = quat[1]; - dest[2] = quat[2]; - dest[3] = quat[3]; - } - return dest; - } - - var halfTheta = Math.acos(cosHalfTheta); - var sinHalfTheta = Math.sqrt(1.0 - cosHalfTheta*cosHalfTheta); - - if (Math.abs(sinHalfTheta) < 0.001){ - dest[0] = (quat[0]*0.5 + quat2[0]*0.5); - dest[1] = (quat[1]*0.5 + quat2[1]*0.5); - dest[2] = (quat[2]*0.5 + quat2[2]*0.5); - dest[3] = (quat[3]*0.5 + quat2[3]*0.5); - return dest; - } - - var ratioA = Math.sin((1 - slerp)*halfTheta) / sinHalfTheta; - var ratioB = Math.sin(slerp*halfTheta) / sinHalfTheta; - - dest[0] = (quat[0]*ratioA + quat2[0]*ratioB); - dest[1] = (quat[1]*ratioA + quat2[1]*ratioB); - dest[2] = (quat[2]*ratioA + quat2[2]*ratioB); - dest[3] = (quat[3]*ratioA + quat2[3]*ratioB); - - return dest; -}; - - -/* - * quat4.str - * Returns a string representation of a quaternion - * - * Params: - * quat - quat4 to represent as a string - * - * Returns: - * string representation of quat - */ -quat4.str = function(quat) { - return '[' + quat[0] + ', ' + quat[1] + ', ' + quat[2] + ', ' + quat[3] + ']'; -}; - - -define("glMatrix", ["typedefs"], (function (global) { - return function () { - var ret, fn; - return ret || global.glMatrix; - }; -}(this))); - -/* - -Copyright (C) 2011 - - Christoph Oberhofer (ar.oberhofer@gmail.com) - - Jens Grubert (jg@jensgrubert.de) - - Gerhard Reitmayr (reitmayr@icg.tugraz.at) -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see . -*/ - - -/* - * glMatrixAddon.js - * Extension to the glMatrix library. The original glMatrix library - * was created by Brandon Jones. - */ - - -mat4.xVec4 = function(mat, vec, dest){ - if(!dest) { dest = vec; } - var x = vec[0], y = vec[1], z = vec[2], w = vec[3]; - - dest[0] = mat[0]*x + mat[1]*y + mat[2]*z + mat[3]*w; - dest[1] = mat[4]*x + mat[5]*y + mat[6]*z + mat[7]*w; - dest[2] = mat[8]*x + mat[9]*y + mat[10]*z + mat[11]*w; - dest[3] = mat[12]*x + mat[13]*y + mat[14]*z + mat[15]*w; - - return dest; -}; - -mat3.scale = function(mat, scalar, dest){ - if(!dest || mat == dest) { - mat[0] *= scalar; - mat[1] *= scalar; - mat[2] *= scalar; - mat[3] *= scalar; - mat[4] *= scalar; - mat[5] *= scalar; - mat[6] *= scalar; - mat[7] *= scalar; - mat[8] *= scalar; - return mat; - } - dest = mat3.create(); - dest[0] = mat[0]*scalar; - dest[1] = mat[1]*scalar; - dest[2] = mat[2]*scalar; - dest[3] = mat[3]*scalar; - dest[4] = mat[4]*scalar; - dest[5] = mat[5]*scalar; - dest[6] = mat[6]*scalar; - dest[7] = mat[7]*scalar; - dest[8] = mat[8]*scalar; - return dest; -}; - -mat3.inverse = function(mat, dest){ - if(!dest) { dest = mat; } - - var ha00 = mat[0], ha01 = mat[1], ha02 = mat[2]; - var ha10 = mat[3], ha11 = mat[4], ha12 = mat[5]; - var ha20 = mat[6], ha21 = mat[7], ha22 = mat[8]; - - var invDetA = 1/(ha00*ha11*ha22 + ha01*ha12*ha20 + ha02*ha10*ha21 - ha02*ha11*ha20 - ha01*ha10*ha22 - ha00*ha12*ha21); - dest[0] = (ha11*ha22 - ha12*ha21)*invDetA; - dest[1] = (ha02*ha21 - ha01*ha22)*invDetA; - dest[2] = (ha01*ha12 - ha02*ha11)*invDetA; - dest[3] = (ha12*ha20 - ha10*ha22)*invDetA; - dest[4] = (ha00*ha22 - ha02*ha20)*invDetA; - dest[5] = (ha02*ha10 - ha00*ha12)*invDetA; - dest[6] = (ha10*ha21 - ha11*ha20)*invDetA; - dest[7] = (ha01*ha20 - ha00*ha21)*invDetA; - dest[8] = (ha00*ha11 - ha01*ha10)*invDetA; - return dest; -}; - -mat3.multiply = function(mat, mat2, dest) { - if(!dest) { dest = mat; } - - var ha00 = mat[0], ha01 = mat[1], ha02 = mat[2]; - var ha10 = mat[3], ha11 = mat[4], ha12 = mat[5]; - var ha20 = mat[6], ha21 = mat[7], ha22 = mat[8]; - - var hb00 = mat2[0], hb01 = mat2[1], hb02 = mat2[2]; - var hb10 = mat2[3], hb11 = mat2[4], hb12 = mat2[5]; - var hb20 = mat2[6], hb21 = mat2[7], hb22 = mat2[8]; - - dest[0] = ha00*hb00 + ha01*hb10 + ha02*hb20; - dest[1] = ha00*hb01 + ha01*hb11 + ha02*hb21; - dest[2] = ha00*hb02 + ha01*hb12 + ha02*hb22; - - dest[3] = ha10*hb00 + ha11*hb10 + ha12*hb20; - dest[4] = ha10*hb01 + ha11*hb11 + ha12*hb21; - dest[5] = ha10*hb02 + ha11*hb12 + ha12*hb22; - - dest[6] = ha20*hb00 + ha21*hb10 + ha22*hb20; - dest[7] = ha20*hb01 + ha21*hb11 + ha22*hb21; - dest[8] = ha20*hb02 + ha21*hb12 + ha22*hb22; - return dest; -}; - -mat3.xVec3 = function(mat, vec, dest){ - if(!dest) { dest = vec; } - var x = vec[0], y = vec[1], z = vec[2]; - - dest[0] = mat[0]*x + mat[1]*y + mat[2]*z; - dest[1] = mat[3]*x + mat[4]*y + mat[5]*z; - dest[2] = mat[6]*x + mat[7]*y + mat[8]*z; - - return dest; -}; - -var vec4={}; - -vec4.create = function(vec){ - var dest; - - if(vec) { - dest = new glMatrixArrayType(4); - dest[0] = vec[0]; - dest[1] = vec[1]; - dest[2] = vec[2]; - dest[3] = vec[3]; - } else { - if(glMatrixArrayType === Array) - dest = new glMatrixArrayType([0,0,0,0]); - else - dest = new glMatrixArrayType(4); - } - - return dest; -}; - -vec4.project = function(vec, dest){ - if(!dest) { dest = vec; } - - dest[0] = vec[0]/vec[3]; - dest[1] = vec[1]/vec[3]; - dest[2] = vec[2]/vec[3]; - return dest; -}; - -vec4.scale = function(vec, val, dest){ - if(!dest || vec == dest) { - vec[0] *= val; - vec[1] *= val; - vec[2] *= val; - vec[4] *= val; - return vec; - } - - dest[0] = vec[0]*val; - dest[1] = vec[1]*val; - dest[2] = vec[2]*val; - dest[3] = vec[3]*val; - return dest; -}; - -vec4.xMat4 = function(vec, mat, dest){ - if(!dest) { dest = vec; } - - var x = vec[0], y = vec[1], z = vec[2], w = vec[3]; - - dest[0] = mat[0]*x + mat[4]*y + mat[8]*z + mat[12]*w; - dest[1] = mat[1]*x + mat[5]*y + mat[9]*z + mat[13]*w; - dest[2] = mat[2]*x + mat[6]*y + mat[10]*z + mat[14]*w; - dest[3] = mat[3]*x + mat[7]*y + mat[11]*z + mat[15]*w; - - return dest; -}; - - -var mat2 = {}; - -mat2.create = function(mat){ - var dest; - - if(mat) { - dest = new glMatrixArrayType(4); - dest[0] = mat[0]; - dest[1] = mat[1]; - dest[2] = mat[2]; - dest[3] = mat[3]; - } else { - if(glMatrixArrayType === Array) - dest = new glMatrixArrayType([0,0,0,0]); - else - dest = new glMatrixArrayType(4); - } - - return dest; -}; - -mat2.xVec2 = function(mat, vec, dest){ - if(!dest) { dest = vec; } - var x = vec[0], y = vec[1]; - - dest[0] = mat[0]*x + mat[1]*y; - dest[1] = mat[2]*x + mat[3]*y; - - return dest; -}; - -mat2.scale = function(mat, scale, dest){ - if(!dest || mat == dest) { - mat[0] *= scale; - mat[1] *= scale; - mat[2] *= scale; - mat[3] *= scale; - return mat; - } - - dest[0] = mat[0]*scale; - dest[1] = mat[1]*scale; - dest[2] = mat[2]*scale; - dest[3] = mat[3]*scale; - return dest; -}; - -mat2.determinant = function(mat){ - return mat[0]*mat[3] - mat[1]*mat[2]; -}; - -mat2.inverse = function(mat){ - var scale = 1/(mat2.determinant(mat)); - var a = mat[3]*scale, - b = -mat[1]*scale, - c = -mat[2]*scale, - d = mat[0]; - mat[0] = a; - mat[1] = b; - mat[2] = c; - mat[3] = d; - return mat; -}; - -var vec2 = {}; -vec2.create = function(vec){ - var dest; - - if(vec) { - dest = new glMatrixArrayType(2); - dest[0] = vec[0]; - dest[1] = vec[1]; - } else { - if(glMatrixArrayType === Array) - dest = new glMatrixArrayType([0,0]); - else - dest = new glMatrixArrayType(2); - } - - return dest; -}; - -vec2.subtract = function(vec, vec2, dest) { - if(!dest || vec == dest) { - vec[0] -= vec2[0]; - vec[1] -= vec2[1]; - return vec; - } - - dest[0] = vec[0] - vec2[0]; - dest[1] = vec[1] - vec2[1]; - return dest; -}; - -vec2.add = function(vec, vec2, dest) { - if(!dest || vec == dest) { - vec[0] += vec2[0]; - vec[1] += vec2[1]; - return vec; - } - - dest[0] = vec[0] + vec2[0]; - dest[1] = vec[1] + vec2[1]; - return dest; -}; - -vec2.scale = function(vec, val, dest) { - if(!dest || vec == dest) { - vec[0] *= val; - vec[1] *= val; - return vec; - } - - dest[0] = vec[0]*val; - dest[1] = vec[1]*val; - return dest; -}; - -vec2.normalize = function(vec, dest) { - if(!dest) { dest = vec; } - - var x = vec[0], y = vec[1]; - var len = Math.sqrt(x*x + y*y); - - if (!len) { - dest[0] = 0; - dest[1] = 0; - return dest; - } else if (len == 1) { - dest[0] = x; - dest[1] = y; - return dest; - } - - len = 1 / len; - dest[0] = x*len; - dest[1] = y*len; - return dest; -}; - -vec2.dot = function(vec, vec2){ - return vec[0]*vec2[0] + vec[1]*vec2[1]; -}; - -vec2.multiply = function(vec, vec2, dest){ - if(!dest) { dest = vec; } - - dest[0] = vec[0]*vec2[0]; - dest[1] = vec[1]*vec2[1]; - return dest; -}; - -/** - * @param vec vec2 to be unprojected [x,y] -> [x,y,1] - * @returns vec3 unprojected vector - */ -vec2.unproject = function(vec){ - return vec3.create([vec[0], vec[1], 1]); -}; - -vec2.length = function(vec){ - return Math.sqrt(vec[0]*vec[0] + vec[1]*vec[1]); -}; - -vec2.perspectiveProject = function(vec){ - var result = vec2.create(vec); - return vec2.scale(result, 1/vec[2]); -}; - -/** - * @param vec vec3 to be projected [x,y,z] -> [x/z,y/z] - * @returns vec2 projected vector - */ -vec3.project = function(vec){ - return vec2.scale(vec2.create(vec), 1/vec[2]); -}; - -var vec6 = {}; -vec6.scale = function(vec, val, dest){ - if(!dest || vec == dest) { - vec[0] *= val; - vec[1] *= val; - vec[2] *= val; - vec[3] *= val; - vec[4] *= val; - vec[5] *= val; - return vec; - } - - dest[0] = vec[0]*val; - dest[1] = vec[1]*val; - dest[2] = vec[2]*val; - dest[3] = vec[3]*val; - dest[4] = vec[4]*val; - dest[5] = vec[5]*val; - return dest; -}; - -vec6.subtract = function(vec, vec2, dest){ - if(!dest || vec == dest) { - vec[0] -= vec2[0]; - vec[1] -= vec2[1]; - vec[2] -= vec2[2]; - vec[3] -= vec2[3]; - vec[4] -= vec2[4]; - vec[5] -= vec2[5]; - return vec; - } - - dest[0] = vec[0] - vec2[0]; - dest[1] = vec[1] - vec2[1]; - dest[2] = vec[2] - vec2[2]; - dest[3] = vec[3] - vec2[3]; - dest[4] = vec[4] - vec2[4]; - dest[5] = vec[5] - vec2[5]; - return dest; -}; - -vec6.dot = function(vec, vec2){ - return vec[0]*vec2[0] + vec[1]*vec2[1] + vec[2]*vec2[2] + vec[3]*vec2[3] + vec[4]*vec2[4] + vec[5]*vec2[5]; -}; - -var mat6 = {}; -mat6.xVec6 = function(mat, vec, dest){ - if(!dest) { dest = vec; } - var x = vec[0], y = vec[1], z = vec[2], u = vec[3], w = vec[4], v = vec[5]; - - dest[0] = mat[0]*x + mat[1]*y + mat[2]*z + mat[3]*u + mat[4]*w + mat[5]*v; - dest[1] = mat[6]*x + mat[7]*y + mat[8]*z + mat[9]*u + mat[10]*w + mat[11]*v; - dest[2] = mat[12]*x + mat[13]*y + mat[14]*z + mat[15]*u + mat[16]*w + mat[17]*v; - dest[3] = mat[18]*x + mat[19]*y + mat[20]*z + mat[21]*u + mat[22]*w + mat[23]*v; - dest[4] = mat[24]*x + mat[25]*y + mat[26]*z + mat[27]*u + mat[28]*w + mat[29]*v; - dest[5] = mat[30]*x + mat[31]*y + mat[32]*z + mat[33]*u + mat[34]*w + mat[35]*v; - - return dest; -}; - -mat3.xVec3 = function(mat, vec, dest){ - if(!dest) { dest = vec; } - var x = vec[0], y = vec[1], z = vec[2]; - - dest[0] = mat[0]*x + mat[1]*y + mat[2]*z; - dest[1] = mat[3]*x + mat[4]*y + mat[5]*z; - dest[2] = mat[6]*x + mat[7]*y + mat[8]*z; - - return dest; -}; -define("glMatrixAddon", ["glMatrix"], (function (global) { - return function () { - var ret, fn; - return ret || global.glMatrixAddon; - }; -}(this))); - -/* jshint undef: true, unused: true, browser:true, devel: true */ -/* global define */ - -define('array_helper',[],function() { - - - return { - init : function(arr, val) { - var l = arr.length; - while (l--) { - arr[l] = val; - } - }, - - /** - * Shuffles the content of an array - * @return {Array} the array itself shuffled - */ - shuffle : function(arr) { - var i = arr.length - 1, j, x; - for (i; i >= 0; i--) { - j = Math.floor(Math.random() * i); - x = arr[i]; - arr[i] = arr[j]; - arr[j] = x; - } - return arr; - }, - - toPointList : function(arr) { - var i, j, row = [], rows = []; - for ( i = 0; i < arr.length; i++) { - row = []; - for ( j = 0; j < arr[i].length; j++) { - row[j] = arr[i][j]; - } - rows[i] = "[" + row.join(",") + "]"; - } - return "[" + rows.join(",\r\n") + "]"; - }, - - /** - * returns the elements which's score is bigger than the threshold - * @return {Array} the reduced array - */ - threshold : function(arr, threshold, scoreFunc) { - var i, queue = []; - for ( i = 0; i < arr.length; i++) { - if (scoreFunc.apply(arr, [arr[i]]) >= threshold) { - queue.push(arr[i]); - } - } - return queue; - }, - - maxIndex : function(arr) { - var i, max = 0; - for ( i = 0; i < arr.length; i++) { - if (arr[i] > arr[max]) { - max = i; - } - } - return max; - }, - - max : function(arr) { - var i, max = 0; - for ( i = 0; i < arr.length; i++) { - if (arr[i] > max) { - max = arr[i]; - } - } - return max; - } - }; -}); -/* jshint undef: true, unused: true, browser:true, devel: true */ -/* global define, vec2, vec3 */ - -define('cv_utils',['cluster', 'glMatrixAddon', "array_helper"], function(Cluster2, glMatrixAddon, ArrayHelper) { - - - /* - * cv_utils.js - * Collection of CV functions and libraries - */ - - /** - * Namespace for various CV alorithms - * @class Represents a collection of useful CV algorithms/functions - */ - - var CVUtils = {}; - - /** - * @param x x-coordinate - * @param y y-coordinate - * @return ImageReference {x,y} Coordinate - */ - CVUtils.imageRef = function(x, y) { - var that = { - x : x, - y : y, - toVec2 : function() { - return vec2.create([this.x, this.y]); - }, - toVec3 : function() { - return vec3.create([this.x, this.y, 1]); - }, - round : function() { - this.x = this.x > 0.0 ? Math.floor(this.x + 0.5) : Math.floor(this.x - 0.5); - this.y = this.y > 0.0 ? Math.floor(this.y + 0.5) : Math.floor(this.y - 0.5); - return this; - } - }; - return that; - }; - - /** - * Computes an integral image of a given grayscale image. - * @param imageDataContainer {ImageDataContainer} the image to be integrated - */ - CVUtils.computeIntegralImage2 = function(imageWrapper, integralWrapper) { - var imageData = imageWrapper.data; - var width = imageWrapper.size.x; - var height = imageWrapper.size.y; - var integralImageData = integralWrapper.data; - var sum = 0, posA = 0, posB = 0, posC = 0, posD = 0, x, y; - - // sum up first column - posB = width; - sum = 0; - for ( y = 1; y < height; y++) { - sum += imageData[posA]; - integralImageData[posB] += sum; - posA += width; - posB += width; - } - - posA = 0; - posB = 1; - sum = 0; - for ( x = 1; x < width; x++) { - sum += imageData[posA]; - integralImageData[posB] += sum; - posA++; - posB++; - } - - for ( y = 1; y < height; y++) { - posA = y * width + 1; - posB = (y - 1) * width + 1; - posC = y * width; - posD = (y - 1) * width; - for ( x = 1; x < width; x++) { - integralImageData[posA] += imageData[posA] + integralImageData[posB] + integralImageData[posC] - integralImageData[posD]; - posA++; - posB++; - posC++; - posD++; - } - } - }; - - CVUtils.computeIntegralImage = function(imageWrapper, integralWrapper) { - var imageData = imageWrapper.data; - var width = imageWrapper.size.x; - var height = imageWrapper.size.y; - var integralImageData = integralWrapper.data; - var sum = 0; - - // sum up first row - for (var i = 0; i < width; i++) { - sum += imageData[i]; - integralImageData[i] = sum; - } - - for (var v = 1; v < height; v++) { - sum = 0; - for (var u = 0; u < width; u++) { - sum += imageData[v * width + u]; - integralImageData[((v) * width) + u] = sum + integralImageData[(v - 1) * width + u]; - } - } - }; - - CVUtils.thresholdImage = function(imageWrapper, threshold, targetWrapper) { - if (!targetWrapper) { - targetWrapper = imageWrapper; - } - var imageData = imageWrapper.data, length = imageData.length, targetData = targetWrapper.data; - - while (length--) { - targetData[length] = imageData[length] < threshold ? 1 : 0; - } - }; - - CVUtils.computeHistogram = function(imageWrapper) { - var imageData = imageWrapper.data, length = imageData.length, i, hist = new Int32Array(256); - - // init histogram - for ( i = 0; i < 256; i++) { - hist[i] = 0; - } - - while (length--) { - hist[imageData[length]]++; - } - return hist; - }; - - CVUtils.otsuThreshold = function(imageWrapper, targetWrapper) { - var hist, threshold; - - function px(init, end) { - var sum = 0, i; - for ( i = init; i <= end; i++) { - sum += hist[i]; - } - return sum; - } - - function mx(init, end) { - var i, sum = 0; - - for ( i = init; i <= end; i++) { - sum += i * hist[i]; - } - - return sum; - } - - function determineThreshold() { - var vet = [0], p1, p2, p12, k, m1, m2, m12; - - hist = CVUtils.computeHistogram(imageWrapper); - for ( k = 1; k < 255; k++) { - p1 = px(0, k); - p2 = px(k + 1, 255); - p12 = p1 * p2; - if (p12 === 0) { - p12 = 1; - } - m1 = mx(0, k) * p2; - m2 = mx(k + 1, 255) * p1; - m12 = m1 - m2; - vet[k] = m12 * m12 / p12; - } - return ArrayHelper.maxIndex(vet); - } - - threshold = determineThreshold(); - CVUtils.thresholdImage(imageWrapper, threshold, targetWrapper); - return threshold; - }; - - // local thresholding - CVUtils.computeBinaryImage = function(imageWrapper, integralWrapper, targetWrapper) { - CVUtils.computeIntegralImage(imageWrapper, integralWrapper); - - if (!targetWrapper) { - targetWrapper = imageWrapper; - } - var imageData = imageWrapper.data; - var targetData = targetWrapper.data; - var width = imageWrapper.size.x; - var height = imageWrapper.size.y; - var integralImageData = integralWrapper.data; - var sum = 0, v, u, kernel = 3, A, B, C, D, avg, size = (kernel * 2 + 1) * (kernel * 2 + 1); - - // clear out top & bottom-border - for ( v = 0; v <= kernel; v++) { - for ( u = 0; u < width; u++) { - targetData[((v) * width) + u] = 0; - targetData[(((height - 1) - v) * width) + u] = 0; - } - } - - // clear out left & right border - for ( v = kernel; v < height - kernel; v++) { - for ( u = 0; u <= kernel; u++) { - targetData[((v) * width) + u] = 0; - targetData[((v) * width) + (width - 1 - u)] = 0; - } - } - - for ( v = kernel + 1; v < height - kernel - 1; v++) { - for ( u = kernel + 1; u < width - kernel; u++) { - A = integralImageData[(v - kernel - 1) * width + (u - kernel - 1)]; - B = integralImageData[(v - kernel - 1) * width + (u + kernel)]; - C = integralImageData[(v + kernel) * width + (u - kernel - 1)]; - D = integralImageData[(v + kernel) * width + (u + kernel)]; - sum = D - C - B + A; - avg = sum / (size); - targetData[v * width + u] = imageData[v * width + u] > (avg + 5) ? 0 : 1; - } - } - }; - - CVUtils.cluster = function(points, threshold, property) { - var i, k, cluster, point, clusters = []; - - if (!property) { - property = "rad"; - } - - function addToCluster(point) { - var found = false; - for ( k = 0; k < clusters.length; k++) { - cluster = clusters[k]; - if (cluster.fits(point)) { - cluster.add(point); - found = true; - } - } - return found; - } - - // iterate over each cloud - for ( i = 0; i < points.length; i++) { - point = Cluster2.createPoint(points[i], i, property); - if (!addToCluster(point)) { - clusters.push(Cluster2.create(point, threshold)); - } - } - - return clusters; - - }; - - CVUtils.Tracer = { - trace : function(points, vec) { - var iteration, maxIterations = 10, top = [], result = [], centerPos = 0, currentPos = 0; - - function trace(idx, forward) { - var from, to, toIdx, predictedPos, thresholdX = 1, thresholdY = Math.abs(vec[1] / 10), found = false; - - function match(pos, predicted) { - if (pos.x > (predicted.x - thresholdX) && pos.x < (predicted.x + thresholdX) && pos.y > (predicted.y - thresholdY) && pos.y < (predicted.y + thresholdY)) { - return true; - } else { - return false; - } - } - - // check if the next index is within the vec specifications - // if not, check as long as the threshold is met - - from = points[idx]; - if (forward) { - predictedPos = { - x : from.x + vec[0], - y : from.y + vec[1] - }; - } else { - predictedPos = { - x : from.x - vec[0], - y : from.y - vec[1] - }; - } - - toIdx = forward ? idx + 1 : idx - 1; - to = points[toIdx]; - while (to && ( found = match(to, predictedPos)) !== true && (Math.abs(to.y - from.y) < vec[1])) { - toIdx = forward ? toIdx + 1 : toIdx - 1; - to = points[toIdx]; - } - - return found ? toIdx : null; - } - - for ( iteration = 0; iteration < maxIterations; iteration++) { - // randomly select point to start with - centerPos = Math.floor(Math.random() * points.length); - - // trace forward - top = []; - currentPos = centerPos; - top.push(points[currentPos]); - while (( currentPos = trace(currentPos, true)) !== null) { - top.push(points[currentPos]); - } - if (centerPos > 0) { - currentPos = centerPos; - while (( currentPos = trace(currentPos, false)) !== null) { - top.push(points[currentPos]); - } - } - - if (top.length > result.length) { - result = top; - } - } - - return result; - - } - }; - - CVUtils.DILATE = 1; - CVUtils.ERODE = 2; - - CVUtils.dilate = function(inImageWrapper, outImageWrapper) { - var v, u, inImageData = inImageWrapper.data, outImageData = outImageWrapper.data, height = inImageWrapper.size.y, width = inImageWrapper.size.x, sum, yStart1, yStart2, xStart1, xStart2; - - for ( v = 1; v < height - 1; v++) { - for ( u = 1; u < width - 1; u++) { - yStart1 = v - 1; - yStart2 = v + 1; - xStart1 = u - 1; - xStart2 = u + 1; - sum = inImageData[yStart1 * width + xStart1]/* + inImageData[yStart1*width+u] */ + inImageData[yStart1 * width + xStart2] + - /* inImageData[v*width+xStart1] + */ - inImageData[v * width + u] + /* inImageData[v*width+xStart2] +*/ - inImageData[yStart2 * width + xStart1]/* + inImageData[yStart2*width+u]*/ + inImageData[yStart2 * width + xStart2]; - outImageData[v * width + u] = sum > 0 ? 1 : 0; - } - } - }; - - CVUtils.erode = function(inImageWrapper, outImageWrapper) { - var v, u, inImageData = inImageWrapper.data, outImageData = outImageWrapper.data, height = inImageWrapper.size.y, width = inImageWrapper.size.x, sum, yStart1, yStart2, xStart1, xStart2; - - for ( v = 1; v < height - 1; v++) { - for ( u = 1; u < width - 1; u++) { - yStart1 = v - 1; - yStart2 = v + 1; - xStart1 = u - 1; - xStart2 = u + 1; - sum = inImageData[yStart1 * width + xStart1]/* + inImageData[yStart1*width+u] */ + inImageData[yStart1 * width + xStart2] + - /* inImageData[v*width+xStart1] + */ - inImageData[v * width + u] + /* inImageData[v*width+xStart2] +*/ - inImageData[yStart2 * width + xStart1]/* + inImageData[yStart2*width+u]*/ + inImageData[yStart2 * width + xStart2]; - outImageData[v * width + u] = sum === 5 ? 1 : 0; - } - } - }; - - CVUtils.subtract = function(aImageWrapper, bImageWrapper, resultImageWrapper) { - if (!resultImageWrapper) { - resultImageWrapper = aImageWrapper; - } - var length = aImageWrapper.data.length, aImageData = aImageWrapper.data, bImageData = bImageWrapper.data, cImageData = resultImageWrapper.data; - - while (length--) { - cImageData[length] = aImageData[length] - bImageData[length]; - } - }; - - CVUtils.bitwiseOr = function(aImageWrapper, bImageWrapper, resultImageWrapper) { - if (!resultImageWrapper) { - resultImageWrapper = aImageWrapper; - } - var length = aImageWrapper.data.length, aImageData = aImageWrapper.data, bImageData = bImageWrapper.data, cImageData = resultImageWrapper.data; - - while (length--) { - cImageData[length] = aImageData[length] || bImageData[length]; - } - }; - - CVUtils.countNonZero = function(imageWrapper) { - var length = imageWrapper.data.length, data = imageWrapper.data, sum = 0; - - while (length--) { - sum += data[length]; - } - return sum; - }; - - CVUtils.topGeneric = function(list, top, scoreFunc) { - var i, minIdx = 0, min = 0, queue = [], score, hit, pos; - - for ( i = 0; i < top; i++) { - queue[i] = { - score : 0, - item : null - }; - } - - for ( i = 0; i < list.length; i++) { - score = scoreFunc.apply(this, [list[i]]); - if (score > min) { - hit = queue[minIdx]; - hit.score = score; - hit.item = list[i]; - min = Number.MAX_VALUE; - for ( pos = 0; pos < top; pos++) { - if (queue[pos].score < min) { - min = queue[pos].score; - minIdx = pos; - } - } - } - } - - return queue; - }; - - CVUtils.grayArrayFromImage = function(htmlImage, offsetX, ctx, array) { - ctx.drawImage(htmlImage, offsetX, 0, htmlImage.width, htmlImage.height); - var ctxData = ctx.getImageData(offsetX, 0, htmlImage.width, htmlImage.height).data; - CVUtils.computeGray(ctxData, array); - }; - - CVUtils.grayArrayFromContext = function(ctx, size, offset, array) { - var ctxData = ctx.getImageData(offset.x, offset.y, size.x, size.y).data; - CVUtils.computeGray(ctxData, array); - }; - - CVUtils.grayAndHalfSampleFromCanvasData = function(canvasData, size, outArray) { - var topRowIdx = 0; - var bottomRowIdx = size.x; - var endIdx = Math.floor(canvasData.length / 4); - var outWidth = size.x / 2; - var outImgIdx = 0; - var inWidth = size.x; - var i; - - while (bottomRowIdx < endIdx) { - for ( i = 0; i < outWidth; i++) { - outArray[outImgIdx] = Math.floor(((0.299 * canvasData[topRowIdx * 4 + 0] + 0.587 * canvasData[topRowIdx * 4 + 1] + 0.114 * canvasData[topRowIdx * 4 + 2]) + (0.299 * canvasData[(topRowIdx + 1) * 4 + 0] + 0.587 * canvasData[(topRowIdx + 1) * 4 + 1] + 0.114 * canvasData[(topRowIdx + 1) * 4 + 2]) + (0.299 * canvasData[(bottomRowIdx) * 4 + 0] + 0.587 * canvasData[(bottomRowIdx) * 4 + 1] + 0.114 * canvasData[(bottomRowIdx) * 4 + 2]) + (0.299 * canvasData[(bottomRowIdx + 1) * 4 + 0] + 0.587 * canvasData[(bottomRowIdx + 1) * 4 + 1] + 0.114 * canvasData[(bottomRowIdx + 1) * 4 + 2])) / 4); - outImgIdx++; - topRowIdx = topRowIdx + 2; - bottomRowIdx = bottomRowIdx + 2; - } - topRowIdx = topRowIdx + inWidth; - bottomRowIdx = bottomRowIdx + inWidth; - } - - }; - - CVUtils.computeGray = function(imageData, outArray) { - var l = imageData.length / 4; - var i = 0; - for ( i = 0; i < l; i++) { - //outArray[i] = (0.299*imageData[i*4+0] + 0.587*imageData[i*4+1] + 0.114*imageData[i*4+2]); - - outArray[i] = Math.floor(0.299 * imageData[i * 4 + 0] + 0.587 * imageData[i * 4 + 1] + 0.114 * imageData[i * 4 + 2]); - } - }; - - CVUtils.loadImageArray = function(src, callback, canvas) { - if (!canvas) - canvas = document.createElement('canvas'); - var img = new Image(); - img.callback = callback; - img.onload = function() { - canvas.width = this.width; - canvas.height = this.height; - var ctx = canvas.getContext('2d'); - ctx.drawImage(this, 0, 0); - var array = new Uint8Array(this.width * this.height); - ctx.drawImage(this, 0, 0); - var data = ctx.getImageData(0, 0, this.width, this.height).data; - CVUtils.computeGray(data, array); - this.callback(array, { - x : this.width, - y : this.height - }, this); - }; - img.src = src; - }; - - /** - * @param inImg {ImageWrapper} input image to be sampled - * @param outImg {ImageWrapper} to be stored in - */ - CVUtils.halfSample = function(inImgWrapper, outImgWrapper) { - var inImg = inImgWrapper.data; - var inWidth = inImgWrapper.size.x; - var outImg = outImgWrapper.data; - var topRowIdx = 0; - var bottomRowIdx = inWidth; - var endIdx = inImg.length; - var outWidth = inWidth / 2; - var outImgIdx = 0; - while (bottomRowIdx < endIdx) { - for (var i = 0; i < outWidth; i++) { - outImg[outImgIdx] = Math.floor((inImg[topRowIdx] + inImg[topRowIdx + 1] + inImg[bottomRowIdx] + inImg[bottomRowIdx + 1]) / 4); - outImgIdx++; - topRowIdx = topRowIdx + 2; - bottomRowIdx = bottomRowIdx + 2; - } - topRowIdx = topRowIdx + inWidth; - bottomRowIdx = bottomRowIdx + inWidth; - } - }; - - CVUtils.hsv2rgb = function(hsv, rgb) { - var h = hsv[0], s = hsv[1], v = hsv[2], c = v * s, x = c * (1 - Math.abs((h / 60) % 2 - 1)), m = v - c, r = 0, g = 0, b = 0; - rgb = rgb || [0, 0, 0]; - - if (h < 60) { - r = c; - g = x; - } else if (h < 120) { - r = x; - g = c; - } else if (h < 180) { - g = c; - b = x; - } else if (h < 240) { - g = x; - b = c; - } else if (h < 300) { - r = x; - b = c; - } else if (h < 360) { - r = c; - b = x; - } - rgb[0] = ((r + m) * 255) | 0; - rgb[1] = ((g + m) * 255) | 0; - rgb[2] = ((b + m) * 255) | 0; - return rgb; - }; - - return (CVUtils); -}); - - -/* jshint undef: true, unused: true, browser:true, devel: true */ -/* global define, vec2, mat2 */ - -define('image_wrapper',[ - "subImage", - "cv_utils", - "array_helper" - ], - function(SubImage, CVUtils, ArrayHelper) { - - - - /** - * Represents a basic image combining the data and size. - * In addition, some methods for manipulation are contained. - * @param size {x,y} The size of the image in pixel - * @param data {Array} If given, a flat array containing the pixel data - * @param ArrayType {Type} If given, the desired DataType of the Array (may be typed/non-typed) - * @param initialize {Boolean} Indicating if the array should be initialized on creation. - * @returns {ImageWrapper} - */ - function ImageWrapper(size, data, ArrayType, initialize) { - if (!data) { - if (ArrayType) { - this.data = new ArrayType(size.x * size.y); - if (ArrayType === Array && initialize) { - ArrayHelper.init(this.data, 0); - } - } else { - this.data = new Uint8Array(size.x * size.y); - if (Uint8Array === Array && initialize) { - ArrayHelper.init(this.data, 0); - } - } - - } else { - this.data = data; - } - this.size = size; - } - - /** - * tests if a position is within the image with a given offset - * @param imgRef {x, y} The location to test - * @param border Number the padding value in pixel - * @returns {Boolean} true if location inside the image's border, false otherwise - * @see cvd/image.h - */ - ImageWrapper.prototype.inImageWithBorder = function(imgRef, border) { - return (imgRef.x >= border) && (imgRef.y >= border) && (imgRef.x < (this.size.x - border)) && (imgRef.y < (this.size.y - border)); - }; - - /** - * Transforms an image according to the given affine-transformation matrix. - * @param inImg ImageWrapper a image containing the information to be extracted. - * @param outImg ImageWrapper the image to be filled. The whole image out image is filled by the in image. - * @param M mat2 the matrix used to map point in the out matrix to those in the in matrix - * @param inOrig vec2 origin in the in image - * @param outOrig vec2 origin in the out image - * @returns Number the number of pixels not in the in image - * @see cvd/vision.h - */ - ImageWrapper.transform = function(inImg, outImg, M, inOrig, outOrig) { - var w = outImg.size.x, h = outImg.size.y, iw = inImg.size.x, ih = inImg.size.y; - var across = vec2.create([M[0], M[2]]); - var down = vec2.create([M[1], M[3]]); - var defaultValue = 0; - - var p0 = vec2.subtract(inOrig, mat2.xVec2(M, outOrig, vec2.create()), vec2.create()); - - var min_x = p0[0], min_y = p0[1]; - var max_x = min_x, max_y = min_y; - var p, i, j; - - var sampleFunc = ImageWrapper.sample; - - if (across[0] < 0) - min_x += w * across[0]; - else - max_x += w * across[0]; - - if (down[0] < 0) - min_x += h * down[0]; - else - max_x += h * down[0]; - - if (across[1] < 0) - min_y += w * across[1]; - else - max_y += w * across[1]; - - if (down[1] < 0) - min_y += h * down[1]; - else - max_y += h * down[1]; - - var carrigeReturn = vec2.subtract(down, vec2.scale(across, w, vec2.create()), vec2.create()); - - if (min_x >= 0 && min_y >= 0 && max_x < iw - 1 && max_y < ih - 1) { - p = p0; - for ( i = 0; i < h; ++i, vec2.add(p, carrigeReturn)) - for ( j = 0; j < w; ++j, vec2.add(p, across)) - outImg.set(j, i, sampleFunc(inImg, p[0], p[1])); - return 0; - } else { - var x_bound = iw - 1; - var y_bound = ih - 1; - var count = 0; - p = p0; - for ( i = 0; i < h; ++i, vec2.add(p, carrigeReturn)) { - for ( j = 0; j < w; ++j, vec2.add(p, across)) { - if (0 <= p[0] && 0 <= p[1] && p[0] < x_bound && p[1] < y_bound) { - outImg.set(j, i, sampleFunc(inImg, p[0], p[1])); - } else { - outImg.set(j, i, defaultValue); ++count; - } - } - } - return count; - } - }; - - /** - * Performs bilinear sampling - * @param inImg Image to extract sample from - * @param x the x-coordinate - * @param y the y-coordinate - * @returns the sampled value - * @see cvd/vision.h - */ - ImageWrapper.sample = function(inImg, x, y) { - var lx = Math.floor(x); - var ly = Math.floor(y); - var w = inImg.size.x; - var base = ly * inImg.size.x + lx; - var a = inImg.data[base + 0]; - var b = inImg.data[base + 1]; - var c = inImg.data[base + w]; - var d = inImg.data[base + w + 1]; - var e = a - b; - x -= lx; - y -= ly; - - var result = Math.floor(x * (y * (e - c + d) - e) + y * (c - a) + a); - return result; - }; - - /** - * Initializes a given array. Sets each element to zero. - * @param array {Array} The array to initialize - */ - ImageWrapper.clearArray = function(array) { - var l = array.length; - while (l--) { - array[l] = 0; - } - }; - - /** - * Creates a {SubImage} from the current image ({this}). - * @param from {ImageRef} The position where to start the {SubImage} from. (top-left corner) - * @param size {ImageRef} The size of the resulting image - * @returns {SubImage} A shared part of the original image - */ - ImageWrapper.prototype.subImage = function(from, size) { - return new SubImage(from, size, this); - }; - - /** - * Creates an {ImageWrapper) and copies the needed underlying image-data area - * @param imageWrapper {ImageWrapper} The target {ImageWrapper} where the data should be copied - * @param from {ImageRef} The location where to copy from (top-left location) - */ - ImageWrapper.prototype.subImageAsCopy = function(imageWrapper, from) { - var sizeY = imageWrapper.size.y, sizeX = imageWrapper.size.x; - var x, y; - for ( x = 0; x < sizeX; x++) { - for ( y = 0; y < sizeY; y++) { - imageWrapper.data[y * sizeX + x] = this.data[(from.y + y) * this.size.x + from.x + x]; - } - } - }; - - ImageWrapper.prototype.copyTo = function(imageWrapper) { - var length = this.data.length, srcData = this.data, dstData = imageWrapper.data; - - while (length--) { - dstData[length] = srcData[length]; - } - }; - - /** - * Retrieves a given pixel position from the image - * @param x {Number} The x-position - * @param y {Number} The y-position - * @returns {Number} The grayscale value at the pixel-position - */ - ImageWrapper.prototype.get = function(x, y) { - return this.data[y * this.size.x + x]; - }; - - /** - * Retrieves a given pixel position from the image - * @param x {Number} The x-position - * @param y {Number} The y-position - * @returns {Number} The grayscale value at the pixel-position - */ - ImageWrapper.prototype.getSafe = function(x, y) { - var i; - - if (!this.indexMapping) { - this.indexMapping = { - x : [], - y : [] - }; - for (i = 0; i < this.size.x; i++) { - this.indexMapping.x[i] = i; - this.indexMapping.x[i + this.size.x] = i; - } - for (i = 0; i < this.size.y; i++) { - this.indexMapping.y[i] = i; - this.indexMapping.y[i + this.size.y] = i; - } - } - return this.data[(this.indexMapping.y[y + this.size.y]) * this.size.x + this.indexMapping.x[x + this.size.x]]; - }; - - /** - * Sets a given pixel position in the image - * @param x {Number} The x-position - * @param y {Number} The y-position - * @param value {Number} The grayscale value to set - * @returns {ImageWrapper} The Image itself (for possible chaining) - */ - ImageWrapper.prototype.set = function(x, y, value) { - this.data[y * this.size.x + x] = value; - return this; - }; - - /** - * Sets the border of the image (1 pixel) to zero - */ - ImageWrapper.prototype.zeroBorder = function() { - var i, width = this.size.x, height = this.size.y, data = this.data; - for ( i = 0; i < width; i++) { - data[i] = data[(height - 1) * width + i] = 0; - } - for ( i = 1; i < height - 1; i++) { - data[i * width] = data[i * width + (width - 1)] = 0; - } - }; - - /** - * Inverts a binary image in place - */ - ImageWrapper.prototype.invert = function() { - var data = this.data, length = data.length; - - while (length--) { - data[length] = data[length] ? 0 : 1; - } - - }; - - ImageWrapper.prototype.convolve = function(kernel) { - var x, y, kx, ky, kSize = (kernel.length / 2) | 0, accu = 0; - for ( y = 0; y < this.size.y; y++) { - for ( x = 0; x < this.size.x; x++) { - accu = 0; - for ( ky = -kSize; ky <= kSize; ky++) { - for ( kx = -kSize; kx <= kSize; kx++) { - accu += kernel[ky+kSize][kx + kSize] * this.getSafe(x + kx, y + ky); - } - } - this.data[y * this.size.x + x] = accu; - } - } - }; - - ImageWrapper.prototype.moments = function(labelcount) { - var data = this.data, - x, - y, - height = this.size.y, - width = this.size.x, - val, - ysq, - labelsum = [], - i, - label, - mu11, - mu02, - mu20, - x_, - y_, - tmp, - result = [], - PI = Math.PI, - PI_4 = PI / 4; - - if (labelcount <= 0) { - return result; - } - - for ( i = 0; i < labelcount; i++) { - labelsum[i] = { - m00 : 0, - m01 : 0, - m10 : 0, - m11 : 0, - m02 : 0, - m20 : 0, - theta : 0, - rad : 0 - }; - } - - for ( y = 0; y < height; y++) { - ysq = y * y; - for ( x = 0; x < width; x++) { - val = data[y * width + x]; - if (val > 0) { - label = labelsum[val - 1]; - label.m00 += 1; - label.m01 += y; - label.m10 += x; - label.m11 += x * y; - label.m02 += ysq; - label.m20 += x * x; - } - } - } - - for ( i = 0; i < labelcount; i++) { - label = labelsum[i]; - if (!isNaN(label.m00) && label.m00 !== 0) { - x_ = label.m10 / label.m00; - y_ = label.m01 / label.m00; - mu11 = label.m11 / label.m00 - x_ * y_; - mu02 = label.m02 / label.m00 - y_ * y_; - mu20 = label.m20 / label.m00 - x_ * x_; - tmp = (mu02 - mu20) / (2 * mu11); - tmp = 0.5 * Math.atan(tmp) + (mu11 >= 0 ? PI_4 : -PI_4 ) + PI; - label.theta = (tmp * 180 / PI + 90) % 180 - 90; - if (label.theta < 0) { - label.theta += 180; - } - label.rad = tmp > PI ? tmp - PI : tmp; - label.vec = vec2.create([Math.cos(tmp), Math.sin(tmp)]); - result.push(label); - } - } - - return result; - }; - - /** - * Displays the {ImageWrapper} in a given canvas - * @param canvas {Canvas} The canvas element to write to - * @param scale {Number} Scale which is applied to each pixel-value - */ - ImageWrapper.prototype.show = function(canvas, scale) { - var ctx, - frame, - data, - current, - pixel, - x, - y; - - if (!scale) { - scale = 1.0; - } - ctx = canvas.getContext('2d'); - canvas.width = this.size.x; - canvas.height = this.size.y; - frame = ctx.getImageData(0, 0, canvas.width, canvas.height); - data = frame.data; - current = 0; - for (y = 0; y < this.size.y; y++) { - for (x = 0; x < this.size.x; x++) { - pixel = y * this.size.x + x; - current = this.get(x, y) * scale; - data[pixel * 4 + 0] = current; - data[pixel * 4 + 1] = current; - data[pixel * 4 + 2] = current; - data[pixel * 4 + 3] = 255; - } - } - //frame.data = data; - ctx.putImageData(frame, 0, 0); - }; - - /** - * Displays the {SubImage} in a given canvas - * @param canvas {Canvas} The canvas element to write to - * @param scale {Number} Scale which is applied to each pixel-value - */ - ImageWrapper.prototype.overlay = function(canvas, scale, from) { - if (!scale || scale < 0 || scale > 360) { - scale = 360; - } - var hsv = [0, 1, 1]; - var rgb = [0, 0, 0]; - var whiteRgb = [255, 255, 255]; - var blackRgb = [0, 0, 0]; - var result = []; - var ctx = canvas.getContext('2d'); - var frame = ctx.getImageData(from.x, from.y, this.size.x, this.size.y); - var data = frame.data; - var length = this.data.length; - while (length--) { - hsv[0] = this.data[length] * scale; - result = hsv[0] <= 0 ? whiteRgb : hsv[0] >= 360 ? blackRgb : CVUtils.hsv2rgb(hsv, rgb); - data[length * 4 + 0] = result[0]; - data[length * 4 + 1] = result[1]; - data[length * 4 + 2] = result[2]; - data[length * 4 + 3] = 255; - } - ctx.putImageData(frame, from.x, from.y); - }; - - return (ImageWrapper); -}); -/* jshint undef: true, unused: true, browser:true, devel: true */ -/* global define */ - -/** - * http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization - */ -define('tracer',[],function() { - - - var Tracer = { - searchDirections : [[0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1, -1], [-1, 0], [-1, 1]], - create : function(imageWrapper, labelWrapper) { - var imageData = imageWrapper.data, - labelData = labelWrapper.data, - searchDirections = this.searchDirections, - width = imageWrapper.size.x, - pos; - - function trace(current, color, label, edgelabel) { - var i, - y, - x; - - for ( i = 0; i < 7; i++) { - y = current.cy + searchDirections[current.dir][0]; - x = current.cx + searchDirections[current.dir][1]; - pos = y * width + x; - if ((imageData[pos] === color) && ((labelData[pos] === 0) || (labelData[pos] === label))) { - labelData[pos] = label; - current.cy = y; - current.cx = x; - return true; - } else { - if (labelData[pos] === 0) { - labelData[pos] = edgelabel; - } - current.dir = (current.dir + 1) % 8; - } - } - return false; - } - - function vertex2D(x, y, dir) { - return { - dir : dir, - x : x, - y : y, - next : null, - prev : null - }; - } - - function contourTracing(sy, sx, label, color, edgelabel) { - var Fv = null, - Cv, - P, - ldir, - current = { - cx : sx, - cy : sy, - dir : 0 - }; - - if (trace(current, color, label, edgelabel)) { - Fv = vertex2D(sx, sy, current.dir); - Cv = Fv; - ldir = current.dir; - P = vertex2D(current.cx, current.cy, 0); - P.prev = Cv; - Cv.next = P; - P.next = null; - Cv = P; - do { - current.dir = (current.dir + 6) % 8; - trace(current, color, label, edgelabel); - if (ldir != current.dir) { - Cv.dir = current.dir; - P = vertex2D(current.cx, current.cy, 0); - P.prev = Cv; - Cv.next = P; - P.next = null; - Cv = P; - } else { - Cv.dir = ldir; - Cv.x = current.cx; - Cv.y = current.cy; - } - ldir = current.dir; - } while(current.cx != sx || current.cy != sy); - Fv.prev = Cv.prev; - Cv.prev.next = Fv; - } - return Fv; - } - - return { - trace : function(current, color, label, edgelabel) { - return trace(current, color, label, edgelabel); - }, - contourTracing : function(sy, sx, label, color, edgelabel) { - return contourTracing(sy, sx, label, color, edgelabel); - } - }; - } - }; - - return (Tracer); -}); - -/* jshint undef: true, unused: true, browser:true, devel: true */ -/* global define */ - -/** - * http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization - */ -define('rasterizer',["tracer"], function(Tracer) { - - - var Rasterizer = { - createContour2D : function() { - return { - dir : null, - index : null, - firstVertex : null, - insideContours : null, - nextpeer : null, - prevpeer : null - }; - }, - CONTOUR_DIR : { - CW_DIR : 0, - CCW_DIR : 1, - UNKNOWN_DIR : 2 - }, - DIR : { - OUTSIDE_EDGE : -32767, - INSIDE_EDGE : -32766 - }, - create : function(imageWrapper, labelWrapper) { - var imageData = imageWrapper.data, - labelData = labelWrapper.data, - width = imageWrapper.size.x, - height = imageWrapper.size.y, - tracer = Tracer.create(imageWrapper, labelWrapper); - - return { - rasterize : function(depthlabel) { - var color, - bc, - lc, - labelindex, - cx, - cy, - colorMap = [], - vertex, - p, - cc, - sc, - pos, - connectedCount = 0, - i; - - for ( i = 0; i < 400; i++) { - colorMap[i] = 0; - } - - colorMap[0] = imageData[0]; - cc = null; - for ( cy = 1; cy < height - 1; cy++) { - labelindex = 0; - bc = colorMap[0]; - for ( cx = 1; cx < width - 1; cx++) { - pos = cy * width + cx; - if (labelData[pos] === 0) { - color = imageData[pos]; - if (color !== bc) { - if (labelindex === 0) { - lc = connectedCount + 1; - colorMap[lc] = color; - bc = color; - vertex = tracer.contourTracing(cy, cx, lc, color, Rasterizer.DIR.OUTSIDE_EDGE); - if (vertex !== null) { - connectedCount++; - labelindex = lc; - p = Rasterizer.createContour2D(); - p.dir = Rasterizer.CONTOUR_DIR.CW_DIR; - p.index = labelindex; - p.firstVertex = vertex; - p.nextpeer = cc; - p.insideContours = null; - if (cc !== null) { - cc.prevpeer = p; - } - cc = p; - } - } else { - vertex = tracer.contourTracing(cy, cx, Rasterizer.DIR.INSIDE_EDGE, color, labelindex); - if (vertex !== null) { - p = Rasterizer.createContour2D(); - p.firstVertex = vertex; - p.insideContours = null; - if (depthlabel === 0) { - p.dir = Rasterizer.CONTOUR_DIR.CCW_DIR; - } else { - p.dir = Rasterizer.CONTOUR_DIR.CW_DIR; - } - p.index = depthlabel; - sc = cc; - while ((sc !== null) && sc.index !== labelindex) { - sc = sc.nextpeer; - } - if (sc !== null) { - p.nextpeer = sc.insideContours; - if (sc.insideContours !== null) { - sc.insideContours.prevpeer = p; - } - sc.insideContours = p; - } - } - } - } else { - labelData[pos] = labelindex; - } - } else if (labelData[pos] === Rasterizer.DIR.OUTSIDE_EDGE || labelData[pos] === Rasterizer.DIR.INSIDE_EDGE) { - labelindex = 0; - if (labelData[pos] === Rasterizer.DIR.INSIDE_EDGE) { - bc = imageData[pos]; - } else { - bc = colorMap[0]; - } - } else { - labelindex = labelData[pos]; - bc = colorMap[labelindex]; - } - } - } - sc = cc; - while (sc !== null) { - sc.index = depthlabel; - sc = sc.nextpeer; - } - return { - cc : cc, - count : connectedCount - }; - }, - debug: { - drawContour : function(canvas, firstContour) { - var ctx = canvas.getContext("2d"), - pq = firstContour, - iq, - q, - p; - - ctx.strokeStyle = "red"; - ctx.fillStyle = "red"; - ctx.lineWidth = 1; - - if (pq !== null) { - iq = pq.insideContours; - } else { - iq = null; - } - - while (pq !== null) { - if (iq !== null) { - q = iq; - iq = iq.nextpeer; - } else { - q = pq; - pq = pq.nextpeer; - if (pq !== null) { - iq = pq.insideContours; - } else { - iq = null; - } - } - - switch(q.dir) { - case Rasterizer.CONTOUR_DIR.CW_DIR: - ctx.strokeStyle = "red"; - break; - case Rasterizer.CONTOUR_DIR.CCW_DIR: - ctx.strokeStyle = "blue"; - break; - case Rasterizer.CONTOUR_DIR.UNKNOWN_DIR: - ctx.strokeStyle = "green"; - break; - } - - p = q.firstVertex; - ctx.beginPath(); - ctx.moveTo(p.x, p.y); - do { - p = p.next; - ctx.lineTo(p.x, p.y); - } while(p !== q.firstVertex); - ctx.stroke(); - } - } - } - }; - } - }; - - return (Rasterizer); -}); - -/* jshint undef: true, unused: true, browser:true, devel: true, -W041: false */ -/* global define */ - -define('skeletonizer',[],function() { - - - function Skeletonizer(stdlib, foreign, buffer) { - "use asm"; - - var images = new stdlib.Uint8Array(buffer), - size = foreign.size | 0, - imul = stdlib.Math.imul; - - function erode(inImagePtr, outImagePtr) { - inImagePtr = inImagePtr | 0; - outImagePtr = outImagePtr | 0; - - var v = 0, - u = 0, - sum = 0, - yStart1 = 0, - yStart2 = 0, - xStart1 = 0, - xStart2 = 0, - offset = 0; - - for ( v = 1; (v | 0) < ((size - 1) | 0); v = (v + 1) | 0) { - offset = (offset + size) | 0; - for ( u = 1; (u | 0) < ((size - 1) | 0); u = (u + 1) | 0) { - yStart1 = (offset - size) | 0; - yStart2 = (offset + size) | 0; - xStart1 = (u - 1) | 0; - xStart2 = (u + 1) | 0; - sum = ((images[(inImagePtr + yStart1 + xStart1) | 0] | 0) + (images[(inImagePtr + yStart1 + xStart2) | 0] | 0) + (images[(inImagePtr + offset + u) | 0] | 0) + (images[(inImagePtr + yStart2 + xStart1) | 0] | 0) + (images[(inImagePtr + yStart2 + xStart2) | 0] | 0)) | 0; - if ((sum | 0) == (5 | 0)) { - images[(outImagePtr + offset + u) | 0] = 1; - } else { - images[(outImagePtr + offset + u) | 0] = 0; - } - } - } - return; - } - - function subtract(aImagePtr, bImagePtr, outImagePtr) { - aImagePtr = aImagePtr | 0; - bImagePtr = bImagePtr | 0; - outImagePtr = outImagePtr | 0; - - var length = 0; - - length = imul(size, size) | 0; - - while ((length | 0) > 0) { - length = (length - 1) | 0; - images[(outImagePtr + length) | 0] = ((images[(aImagePtr + length) | 0] | 0) - (images[(bImagePtr + length) | 0] | 0)) | 0; - } - } - - function bitwiseOr(aImagePtr, bImagePtr, outImagePtr) { - aImagePtr = aImagePtr | 0; - bImagePtr = bImagePtr | 0; - outImagePtr = outImagePtr | 0; - - var length = 0; - - length = imul(size, size) | 0; - - while ((length | 0) > 0) { - length = (length - 1) | 0; - images[(outImagePtr + length) | 0] = ((images[(aImagePtr + length) | 0] | 0) | (images[(bImagePtr + length) | 0] | 0)) | 0; - } - } - - function countNonZero(imagePtr) { - imagePtr = imagePtr | 0; - - var sum = 0, - length = 0; - - length = imul(size, size) | 0; - - while ((length | 0) > 0) { - length = (length - 1) | 0; - sum = ((sum | 0) + (images[(imagePtr + length) | 0] | 0)) | 0; - } - - return (sum | 0); - } - - function init(imagePtr, value) { - imagePtr = imagePtr | 0; - value = value | 0; - - var length = 0; - - length = imul(size, size) | 0; - - while ((length | 0) > 0) { - length = (length - 1) | 0; - images[(imagePtr + length) | 0] = value; - } - } - - function dilate(inImagePtr, outImagePtr) { - inImagePtr = inImagePtr | 0; - outImagePtr = outImagePtr | 0; - - var v = 0, - u = 0, - sum = 0, - yStart1 = 0, - yStart2 = 0, - xStart1 = 0, - xStart2 = 0, - offset = 0; - - for ( v = 1; (v | 0) < ((size - 1) | 0); v = (v + 1) | 0) { - offset = (offset + size) | 0; - for ( u = 1; (u | 0) < ((size - 1) | 0); u = (u + 1) | 0) { - yStart1 = (offset - size) | 0; - yStart2 = (offset + size) | 0; - xStart1 = (u - 1) | 0; - xStart2 = (u + 1) | 0; - sum = ((images[(inImagePtr + yStart1 + xStart1) | 0] | 0) + (images[(inImagePtr + yStart1 + xStart2) | 0] | 0) + (images[(inImagePtr + offset + u) | 0] | 0) + (images[(inImagePtr + yStart2 + xStart1) | 0] | 0) + (images[(inImagePtr + yStart2 + xStart2) | 0] | 0)) | 0; - if ((sum | 0) > (0 | 0)) { - images[(outImagePtr + offset + u) | 0] = 1; - } else { - images[(outImagePtr + offset + u) | 0] = 0; - } - } - } - return; - } - - function memcpy(srcImagePtr, dstImagePtr) { - srcImagePtr = srcImagePtr | 0; - dstImagePtr = dstImagePtr | 0; - - var length = 0; - - length = imul(size, size) | 0; - - while ((length | 0) > 0) { - length = (length - 1) | 0; - images[(dstImagePtr + length) | 0] = (images[(srcImagePtr + length) | 0] | 0); - } - } - - function zeroBorder(imagePtr) { - imagePtr = imagePtr | 0; - - var x = 0, - y = 0; - - for ( x = 0; (x | 0) < ((size - 1) | 0); x = (x + 1) | 0) { - images[(imagePtr + x) | 0] = 0; - images[(imagePtr + y) | 0] = 0; - y = ((y + size) - 1) | 0; - images[(imagePtr + y) | 0] = 0; - y = (y + 1) | 0; - } - for ( x = 0; (x | 0) < (size | 0); x = (x + 1) | 0) { - images[(imagePtr + y) | 0] = 0; - y = (y + 1) | 0; - } - } - - function skeletonize() { - var subImagePtr = 0, - erodedImagePtr = 0, - tempImagePtr = 0, - skelImagePtr = 0, - sum = 0, - done = 0; - - erodedImagePtr = imul(size, size) | 0; - tempImagePtr = (erodedImagePtr + erodedImagePtr) | 0; - skelImagePtr = (tempImagePtr + erodedImagePtr) | 0; - - // init skel-image - init(skelImagePtr, 0); - zeroBorder(subImagePtr); - - do { - erode(subImagePtr, erodedImagePtr); - dilate(erodedImagePtr, tempImagePtr); - subtract(subImagePtr, tempImagePtr, tempImagePtr); - bitwiseOr(skelImagePtr, tempImagePtr, skelImagePtr); - memcpy(erodedImagePtr, subImagePtr); - sum = countNonZero(subImagePtr) | 0; - done = ((sum | 0) == 0 | 0); - } while(!done); - } - - return { - skeletonize : skeletonize - }; - } - - return Skeletonizer; -}); - -/* jshint undef: true, unused: true, browser:true, devel: true */ -/* global define */ - -define('image_debug',[],function() { - - - return { - drawRect: function(pos, size, ctx, style){ - ctx.strokeStyle = style.color; - ctx.fillStyle = style.color; - ctx.lineWidth = 1; - ctx.beginPath(); - ctx.strokeRect(pos.x, pos.y, size.x, size.y); - }, - drawPath: function(path, def, ctx, style) { - ctx.strokeStyle = style.color; - ctx.fillStyle = style.color; - ctx.lineWidth = style.lineWidth; - ctx.beginPath(); - ctx.moveTo(path[0][def.x], path[0][def.y]); - for (var j = 1; j < path.length; j++) { - ctx.lineTo(path[j][def.x], path[j][def.y]); - } - ctx.closePath(); - ctx.stroke(); - } - }; - -}); - -/* jshint undef: true, unused: true, browser:true, devel: true */ -/* global define, mat2, vec2 */ - -define('barcode_locator',["image_wrapper", "cv_utils", "rasterizer", "tracer", "skeletonizer", "array_helper", "image_debug"], -function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, ImageDebug) { - - - var _config, - _currentImageWrapper, - _skelImageWrapper, - _subImageWrapper, - _labelImageWrapper, - _patchGrid, - _patchLabelGrid, - _imageToPatchGrid, - _binaryImageWrapper, - _patchSize, - _canvasContainer = { - ctx : { - binary : null - }, - dom : { - binary : null - } - }, - _numPatches = {x: 0, y: 0}, - _inputImageWrapper, - _skeletonizer, - self = this, - _worker, - _locatedCb, - _initialized; - - function initBuffers() { - var skeletonImageData; - - if (_config.halfSample) { - _currentImageWrapper = new ImageWrapper({ - x : _inputImageWrapper.size.x / 2 | 0, - y : _inputImageWrapper.size.y / 2 | 0 - }); - } else { - _currentImageWrapper = _inputImageWrapper; - } - - _patchSize = { - x : 16 * ( _config.halfSample ? 1 : 2), - y : 16 * ( _config.halfSample ? 1 : 2) - }; - - _numPatches.x = _currentImageWrapper.size.x / _patchSize.x | 0; - _numPatches.y = _currentImageWrapper.size.y / _patchSize.y | 0; - - _binaryImageWrapper = new ImageWrapper(_currentImageWrapper.size, undefined, Uint8Array, false); - - _labelImageWrapper = new ImageWrapper(_patchSize, undefined, Array, true); - - skeletonImageData = new ArrayBuffer(64*1024); - _subImageWrapper = new ImageWrapper(_patchSize, new Uint8Array(skeletonImageData, 0, _patchSize.x * _patchSize.y)); - _skelImageWrapper = new ImageWrapper(_patchSize, new Uint8Array(skeletonImageData, _patchSize.x * _patchSize.y * 3, _patchSize.x * _patchSize.y), undefined, true); - _skeletonizer = skeletonizer(self, { - size : _patchSize.x - }, skeletonImageData); - - _imageToPatchGrid = new ImageWrapper({ - x : (_currentImageWrapper.size.x / _subImageWrapper.size.x) | 0, - y : (_currentImageWrapper.size.y / _subImageWrapper.size.y) | 0 - }, undefined, Array, true); - _patchGrid = new ImageWrapper(_imageToPatchGrid.size, undefined, undefined, true); - _patchLabelGrid = new ImageWrapper(_imageToPatchGrid.size, undefined, Int32Array, true); - } - - function initCanvas() { - if (_config.useWorker || typeof document === 'undefined') { - return; - } - _canvasContainer.dom.binary = document.createElement("canvas"); - _canvasContainer.dom.binary.className = "binaryBuffer"; - if (_config.showCanvas === true) { - document.querySelector("#debug").appendChild(_canvasContainer.dom.binary); - } - _canvasContainer.ctx.binary = _canvasContainer.dom.binary.getContext("2d"); - _canvasContainer.dom.binary.width = _binaryImageWrapper.size.x; - _canvasContainer.dom.binary.height = _binaryImageWrapper.size.y; - } - - /** - * Creates a bounding box which encloses all the given patches - * @returns {Array} The minimal bounding box - */ - function boxFromPatches(patches) { - var overAvg, i, j, patch, transMat, minx = _binaryImageWrapper.size.x, miny = _binaryImageWrapper.size.y, maxx = -_binaryImageWrapper.size.x, maxy = -_binaryImageWrapper.size.y, box, scale; - - // draw all patches which are to be taken into consideration - overAvg = 0; - for ( i = 0; i < patches.length; i++) { - patch = patches[i]; - overAvg += patch.rad; - if (_config.showPatches) { - ImageDebug.drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary, {color: "red"}); - } - } - - overAvg /= patches.length; - overAvg = (overAvg * 180 / Math.PI + 90) % 180 - 90; - if (overAvg < 0) { - overAvg += 180; - } - - //console.log(overAvg); - overAvg = (180 - overAvg) * Math.PI / 180; - transMat = mat2.create([Math.cos(overAvg), -Math.sin(overAvg), Math.sin(overAvg), Math.cos(overAvg)]); - - // iterate over patches and rotate by angle - for ( i = 0; i < patches.length; i++) { - patch = patches[i]; - for ( j = 0; j < 4; j++) { - mat2.xVec2(transMat, patch.box[j]); - } - - if (_config.boxFromPatches.showTransformed) { - ImageDebug.drawPath(patch.box, {x: 0, y: 1}, _canvasContainer.ctx.binary, {color: '#99ff00', lineWidth: 2}); - } - } - - // find bounding box - for ( i = 0; i < patches.length; i++) { - patch = patches[i]; - for ( j = 0; j < 4; j++) { - if (patch.box[j][0] < minx) { - minx = patch.box[j][0]; - } - if (patch.box[j][0] > maxx) { - maxx = patch.box[j][0]; - } - if (patch.box[j][1] < miny) { - miny = patch.box[j][1]; - } - if (patch.box[j][1] > maxy) { - maxy = patch.box[j][1]; - } - } - } - - box = [[minx, miny], [maxx, miny], [maxx, maxy], [minx, maxy]]; - - if (_config.boxFromPatches.showTransformedBox) { - ImageDebug.drawPath(box, {x: 0, y: 1}, _canvasContainer.ctx.binary, {color: '#ff0000', lineWidth: 2}); - } - - scale = _config.halfSample ? 2 : 1; - // reverse rotation; - transMat = mat2.inverse(transMat); - for ( j = 0; j < 4; j++) { - mat2.xVec2(transMat, box[j]); - } - - if (_config.boxFromPatches.showBB) { - ImageDebug.drawPath(box, {x: 0, y: 1}, _canvasContainer.ctx.binary, {color: '#ff0000', lineWidth: 2}); - } - - for ( j = 0; j < 4; j++) { - vec2.scale(box[j], scale); - } - - return box; - } - - /** - * Creates a binary image of the current image - */ - function binarizeImage() { - CVUtils.otsuThreshold(_currentImageWrapper, _binaryImageWrapper); - _binaryImageWrapper.zeroBorder(); - if (_config.showCanvas) { - _binaryImageWrapper.show(_canvasContainer.dom.binary, 255); - } - } - - /** - * Iterate over the entire image - * extract patches - */ - function findPatches() { - var i, - j, - x, - y, - moments, - patchesFound = [], - rasterizer, - rasterResult, - patch; - for ( i = 0; i < _numPatches.x; i++) { - for ( j = 0; j < _numPatches.y; j++) { - - x = _subImageWrapper.size.x * i; - y = _subImageWrapper.size.y * j; - - // seperate parts - skeletonize(x, y); - - // Rasterize, find individual bars - _skelImageWrapper.zeroBorder(); - ArrayHelper.init(_labelImageWrapper.data, 0); - rasterizer = Rasterizer.create(_skelImageWrapper, _labelImageWrapper); - rasterResult = rasterizer.rasterize(0); - - if (_config.showLabels) { - _labelImageWrapper.overlay(_canvasContainer.dom.binary, Math.floor(360 / rasterResult.count), {x : x, y : y}); - } - - // calculate moments from the skeletonized patch - moments = _labelImageWrapper.moments(rasterResult.count); - - // extract eligible patches - patchesFound = patchesFound.concat(describePatch(moments, [i, j], x, y)); - } - } - - if (_config.showFoundPatches) { - for ( i = 0; i < patchesFound.length; i++) { - patch = patchesFound[i]; - ImageDebug.drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary, {color: "#99ff00", lineWidth: 2}); - } - } - - return patchesFound; - } - - /** - * Finds those connected areas which contain at least 6 patches - * and returns them ordered DESC by the number of contained patches - * @param {Number} maxLabel - */ - function findBiggestConnectedAreas(maxLabel){ - var i, - sum, - labelHist = [], - topLabels = []; - - for ( i = 0; i < maxLabel; i++) { - labelHist.push(0); - } - sum = _patchLabelGrid.data.length; - while (sum--) { - if (_patchLabelGrid.data[sum] > 0) { - labelHist[_patchLabelGrid.data[sum] - 1]++; - } - } - - labelHist = labelHist.map(function(val, idx) { - return { - val : val, - label : idx + 1 - }; - }); - - labelHist.sort(function(a, b) { - return b.val - a.val; - }); - - // extract top areas with at least 6 patches present - topLabels = labelHist.filter(function(el) { - return el.val >= 5; - }); - - return topLabels; - } - - /** - * - */ - function findBoxes(topLabels, maxLabel) { - var i, - j, - sum, - patches = [], - patch, - box, - boxes = [], - hsv = [0, 1, 1], - rgb = [0, 0, 0]; - - for ( i = 0; i < topLabels.length; i++) { - sum = _patchLabelGrid.data.length; - patches.length = 0; - while (sum--) { - if (_patchLabelGrid.data[sum] === topLabels[i].label) { - patch = _imageToPatchGrid.data[sum]; - patches.push(patch); - } - } - box = boxFromPatches(patches); - if (box) { - boxes.push(box); - - // draw patch-labels if requested - if (_config.showRemainingPatchLabels) { - for ( j = 0; j < patches.length; j++) { - patch = patches[j]; - hsv[0] = (topLabels[i].label / (maxLabel + 1)) * 360; - CVUtils.hsv2rgb(hsv, rgb); - ImageDebug.drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary, {color: "rgb(" + rgb.join(",") + ")", lineWidth: 2}); - } - } - } - } - return boxes; - } - - /** - * Find similar moments (via cluster) - * @param {Object} moments - */ - function similarMoments(moments) { - var clusters = CVUtils.cluster(moments, 0.90); - var topCluster = CVUtils.topGeneric(clusters, 1, function(e) { - return e.getPoints().length; - }); - var points = [], result = []; - if (topCluster.length === 1) { - points = topCluster[0].item.getPoints(); - for (var i = 0; i < points.length; i++) { - result.push(points[i].point); - } - } - return result; - } - - function skeletonize(x, y) { - _binaryImageWrapper.subImageAsCopy(_subImageWrapper, CVUtils.imageRef(x, y)); - _skeletonizer.skeletonize(); - - // Show skeleton if requested - if (_config.showSkeleton) { - _skelImageWrapper.overlay(_canvasContainer.dom.binary, 360, CVUtils.imageRef(x, y)); - } - } - - /** - * Extracts and describes those patches which seem to contain a barcode pattern - * @param {Array} moments - * @param {Object} patchPos, - * @param {Number} x - * @param {Number} y - * @returns {Array} list of patches - */ - function describePatch(moments, patchPos, x, y) { - var k, avg, sum = 0, eligibleMoments = [], matchingMoments, patch, patchesFound = []; - if (moments.length >= 2) { - // only collect moments which's area covers at least 6 pixels. - for ( k = 0; k < moments.length; k++) { - if (moments[k].m00 > 6) { - eligibleMoments.push(moments[k]); - } - } - - // if at least 2 moments are found which have 6pixels covered - if (eligibleMoments.length >= 2) { - sum = eligibleMoments.length; - matchingMoments = similarMoments(eligibleMoments); - avg = 0; - // determine the similarity of the moments - for ( k = 0; k < matchingMoments.length; k++) { - avg += matchingMoments[k].rad; - } - - // Only two of the moments are allowed not to fit into the equation - // add the patch to the set - if (matchingMoments.length > 1 && matchingMoments.length >= (eligibleMoments.length / 4) * 3 && matchingMoments.length > moments.length / 4) { - avg /= matchingMoments.length; - patch = { - index : patchPos[1] * _numPatches.x + patchPos[0], - pos : { - x : x, - y : y - }, - box : [vec2.create([x, y]), vec2.create([x + _subImageWrapper.size.x, y]), vec2.create([x + _subImageWrapper.size.x, y + _subImageWrapper.size.y]), vec2.create([x, y + _subImageWrapper.size.y])], - moments : matchingMoments, - rad : avg, - vec : vec2.create([Math.cos(avg), Math.sin(avg)]) - }; - patchesFound.push(patch); - } - } - } - return patchesFound; - } - - /** - * finds patches which are connected and share the same orientation - * @param {Object} patchesFound - */ - function rasterizeAngularSimilarity(patchesFound) { - var label = 0, - threshold = 0.95, - currIdx = 0, - j, - patch, - hsv = [0, 1, 1], - rgb = [0, 0, 0]; - - function notYetProcessed() { - var i; - for ( i = 0; i < _patchLabelGrid.data.length; i++) { - if (_patchLabelGrid.data[i] === 0 && _patchGrid.data[i] === 1) { - return i; - } - } - return _patchLabelGrid.length; - } - - function trace(currentIdx) { - var x, y, currentPatch, patch, idx, dir, current = { - x : currentIdx % _patchLabelGrid.size.x, - y : (currentIdx / _patchLabelGrid.size.x) | 0 - }, similarity; - - if (currentIdx < _patchLabelGrid.data.length) { - currentPatch = _imageToPatchGrid.data[currentIdx]; - // assign label - _patchLabelGrid.data[currentIdx] = label; - for ( dir = 0; dir < Tracer.searchDirections.length; dir++) { - y = current.y + Tracer.searchDirections[dir][0]; - x = current.x + Tracer.searchDirections[dir][1]; - idx = y * _patchLabelGrid.size.x + x; - - // continue if patch empty - if (_patchGrid.data[idx] === 0) { - _patchLabelGrid.data[idx] = Number.MAX_VALUE; - continue; - } - - patch = _imageToPatchGrid.data[idx]; - if (_patchLabelGrid.data[idx] === 0) { - similarity = Math.abs(vec2.dot(patch.vec, currentPatch.vec)); - if (similarity > threshold) { - trace(idx); - } - } - } - } - } - - // prepare for finding the right patches - ArrayHelper.init(_patchGrid.data, 0); - ArrayHelper.init(_patchLabelGrid.data, 0); - ArrayHelper.init(_imageToPatchGrid.data, null); - - for ( j = 0; j < patchesFound.length; j++) { - patch = patchesFound[j]; - _imageToPatchGrid.data[patch.index] = patch; - _patchGrid.data[patch.index] = 1; - } - - // rasterize the patches found to determine area - _patchGrid.zeroBorder(); - - while (( currIdx = notYetProcessed()) < _patchLabelGrid.data.length) { - label++; - trace(currIdx); - } - - // draw patch-labels if requested - if (_config.showPatchLabels) { - for ( j = 0; j < _patchLabelGrid.data.length; j++) { - if (_patchLabelGrid.data[j] > 0 && _patchLabelGrid.data[j] <= label) { - patch = _imageToPatchGrid.data[j]; - hsv[0] = (_patchLabelGrid.data[j] / (label + 1)) * 360; - CVUtils.hsv2rgb(hsv, rgb); - ImageDebug.drawRect(patch.pos, _subImageWrapper.size, _canvasContainer.ctx.binary, {color: "rgb(" + rgb.join(",") + ")", lineWidth: 2}); - } - } - } - - return label; - } - - function initWorker(cb) { - var tmpData; - - _worker = new Worker('../src/worker_locator.js'); - tmpData = _inputImageWrapper.data; - _inputImageWrapper.data = null; // do not send the data along - _worker.postMessage({cmd: 'init', inputImageWrapper: _inputImageWrapper, config: _config}); - _inputImageWrapper.data = tmpData; - _worker.onmessage = function(e) { - if (e.data.event === 'initialized') { - _initialized = true; - cb(); - } else if (e.data.event === 'located') { - _inputImageWrapper.data = new Uint8Array(e.data.buffer); - _locatedCb(e.data.result); - } - }; - } - - return { - init : function(inputImageWrapper, config, cb) { - _config = config; - _inputImageWrapper = inputImageWrapper; - - // 1. check config for web-worker - if (_config.useWorker) { - initWorker(cb); - } else { - initBuffers(); - initCanvas(); - cb(); - } - }, - locate : function(cb) { - var patchesFound, - topLabels = [], - boxes = []; - - if (_config.useWorker) { - _locatedCb = cb; - _worker.postMessage({cmd: 'locate', buffer: _inputImageWrapper.data}, [_inputImageWrapper.data.buffer]); - } else { - if (_config.halfSample) { - CVUtils.halfSample(_inputImageWrapper, _currentImageWrapper); - } - - binarizeImage(); - patchesFound = findPatches(); - // return unless 5% or more patches are found - if (patchesFound.length < _numPatches.x * _numPatches.y * 0.05) { - return cb(null); - } - - // rasterrize area by comparing angular similarity; - var maxLabel = rasterizeAngularSimilarity(patchesFound); - if (maxLabel <= 1) { - return cb(null); - } - - // search for area with the most patches (biggest connected area) - topLabels = findBiggestConnectedAreas(maxLabel); - if (topLabels.length === 0) { - return cb(null); - } - - boxes = findBoxes(topLabels, maxLabel); - cb(boxes); - } - } - }; -}); - - - return require('barcode_locator'); -})); \ No newline at end of file diff --git a/dist/quagga.js b/dist/quagga.js index 964aa47..30a3d7f 100644 --- a/dist/quagga.js +++ b/dist/quagga.js @@ -6173,9 +6173,13 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I } function initWorker(cb) { - var tmpData; + var tmpData, + blobURL; + + blobURL = generateWorkerBlob(); + _worker = new Worker(blobURL); + URL.revokeObjectURL(blobURL); - _worker = new Worker('../src/worker_locator.js'); tmpData = _inputImageWrapper.data; _inputImageWrapper.data = null; // do not send the data along _worker.postMessage({cmd: 'init', inputImageWrapper: _inputImageWrapper, config: _config}); @@ -6191,6 +6195,50 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I }; } + function generateWorkerBlob() { + var blob, + quaggaAbsoluteUrl, + scripts = document.getElementsByTagName('script'), + regex = new RegExp('\/' + _config.scriptName + '$'); + + quaggaAbsoluteUrl = Array.prototype.slice.apply(scripts).filter(function(script) { + return script.src && script.src.match(regex); + }).map(function(script) { + return script.src; + })[0]; + + /* jshint ignore:start */ + blob = new Blob(['(' + + (function(scriptUrl){ + importScripts(scriptUrl); + var inputImageWrapper, + config, + Locator = Quagga.Locator; + + self.onmessage = function(e) { + if (e.data.cmd === 'init') { + inputImageWrapper = e.data.inputImageWrapper; + config = e.data.config; + + config.useWorker = false; + Locator.init(inputImageWrapper, config, function() { + self.postMessage({'event': 'initialized'}); + }); + } else if (e.data.cmd === 'locate') { + inputImageWrapper.data = new Uint8Array(e.data.buffer); + Locator.locate(function(result) { + self.postMessage({'event': 'located', result: result, buffer : inputImageWrapper.data}, [inputImageWrapper.data.buffer]); + }); + } + }; + }).toString() + ')("' + quaggaAbsoluteUrl + '");' + ], {type : 'text/javascript'}); + + /* jshint ignore:end */ + return window.URL.createObjectURL(blob); + } + + return { init : function(inputImageWrapper, config, cb) { _config = config; @@ -6859,6 +6907,7 @@ define('config',[],function(){ locator: { halfSample: true, useWorker: true, + scriptName: 'quagga.js', showCanvas: false, showPatches: false, showFoundPatches: false, @@ -7296,7 +7345,8 @@ function(Code128Reader, EANReader, InputStream, ImageWrapper, BarcodeLocator, Ba Reader: { EANReader : EANReader, Code128Reader : Code128Reader - } + }, + Locator: BarcodeLocator }; }); diff --git a/dist/quagga.min.js b/dist/quagga.min.js deleted file mode 100644 index cfa4b2f..0000000 --- a/dist/quagga.min.js +++ /dev/null @@ -1,3 +0,0 @@ -/*! quagga 2014-12-19 */ -!function(a,b){"function"==typeof define&&define.amd?define([],b):a.Quagga=b()}(this,function(){var a,b,c;!function(d){function e(a,b){return u.call(a,b)}function f(a,b){var c,d,e,f,g,h,i,j,k,l,m,n=b&&b.split("/"),o=s.map,p=o&&o["*"]||{};if(a&&"."===a.charAt(0))if(b){for(n=n.slice(0,n.length-1),a=a.split("/"),g=a.length-1,s.nodeIdCompat&&w.test(a[g])&&(a[g]=a[g].replace(w,"")),a=n.concat(a),k=0;k0&&(a.splice(k-1,2),k-=2)}a=a.join("/")}else 0===a.indexOf("./")&&(a=a.substring(2));if((n||p)&&o){for(c=a.split("/"),k=c.length;k>0;k-=1){if(d=c.slice(0,k).join("/"),n)for(l=n.length;l>0;l-=1)if(e=o[n.slice(0,l).join("/")],e&&(e=e[d])){f=e,h=k;break}if(f)break;!i&&p&&p[d]&&(i=p[d],j=k)}!f&&i&&(f=i,h=j),f&&(c.splice(0,h,f),a=c.join("/"))}return a}function g(a,b){return function(){return n.apply(d,v.call(arguments,0).concat([a,b]))}}function h(a){return function(b){return f(b,a)}}function i(a){return function(b){q[a]=b}}function j(a){if(e(r,a)){var b=r[a];delete r[a],t[a]=!0,m.apply(d,b)}if(!e(q,a)&&!e(t,a))throw new Error("No "+a);return q[a]}function k(a){var b,c=a?a.indexOf("!"):-1;return c>-1&&(b=a.substring(0,c),a=a.substring(c+1,a.length)),[b,a]}function l(a){return function(){return s&&s.config&&s.config[a]||{}}}var m,n,o,p,q={},r={},s={},t={},u=Object.prototype.hasOwnProperty,v=[].slice,w=/\.js$/;o=function(a,b){var c,d=k(a),e=d[0];return a=d[1],e&&(e=f(e,b),c=j(e)),e?a=c&&c.normalize?c.normalize(a,h(b)):f(a,b):(a=f(a,b),d=k(a),e=d[0],a=d[1],e&&(c=j(e))),{f:e?e+"!"+a:a,n:a,pr:e,p:c}},p={require:function(a){return g(a)},exports:function(a){var b=q[a];return"undefined"!=typeof b?b:q[a]={}},module:function(a){return{id:a,uri:"",exports:q[a],config:l(a)}}},m=function(a,b,c,f){var h,k,l,m,n,s,u=[],v=typeof c;if(f=f||a,"undefined"===v||"function"===v){for(b=!b.length&&c.length?["require","exports","module"]:b,n=0;n1)for(c=0;cd?(j.start=c-g,j.end=c,j.counter=e,j):null;i++,e[i]=1,h=!h}}else for(e.push(0),c=g;cb)return k.error=b,k.start=a-d,k.end=a,k;for(c=0;5>c;c++)f[c]=f[c+2];f[5]=0,f[6]=0,j--}else j++;f[j]=1,i=!i}return null},b.prototype._findStart=function(){var a,b,c,d,e,f,g=[0,0,0,0,0,0],h=this,i=h._nextSet(h._row),j=!1,k=0,l={error:Number.MAX_VALUE,code:-1,start:0,end:0};for(a=i;ad;d++)g[d]=g[d+2];g[4]=0,g[5]=0,k--}else k++;g[k]=1,j=!j}return null},b.prototype._decode=function(){var a,b,c,d=this,e=d._findStart(),f=null,g=!1,h=[],i=0,j=0,k=[],l=[],m=!1;if(null===e)return null;switch(f={code:e.code,start:e.start,end:e.end},l.push(f),j=f.code,f.code){case d.START_CODE_A:a=d.CODE_A;break;case d.START_CODE_B:a=d.CODE_B;break;case d.START_CODE_C:a=d.CODE_C;break;default:return null}for(;!g;){if(b=m,m=!1,f=d._decodeCode(f.end),null!==f)switch(f.code!==d.STOP_CODE&&(k.push(f.code),i++,j+=i*f.code),l.push(f),a){case d.CODE_A:if(f.code<64)h.push(String.fromCharCode(32+f.code));else if(f.code<96)h.push(String.fromCharCode(f.code-64));else switch(f.code){case d.CODE_SHIFT:m=!0,a=d.CODE_B;break;case d.CODE_B:a=d.CODE_B;break;case d.CODE_C:a=d.CODE_C;break;case d.STOP_CODE:g=!0}break;case d.CODE_B:if(f.code<96)h.push(String.fromCharCode(32+f.code));else switch(f.code!=d.STOP_CODE&&(c=!1),f.code){case d.CODE_SHIFT:m=!0,a=d.CODE_A;break;case d.CODE_A:a=d.CODE_A;break;case d.CODE_C:a=d.CODE_C;break;case d.STOP_CODE:g=!0}break;case d.CODE_C:switch(f.code<100&&h.push(f.code<10?"0"+f.code:f.code),f.code){case d.CODE_A:a=d.CODE_A;break;case d.CODE_B:a=d.CODE_B;break;case d.STOP_CODE:g=!0}}else g=!0;b&&(a=a==d.CODE_A?d.CODE_B:d.CODE_A)}return null===f?null:(f.end=d._nextUnset(d._row,f.end),f.end===d._row.length?null:(j-=i*k[k.length-1],j%103!=k[k.length-1]?null:(h.splice(h.length-1,1),{code:h.join(""),start:e.start,end:f.end,codeset:a,startInfo:e,decodedCodes:l,endInfo:f})))},b}),c("ean_reader",["./barcode_reader"],function(a){function b(){a.call(this)}var c={CODE_L_START:{value:0},MODULO:{value:7},CODE_G_START:{value:10},START_PATTERN:{value:[1/3*7,1/3*7,1/3*7]},STOP_PATTERN:{value:[1/3*7,1/3*7,1/3*7]},MIDDLE_PATTERN:{value:[.2*7,.2*7,.2*7,.2*7,.2*7]},CODE_PATTERN:{value:[[3,2,1,1],[2,2,2,1],[2,1,2,2],[1,4,1,1],[1,1,3,2],[1,2,3,1],[1,1,1,4],[1,3,1,2],[1,2,1,3],[3,1,1,2],[1,1,2,3],[1,2,2,2],[2,2,1,2],[1,1,4,1],[2,3,1,1],[1,3,2,1],[4,1,1,1],[2,1,3,1],[3,1,2,1],[2,1,1,3]]},CODE_FREQUENCY:{value:[0,11,13,14,19,25,28,21,22,26]}};return b.prototype=Object.create(a.prototype,c),b.prototype.constructor=b,b.prototype._decodeCode=function(b,c){var d,e,f,g,h=[0,0,0,0],i=this,j=b,k=!i._row[j],l=0,m={error:Number.MAX_VALUE,code:-1,start:b,end:b};for(c||(c=i.CODE_PATTERN.length),d=j;de;e++)f=i._matchPattern(g,i.CODE_PATTERN[e]),fh)return o.error=h,o.start=g-j,o.end=g,o;if(!e)throw a.PatternNotFoundException;for(i=0;ib;b++)d=c._decodeCode(d.end),d.code>=c.CODE_G_START?(d.code=d.code-c.CODE_G_START,f|=1<<5-b):f|=0<<5-b,e.push(d.code),g.push(d);for(b=0;bb;b++)d=c._decodeCode(d.end,c.CODE_G_START),g.push(d),e.push(d.code);if(d=c._findPattern(c.STOP_PATTERN,d.end),g.push(d),!c._checksum(e))return null}catch(h){return null}return{code:e.join(""),start:a.start,end:d.end,codeset:"",startInfo:a,decodedCodes:g}},b.prototype._checksum=function(a){var b,c=0;for(b=a.length-2;b>=0;b-=2)c+=a[b];for(c*=3,b=a.length-1;b>=0;b-=2)c+=a[b];return c%10===0},b}),c("image_loader",[],function(){function a(a,b){a.onload=function(){b.loaded(this)}}var b={};return b.load=function(b,c,d,e,f){var g,h,i,j=new Array(e),k=new Array(j.length);if(f===!1)j[0]=b;else for(g=0;g0)for(d=0;d0)for(c=0;c1?e.size:f/g*e.size:f},d.getHeight=function(){return e.size?f/g>1?g/f*e.size:e.size:g},d.getRealWidth=function(){return f},d.getRealHeight=function(){return g},d.setInputStream=function(a){e=a,a.sequence===!1?(n=a.src,l=1):(n=a.src,l=a.length),b()},d.ended=function(){return o},d.setAttribute=function(){},d.getConfig=function(){return e},d.pause=function(){i=!0},d.play=function(){i=!1},d.setCurrentTime=function(a){h=a},d.addEventListener=function(a,b){-1!==p.indexOf(a)&&(q[a]||(q[a]=[]),q[a].push(b))},d.getFrame=function(){var a;return j?(i||(a=k[h],l-1>h?h++:setTimeout(function(){o=!0,c("ended",[])},0)),a):null},d},b}),glMatrixArrayType=Float32Array,window.requestAnimFrame=function(){return window.requestAnimationFrame||window.webkitRequestAnimationFrame||window.mozRequestAnimationFrame||window.oRequestAnimationFrame||window.msRequestAnimationFrame||function(a){window.setTimeout(a,1e3/60)}}(),navigator.getUserMedia=navigator.getUserMedia||navigator.webkitGetUserMedia||navigator.mozGetUserMedia||navigator.msGetUserMedia,window.URL=window.URL||window.webkitURL||window.mozURL||window.msURL,c("typedefs",function(a){return function(){var b;return b||a.typedefs}}(this)),c("subImage",["typedefs"],function(){function a(a,b,c){c||(c={data:null,size:b}),this.data=c.data,this.originalSize=c.size,this.I=c,this.from=a,this.size=b}return a.prototype.show=function(a,b){var c,d,e,f,g,h,i;for(b||(b=1),c=a.getContext("2d"),a.width=this.size.x,a.height=this.size.y,d=c.getImageData(0,0,a.width,a.height),e=d.data,f=0,g=0;gb?!0:!1},getPoints:function(){return f},getCenter:function(){return g}}},createPoint:function(a,b,c){return{rad:a[c],point:a,id:b}}};return a});var d={};d.create=function(a){var b;return a?(b=new glMatrixArrayType(3),b[0]=a[0],b[1]=a[1],b[2]=a[2]):b=new glMatrixArrayType(glMatrixArrayType===Array?[0,0,0]:3),b},d.set=function(a,b){return b[0]=a[0],b[1]=a[1],b[2]=a[2],b},d.add=function(a,b,c){return c&&a!=c?(c[0]=a[0]+b[0],c[1]=a[1]+b[1],c[2]=a[2]+b[2],c):(a[0]+=b[0],a[1]+=b[1],a[2]+=b[2],a)},d.subtract=function(a,b,c){return c&&a!=c?(c[0]=a[0]-b[0],c[1]=a[1]-b[1],c[2]=a[2]-b[2],c):(a[0]-=b[0],a[1]-=b[1],a[2]-=b[2],a)},d.negate=function(a,b){return b||(b=a),b[0]=-a[0],b[1]=-a[1],b[2]=-a[2],b},d.scale=function(a,b,c){return c&&a!=c?(c[0]=a[0]*b,c[1]=a[1]*b,c[2]=a[2]*b,c):(a[0]*=b,a[1]*=b,a[2]*=b,a)},d.normalize=function(a,b){b||(b=a);var c=a[0],d=a[1],e=a[2],f=Math.sqrt(c*c+d*d+e*e);return f?1==f?(b[0]=c,b[1]=d,b[2]=e,b):(f=1/f,b[0]=c*f,b[1]=d*f,b[2]=e*f,b):(b[0]=0,b[1]=0,b[2]=0,b)},d.cross=function(a,b,c){c||(c=a);var d=a[0],e=a[1],f=a[2],g=b[0],h=b[1],i=b[2];return c[0]=e*i-f*h,c[1]=f*g-d*i,c[2]=d*h-e*g,c},d.length=function(a){var b=a[0],c=a[1],d=a[2];return Math.sqrt(b*b+c*c+d*d)},d.dot=function(a,b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2]},d.direction=function(a,b,c){c||(c=a);var d=a[0]-b[0],e=a[1]-b[1],f=a[2]-b[2],g=Math.sqrt(d*d+e*e+f*f);return g?(g=1/g,c[0]=d*g,c[1]=e*g,c[2]=f*g,c):(c[0]=0,c[1]=0,c[2]=0,c)},d.lerp=function(a,b,c,d){return d||(d=a),d[0]=a[0]+c*(b[0]-a[0]),d[1]=a[1]+c*(b[1]-a[1]),d[2]=a[2]+c*(b[2]-a[2]),d},d.str=function(a){return"["+a[0]+", "+a[1]+", "+a[2]+"]"};var e={};e.create=function(a){var b;return a?(b=new glMatrixArrayType(9),b[0]=a[0],b[1]=a[1],b[2]=a[2],b[3]=a[3],b[4]=a[4],b[5]=a[5],b[6]=a[6],b[7]=a[7],b[8]=a[8]):b=new glMatrixArrayType(glMatrixArrayType===Array?[0,0,0,0,0,0,0,0,0]:9),b},e.set=function(a,b){return b[0]=a[0],b[1]=a[1],b[2]=a[2],b[3]=a[3],b[4]=a[4],b[5]=a[5],b[6]=a[6],b[7]=a[7],b[8]=a[8],b},e.identity=function(a){return a[0]=1,a[1]=0,a[2]=0,a[3]=0,a[4]=1,a[5]=0,a[6]=0,a[7]=0,a[8]=1,a},e.transpose=function(a,b){if(!b||a==b){var c=a[1],d=a[2],e=a[5];return a[1]=a[3],a[2]=a[6],a[3]=c,a[5]=a[7],a[6]=d,a[7]=e,a}return b[0]=a[0],b[1]=a[3],b[2]=a[6],b[3]=a[1],b[4]=a[4],b[5]=a[7],b[6]=a[2],b[7]=a[5],b[8]=a[8],b},e.toMat4=function(a,b){return b||(b=f.create()),b[0]=a[0],b[1]=a[1],b[2]=a[2],b[3]=0,b[4]=a[3],b[5]=a[4],b[6]=a[5],b[7]=0,b[8]=a[6],b[9]=a[7],b[10]=a[8],b[11]=0,b[12]=0,b[13]=0,b[14]=0,b[15]=1,b},e.str=function(a){return"["+a[0]+", "+a[1]+", "+a[2]+", "+a[3]+", "+a[4]+", "+a[5]+", "+a[6]+", "+a[7]+", "+a[8]+"]"};var f={};f.create=function(a){var b;return a?(b=new glMatrixArrayType(16),b[0]=a[0],b[1]=a[1],b[2]=a[2],b[3]=a[3],b[4]=a[4],b[5]=a[5],b[6]=a[6],b[7]=a[7],b[8]=a[8],b[9]=a[9],b[10]=a[10],b[11]=a[11],b[12]=a[12],b[13]=a[13],b[14]=a[14],b[15]=a[15]):b=new glMatrixArrayType(glMatrixArrayType===Array?[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]:16),b},f.set=function(a,b){return b[0]=a[0],b[1]=a[1],b[2]=a[2],b[3]=a[3],b[4]=a[4],b[5]=a[5],b[6]=a[6],b[7]=a[7],b[8]=a[8],b[9]=a[9],b[10]=a[10],b[11]=a[11],b[12]=a[12],b[13]=a[13],b[14]=a[14],b[15]=a[15],b},f.identity=function(a){return a[0]=1,a[1]=0,a[2]=0,a[3]=0,a[4]=0,a[5]=1,a[6]=0,a[7]=0,a[8]=0,a[9]=0,a[10]=1,a[11]=0,a[12]=0,a[13]=0,a[14]=0,a[15]=1,a},f.transpose=function(a,b){if(!b||a==b){var c=a[1],d=a[2],e=a[3],f=a[6],g=a[7],h=a[11];return a[1]=a[4],a[2]=a[8],a[3]=a[12],a[4]=c,a[6]=a[9],a[7]=a[13],a[8]=d,a[9]=f,a[11]=a[14],a[12]=e,a[13]=g,a[14]=h,a}return b[0]=a[0],b[1]=a[4],b[2]=a[8],b[3]=a[12],b[4]=a[1],b[5]=a[5],b[6]=a[9],b[7]=a[13],b[8]=a[2],b[9]=a[6],b[10]=a[10],b[11]=a[14],b[12]=a[3],b[13]=a[7],b[14]=a[11],b[15]=a[15],b},f.determinant=function(a){var b=a[0],c=a[1],d=a[2],e=a[3],f=a[4],g=a[5],h=a[6],i=a[7],j=a[8],k=a[9],l=a[10],m=a[11],n=a[12],o=a[13],p=a[14],q=a[15];return n*k*h*e-j*o*h*e-n*g*l*e+f*o*l*e+j*g*p*e-f*k*p*e-n*k*d*i+j*o*d*i+n*c*l*i-b*o*l*i-j*c*p*i+b*k*p*i+n*g*d*m-f*o*d*m-n*c*h*m+b*o*h*m+f*c*p*m-b*g*p*m-j*g*d*q+f*k*d*q+j*c*h*q-b*k*h*q-f*c*l*q+b*g*l*q},f.inverse=function(a,b){b||(b=a);var c=a[0],d=a[1],e=a[2],f=a[3],g=a[4],h=a[5],i=a[6],j=a[7],k=a[8],l=a[9],m=a[10],n=a[11],o=a[12],p=a[13],q=a[14],r=a[15],s=c*h-d*g,t=c*i-e*g,u=c*j-f*g,v=d*i-e*h,w=d*j-f*h,x=e*j-f*i,y=k*p-l*o,z=k*q-m*o,A=k*r-n*o,B=l*q-m*p,C=l*r-n*p,D=m*r-n*q,E=1/(s*D-t*C+u*B+v*A-w*z+x*y);return b[0]=(h*D-i*C+j*B)*E,b[1]=(-d*D+e*C-f*B)*E,b[2]=(p*x-q*w+r*v)*E,b[3]=(-l*x+m*w-n*v)*E,b[4]=(-g*D+i*A-j*z)*E,b[5]=(c*D-e*A+f*z)*E,b[6]=(-o*x+q*u-r*t)*E,b[7]=(k*x-m*u+n*t)*E,b[8]=(g*C-h*A+j*y)*E,b[9]=(-c*C+d*A-f*y)*E,b[10]=(o*w-p*u+r*s)*E,b[11]=(-k*w+l*u-n*s)*E,b[12]=(-g*B+h*z-i*y)*E,b[13]=(c*B-d*z+e*y)*E,b[14]=(-o*v+p*t-q*s)*E,b[15]=(k*v-l*t+m*s)*E,b},f.toRotationMat=function(a,b){return b||(b=f.create()),b[0]=a[0],b[1]=a[1],b[2]=a[2],b[3]=a[3],b[4]=a[4],b[5]=a[5],b[6]=a[6],b[7]=a[7],b[8]=a[8],b[9]=a[9],b[10]=a[10],b[11]=a[11],b[12]=0,b[13]=0,b[14]=0,b[15]=1,b},f.toMat3=function(a,b){return b||(b=e.create()),b[0]=a[0],b[1]=a[1],b[2]=a[2],b[3]=a[4],b[4]=a[5],b[5]=a[6],b[6]=a[8],b[7]=a[9],b[8]=a[10],b},f.toInverseMat3=function(a,b){var c=a[0],d=a[1],f=a[2],g=a[4],h=a[5],i=a[6],j=a[8],k=a[9],l=a[10],m=l*h-i*k,n=-l*g+i*j,o=k*g-h*j,p=c*m+d*n+f*o;if(!p)return null;var q=1/p;return b||(b=e.create()),b[0]=m*q,b[1]=(-l*d+f*k)*q,b[2]=(i*d-f*h)*q,b[3]=n*q,b[4]=(l*c-f*j)*q,b[5]=(-i*c+f*g)*q,b[6]=o*q,b[7]=(-k*c+d*j)*q,b[8]=(h*c-d*g)*q,b},f.multiply=function(a,b,c){c||(c=a);var d=a[0],e=a[1],f=a[2],g=a[3],h=a[4],i=a[5],j=a[6],k=a[7],l=a[8],m=a[9],n=a[10],o=a[11],p=a[12],q=a[13],r=a[14],s=a[15],t=b[0],u=b[1],v=b[2],w=b[3],x=b[4],y=b[5],z=b[6],A=b[7],B=b[8],C=b[9],D=b[10],E=b[11],F=b[12],G=b[13],H=b[14],I=b[15];return c[0]=t*d+u*h+v*l+w*p,c[1]=t*e+u*i+v*m+w*q,c[2]=t*f+u*j+v*n+w*r,c[3]=t*g+u*k+v*o+w*s,c[4]=x*d+y*h+z*l+A*p,c[5]=x*e+y*i+z*m+A*q,c[6]=x*f+y*j+z*n+A*r,c[7]=x*g+y*k+z*o+A*s,c[8]=B*d+C*h+D*l+E*p,c[9]=B*e+C*i+D*m+E*q,c[10]=B*f+C*j+D*n+E*r,c[11]=B*g+C*k+D*o+E*s,c[12]=F*d+G*h+H*l+I*p,c[13]=F*e+G*i+H*m+I*q,c[14]=F*f+G*j+H*n+I*r,c[15]=F*g+G*k+H*o+I*s,c},f.multiplyVec3=function(a,b,c){c||(c=b);var d=b[0],e=b[1],f=b[2];return c[0]=a[0]*d+a[4]*e+a[8]*f+a[12],c[1]=a[1]*d+a[5]*e+a[9]*f+a[13],c[2]=a[2]*d+a[6]*e+a[10]*f+a[14],c},f.multiplyVec4=function(a,b,c){c||(c=b);var d=b[0],e=b[1],f=b[2],g=b[3];return c[0]=a[0]*d+a[4]*e+a[8]*f+a[12]*g,c[1]=a[1]*d+a[5]*e+a[9]*f+a[13]*g,c[2]=a[2]*d+a[6]*e+a[10]*f+a[14]*g,c[3]=a[3]*d+a[7]*e+a[11]*f+a[15]*g,c},f.translate=function(a,b,c){var d=b[0],e=b[1],f=b[2];if(!c||a==c)return a[12]=a[0]*d+a[4]*e+a[8]*f+a[12],a[13]=a[1]*d+a[5]*e+a[9]*f+a[13],a[14]=a[2]*d+a[6]*e+a[10]*f+a[14],a[15]=a[3]*d+a[7]*e+a[11]*f+a[15],a;var g=a[0],h=a[1],i=a[2],j=a[3],k=a[4],l=a[5],m=a[6],n=a[7],o=a[8],p=a[9],q=a[10],r=a[11];return c[0]=g,c[1]=h,c[2]=i,c[3]=j,c[4]=k,c[5]=l,c[6]=m,c[7]=n,c[8]=o,c[9]=p,c[10]=q,c[11]=r,c[12]=g*d+k*e+o*f+a[12],c[13]=h*d+l*e+p*f+a[13],c[14]=i*d+m*e+q*f+a[14],c[15]=j*d+n*e+r*f+a[15],c},f.scale=function(a,b,c){var d=b[0],e=b[1],f=b[2];return c&&a!=c?(c[0]=a[0]*d,c[1]=a[1]*d,c[2]=a[2]*d,c[3]=a[3]*d,c[4]=a[4]*e,c[5]=a[5]*e,c[6]=a[6]*e,c[7]=a[7]*e,c[8]=a[8]*f,c[9]=a[9]*f,c[10]=a[10]*f,c[11]=a[11]*f,c[12]=a[12],c[13]=a[13],c[14]=a[14],c[15]=a[15],c):(a[0]*=d,a[1]*=d,a[2]*=d,a[3]*=d,a[4]*=e,a[5]*=e,a[6]*=e,a[7]*=e,a[8]*=f,a[9]*=f,a[10]*=f,a[11]*=f,a)},f.rotate=function(a,b,c,d){var e=c[0],f=c[1],g=c[2],h=Math.sqrt(e*e+f*f+g*g);if(!h)return null;1!=h&&(h=1/h,e*=h,f*=h,g*=h);var i=Math.sin(b),j=Math.cos(b),k=1-j,l=a[0],m=a[1],n=a[2],o=a[3],p=a[4],q=a[5],r=a[6],s=a[7],t=a[8],u=a[9],v=a[10],w=a[11],x=e*e*k+j,y=f*e*k+g*i,z=g*e*k-f*i,A=e*f*k-g*i,B=f*f*k+j,C=g*f*k+e*i,D=e*g*k+f*i,E=f*g*k-e*i,F=g*g*k+j;return d?a!=d&&(d[12]=a[12],d[13]=a[13],d[14]=a[14],d[15]=a[15]):d=a,d[0]=l*x+p*y+t*z,d[1]=m*x+q*y+u*z,d[2]=n*x+r*y+v*z,d[3]=o*x+s*y+w*z,d[4]=l*A+p*B+t*C,d[5]=m*A+q*B+u*C,d[6]=n*A+r*B+v*C,d[7]=o*A+s*B+w*C,d[8]=l*D+p*E+t*F,d[9]=m*D+q*E+u*F,d[10]=n*D+r*E+v*F,d[11]=o*D+s*E+w*F,d},f.rotateX=function(a,b,c){var d=Math.sin(b),e=Math.cos(b),f=a[4],g=a[5],h=a[6],i=a[7],j=a[8],k=a[9],l=a[10],m=a[11];return c?a!=c&&(c[0]=a[0],c[1]=a[1],c[2]=a[2],c[3]=a[3],c[12]=a[12],c[13]=a[13],c[14]=a[14],c[15]=a[15]):c=a,c[4]=f*e+j*d,c[5]=g*e+k*d,c[6]=h*e+l*d,c[7]=i*e+m*d,c[8]=f*-d+j*e,c[9]=g*-d+k*e,c[10]=h*-d+l*e,c[11]=i*-d+m*e,c},f.rotateY=function(a,b,c){var d=Math.sin(b),e=Math.cos(b),f=a[0],g=a[1],h=a[2],i=a[3],j=a[8],k=a[9],l=a[10],m=a[11];return c?a!=c&&(c[4]=a[4],c[5]=a[5],c[6]=a[6],c[7]=a[7],c[12]=a[12],c[13]=a[13],c[14]=a[14],c[15]=a[15]):c=a,c[0]=f*e+j*-d,c[1]=g*e+k*-d,c[2]=h*e+l*-d,c[3]=i*e+m*-d,c[8]=f*d+j*e,c[9]=g*d+k*e,c[10]=h*d+l*e,c[11]=i*d+m*e,c},f.rotateZ=function(a,b,c){var d=Math.sin(b),e=Math.cos(b),f=a[0],g=a[1],h=a[2],i=a[3],j=a[4],k=a[5],l=a[6],m=a[7];return c?a!=c&&(c[8]=a[8],c[9]=a[9],c[10]=a[10],c[11]=a[11],c[12]=a[12],c[13]=a[13],c[14]=a[14],c[15]=a[15]):c=a,c[0]=f*e+j*d,c[1]=g*e+k*d,c[2]=h*e+l*d,c[3]=i*e+m*d,c[4]=f*-d+j*e,c[5]=g*-d+k*e,c[6]=h*-d+l*e,c[7]=i*-d+m*e,c},f.frustum=function(a,b,c,d,e,g,h){h||(h=f.create());var i=b-a,j=d-c,k=g-e;return h[0]=2*e/i,h[1]=0,h[2]=0,h[3]=0,h[4]=0,h[5]=2*e/j,h[6]=0,h[7]=0,h[8]=(b+a)/i,h[9]=(d+c)/j,h[10]=-(g+e)/k,h[11]=-1,h[12]=0,h[13]=0,h[14]=-(g*e*2)/k,h[15]=0,h},f.perspective=function(a,b,c,d,e){var g=c*Math.tan(a*Math.PI/360),h=g*b;return f.frustum(-h,h,-g,g,c,d,e)},f.ortho=function(a,b,c,d,e,g,h){h||(h=f.create());var i=b-a,j=d-c,k=g-e;return h[0]=2/i,h[1]=0,h[2]=0,h[3]=0,h[4]=0,h[5]=2/j,h[6]=0,h[7]=0,h[8]=0,h[9]=0,h[10]=-2/k,h[11]=0,h[12]=-(a+b)/i,h[13]=-(d+c)/j,h[14]=-(g+e)/k,h[15]=1,h},f.lookAt=function(a,b,c,d){d||(d=f.create());var e=a[0],g=a[1],h=a[2],i=c[0],j=c[1],k=c[2],l=b[0],m=b[1],n=b[2];if(e==l&&g==m&&h==n)return f.identity(d);var o,p,q,r,s,t,u,v,w,x;return o=e-b[0],p=g-b[1],q=h-b[2],x=1/Math.sqrt(o*o+p*p+q*q),o*=x,p*=x,q*=x,r=j*q-k*p,s=k*o-i*q,t=i*p-j*o,x=Math.sqrt(r*r+s*s+t*t),x?(x=1/x,r*=x,s*=x,t*=x):(r=0,s=0,t=0),u=p*t-q*s,v=q*r-o*t,w=o*s-p*r,x=Math.sqrt(u*u+v*v+w*w),x?(x=1/x,u*=x,v*=x,w*=x):(u=0,v=0,w=0),d[0]=r,d[1]=u,d[2]=o,d[3]=0,d[4]=s,d[5]=v,d[6]=p,d[7]=0,d[8]=t,d[9]=w,d[10]=q,d[11]=0,d[12]=-(r*e+s*g+t*h),d[13]=-(u*e+v*g+w*h),d[14]=-(o*e+p*g+q*h),d[15]=1,d},f.str=function(a){return"["+a[0]+", "+a[1]+", "+a[2]+", "+a[3]+",\n "+a[4]+", "+a[5]+", "+a[6]+", "+a[7]+",\n "+a[8]+", "+a[9]+", "+a[10]+", "+a[11]+",\n "+a[12]+", "+a[13]+", "+a[14]+", "+a[15]+"]"},quat4={},quat4.create=function(a){var b;return a?(b=new glMatrixArrayType(4),b[0]=a[0],b[1]=a[1],b[2]=a[2],b[3]=a[3]):b=new glMatrixArrayType(glMatrixArrayType===Array?[0,0,0,0]:4),b},quat4.set=function(a,b){return b[0]=a[0],b[1]=a[1],b[2]=a[2],b[3]=a[3],b},quat4.calculateW=function(a,b){var c=a[0],d=a[1],e=a[2];return b&&a!=b?(b[0]=c,b[1]=d,b[2]=e,b[3]=-Math.sqrt(Math.abs(1-c*c-d*d-e*e)),b):(a[3]=-Math.sqrt(Math.abs(1-c*c-d*d-e*e)),a)},quat4.inverse=function(a,b){return b&&a!=b?(b[0]=-a[0],b[1]=-a[1],b[2]=-a[2],b[3]=a[3],b):(a[0]*=-1,a[1]*=-1,a[2]*=-1,a)},quat4.length=function(a){var b=a[0],c=a[1],d=a[2],e=a[3];return Math.sqrt(b*b+c*c+d*d+e*e)},quat4.normalize=function(a,b){b||(b=a);var c=a[0],d=a[1],e=a[2],f=a[3],g=Math.sqrt(c*c+d*d+e*e+f*f);return 0==g?(b[0]=0,b[1]=0,b[2]=0,b[3]=0,b):(g=1/g,b[0]=c*g,b[1]=d*g,b[2]=e*g,b[3]=f*g,b)},quat4.multiply=function(a,b,c){c||(c=a);var d=a[0],e=a[1],f=a[2],g=a[3],h=b[0],i=b[1],j=b[2],k=b[3];return c[0]=d*k+g*h+e*j-f*i,c[1]=e*k+g*i+f*h-d*j,c[2]=f*k+g*j+d*i-e*h,c[3]=g*k-d*h-e*i-f*j,c},quat4.multiplyVec3=function(a,b,c){c||(c=b);var d=b[0],e=b[1],f=b[2],g=a[0],h=a[1],i=a[2],j=a[3],k=j*d+h*f-i*e,l=j*e+i*d-g*f,m=j*f+g*e-h*d,n=-g*d-h*e-i*f;return c[0]=k*j+n*-g+l*-i-m*-h,c[1]=l*j+n*-h+m*-g-k*-i,c[2]=m*j+n*-i+k*-h-l*-g,c},quat4.toMat3=function(a,b){b||(b=e.create());var c=a[0],d=a[1],f=a[2],g=a[3],h=c+c,i=d+d,j=f+f,k=c*h,l=c*i,m=c*j,n=d*i,o=d*j,p=f*j,q=g*h,r=g*i,s=g*j;return b[0]=1-(n+p),b[1]=l-s,b[2]=m+r,b[3]=l+s,b[4]=1-(k+p),b[5]=o-q,b[6]=m-r,b[7]=o+q,b[8]=1-(k+n),b},quat4.toMat4=function(a,b){b||(b=f.create());var c=a[0],d=a[1],e=a[2],g=a[3],h=c+c,i=d+d,j=e+e,k=c*h,l=c*i,m=c*j,n=d*i,o=d*j,p=e*j,q=g*h,r=g*i,s=g*j;return b[0]=1-(n+p),b[1]=l-s,b[2]=m+r,b[3]=0,b[4]=l+s,b[5]=1-(k+p),b[6]=o-q,b[7]=0,b[8]=m-r,b[9]=o+q,b[10]=1-(k+n),b[11]=0,b[12]=0,b[13]=0,b[14]=0,b[15]=1,b},quat4.slerp=function(a,b,c,d){d||(d=a);var e=a[0]*b[0]+a[1]*b[1]+a[2]*b[2]+a[3]*b[3];if(Math.abs(e)>=1)return d!=a&&(d[0]=a[0],d[1]=a[1],d[2]=a[2],d[3]=a[3]),d;var f=Math.acos(e),g=Math.sqrt(1-e*e);if(Math.abs(g)<.001)return d[0]=.5*a[0]+.5*b[0],d[1]=.5*a[1]+.5*b[1],d[2]=.5*a[2]+.5*b[2],d[3]=.5*a[3]+.5*b[3],d;var h=Math.sin((1-c)*f)/g,i=Math.sin(c*f)/g;return d[0]=a[0]*h+b[0]*i,d[1]=a[1]*h+b[1]*i,d[2]=a[2]*h+b[2]*i,d[3]=a[3]*h+b[3]*i,d},quat4.str=function(a){return"["+a[0]+", "+a[1]+", "+a[2]+", "+a[3]+"]"},c("glMatrix",["typedefs"],function(a){return function(){var b;return b||a.glMatrix}}(this)),f.xVec4=function(a,b,c){c||(c=b);var d=b[0],e=b[1],f=b[2],g=b[3];return c[0]=a[0]*d+a[1]*e+a[2]*f+a[3]*g,c[1]=a[4]*d+a[5]*e+a[6]*f+a[7]*g,c[2]=a[8]*d+a[9]*e+a[10]*f+a[11]*g,c[3]=a[12]*d+a[13]*e+a[14]*f+a[15]*g,c},e.scale=function(a,b,c){return c&&a!=c?(c=e.create(),c[0]=a[0]*b,c[1]=a[1]*b,c[2]=a[2]*b,c[3]=a[3]*b,c[4]=a[4]*b,c[5]=a[5]*b,c[6]=a[6]*b,c[7]=a[7]*b,c[8]=a[8]*b,c):(a[0]*=b,a[1]*=b,a[2]*=b,a[3]*=b,a[4]*=b,a[5]*=b,a[6]*=b,a[7]*=b,a[8]*=b,a)},e.inverse=function(a,b){b||(b=a);var c=a[0],d=a[1],e=a[2],f=a[3],g=a[4],h=a[5],i=a[6],j=a[7],k=a[8],l=1/(c*g*k+d*h*i+e*f*j-e*g*i-d*f*k-c*h*j);return b[0]=(g*k-h*j)*l,b[1]=(e*j-d*k)*l,b[2]=(d*h-e*g)*l,b[3]=(h*i-f*k)*l,b[4]=(c*k-e*i)*l,b[5]=(e*f-c*h)*l,b[6]=(f*j-g*i)*l,b[7]=(d*i-c*j)*l,b[8]=(c*g-d*f)*l,b},e.multiply=function(a,b,c){c||(c=a);var d=a[0],e=a[1],f=a[2],g=a[3],h=a[4],i=a[5],j=a[6],k=a[7],l=a[8],m=b[0],n=b[1],o=b[2],p=b[3],q=b[4],r=b[5],s=b[6],t=b[7],u=b[8];return c[0]=d*m+e*p+f*s,c[1]=d*n+e*q+f*t,c[2]=d*o+e*r+f*u,c[3]=g*m+h*p+i*s,c[4]=g*n+h*q+i*t,c[5]=g*o+h*r+i*u,c[6]=j*m+k*p+l*s,c[7]=j*n+k*q+l*t,c[8]=j*o+k*r+l*u,c},e.xVec3=function(a,b,c){c||(c=b);var d=b[0],e=b[1],f=b[2];return c[0]=a[0]*d+a[1]*e+a[2]*f,c[1]=a[3]*d+a[4]*e+a[5]*f,c[2]=a[6]*d+a[7]*e+a[8]*f,c};var g={};g.create=function(a){var b;return a?(b=new glMatrixArrayType(4),b[0]=a[0],b[1]=a[1],b[2]=a[2],b[3]=a[3]):b=new glMatrixArrayType(glMatrixArrayType===Array?[0,0,0,0]:4),b},g.project=function(a,b){return b||(b=a),b[0]=a[0]/a[3],b[1]=a[1]/a[3],b[2]=a[2]/a[3],b},g.scale=function(a,b,c){return c&&a!=c?(c[0]=a[0]*b,c[1]=a[1]*b,c[2]=a[2]*b,c[3]=a[3]*b,c):(a[0]*=b,a[1]*=b,a[2]*=b,a[4]*=b,a)},g.xMat4=function(a,b,c){c||(c=a);var d=a[0],e=a[1],f=a[2],g=a[3];return c[0]=b[0]*d+b[4]*e+b[8]*f+b[12]*g,c[1]=b[1]*d+b[5]*e+b[9]*f+b[13]*g,c[2]=b[2]*d+b[6]*e+b[10]*f+b[14]*g,c[3]=b[3]*d+b[7]*e+b[11]*f+b[15]*g,c};var h={};h.create=function(a){var b;return a?(b=new glMatrixArrayType(4),b[0]=a[0],b[1]=a[1],b[2]=a[2],b[3]=a[3]):b=new glMatrixArrayType(glMatrixArrayType===Array?[0,0,0,0]:4),b},h.xVec2=function(a,b,c){c||(c=b);var d=b[0],e=b[1];return c[0]=a[0]*d+a[1]*e,c[1]=a[2]*d+a[3]*e,c},h.scale=function(a,b,c){return c&&a!=c?(c[0]=a[0]*b,c[1]=a[1]*b,c[2]=a[2]*b,c[3]=a[3]*b,c):(a[0]*=b,a[1]*=b,a[2]*=b,a[3]*=b,a)},h.determinant=function(a){return a[0]*a[3]-a[1]*a[2]},h.inverse=function(a){var b=1/h.determinant(a),c=a[3]*b,d=-a[1]*b,e=-a[2]*b,f=a[0];return a[0]=c,a[1]=d,a[2]=e,a[3]=f,a};var i={};i.create=function(a){var b;return a?(b=new glMatrixArrayType(2),b[0]=a[0],b[1]=a[1]):b=new glMatrixArrayType(glMatrixArrayType===Array?[0,0]:2),b},i.subtract=function(a,b,c){return c&&a!=c?(c[0]=a[0]-b[0],c[1]=a[1]-b[1],c):(a[0]-=b[0],a[1]-=b[1],a)},i.add=function(a,b,c){return c&&a!=c?(c[0]=a[0]+b[0],c[1]=a[1]+b[1],c):(a[0]+=b[0],a[1]+=b[1],a)},i.scale=function(a,b,c){return c&&a!=c?(c[0]=a[0]*b,c[1]=a[1]*b,c):(a[0]*=b,a[1]*=b,a)},i.normalize=function(a,b){b||(b=a);var c=a[0],d=a[1],e=Math.sqrt(c*c+d*d);return e?1==e?(b[0]=c,b[1]=d,b):(e=1/e,b[0]=c*e,b[1]=d*e,b):(b[0]=0,b[1]=0,b)},i.dot=function(a,b){return a[0]*b[0]+a[1]*b[1]},i.multiply=function(a,b,c){return c||(c=a),c[0]=a[0]*b[0],c[1]=a[1]*b[1],c -},i.unproject=function(a){return d.create([a[0],a[1],1])},i.length=function(a){return Math.sqrt(a[0]*a[0]+a[1]*a[1])},i.perspectiveProject=function(a){var b=i.create(a);return i.scale(b,1/a[2])},d.project=function(a){return i.scale(i.create(a),1/a[2])};var j={};j.scale=function(a,b,c){return c&&a!=c?(c[0]=a[0]*b,c[1]=a[1]*b,c[2]=a[2]*b,c[3]=a[3]*b,c[4]=a[4]*b,c[5]=a[5]*b,c):(a[0]*=b,a[1]*=b,a[2]*=b,a[3]*=b,a[4]*=b,a[5]*=b,a)},j.subtract=function(a,b,c){return c&&a!=c?(c[0]=a[0]-b[0],c[1]=a[1]-b[1],c[2]=a[2]-b[2],c[3]=a[3]-b[3],c[4]=a[4]-b[4],c[5]=a[5]-b[5],c):(a[0]-=b[0],a[1]-=b[1],a[2]-=b[2],a[3]-=b[3],a[4]-=b[4],a[5]-=b[5],a)},j.dot=function(a,b){return a[0]*b[0]+a[1]*b[1]+a[2]*b[2]+a[3]*b[3]+a[4]*b[4]+a[5]*b[5]};var k={};return k.xVec6=function(a,b,c){c||(c=b);var d=b[0],e=b[1],f=b[2],g=b[3],h=b[4],i=b[5];return c[0]=a[0]*d+a[1]*e+a[2]*f+a[3]*g+a[4]*h+a[5]*i,c[1]=a[6]*d+a[7]*e+a[8]*f+a[9]*g+a[10]*h+a[11]*i,c[2]=a[12]*d+a[13]*e+a[14]*f+a[15]*g+a[16]*h+a[17]*i,c[3]=a[18]*d+a[19]*e+a[20]*f+a[21]*g+a[22]*h+a[23]*i,c[4]=a[24]*d+a[25]*e+a[26]*f+a[27]*g+a[28]*h+a[29]*i,c[5]=a[30]*d+a[31]*e+a[32]*f+a[33]*g+a[34]*h+a[35]*i,c},e.xVec3=function(a,b,c){c||(c=b);var d=b[0],e=b[1],f=b[2];return c[0]=a[0]*d+a[1]*e+a[2]*f,c[1]=a[3]*d+a[4]*e+a[5]*f,c[2]=a[6]*d+a[7]*e+a[8]*f,c},c("glMatrixAddon",["glMatrix"],function(a){return function(){var b;return b||a.glMatrixAddon}}(this)),c("array_helper",[],function(){return{init:function(a,b){for(var c=a.length;c--;)a[c]=b},shuffle:function(a){var b,c,d=a.length-1;for(d;d>=0;d--)b=Math.floor(Math.random()*d),c=a[d],a[d]=a[b],a[b]=c;return a},toPointList:function(a){var b,c,d=[],e=[];for(b=0;b=b&&e.push(a[d]);return e},maxIndex:function(a){var b,c=0;for(b=0;ba[c]&&(c=b);return c},max:function(a){var b,c=0;for(b=0;bc&&(c=a[b]);return c}}}),c("cv_utils",["cluster","glMatrixAddon","array_helper"],function(a,b,c){var e={};return e.imageRef=function(a,b){var c={x:a,y:b,toVec2:function(){return i.create([this.x,this.y])},toVec3:function(){return d.create([this.x,this.y,1])},round:function(){return this.x=Math.floor(this.x>0?this.x+.5:this.x-.5),this.y=Math.floor(this.y>0?this.y+.5:this.y-.5),this}};return c},e.computeIntegralImage2=function(a,b){var c,d,e=a.data,f=a.size.x,g=a.size.y,h=b.data,i=0,j=0,k=0,l=0,m=0;for(k=f,i=0,d=1;g>d;d++)i+=e[j],h[k]+=i,j+=f,k+=f;for(j=0,k=1,i=0,c=1;f>c;c++)i+=e[j],h[k]+=i,j++,k++;for(d=1;g>d;d++)for(j=d*f+1,k=(d-1)*f+1,l=d*f,m=(d-1)*f,c=1;f>c;c++)h[j]+=e[j]+h[k]+h[l]-h[m],j++,k++,l++,m++},e.computeIntegralImage=function(a,b){for(var c=a.data,d=a.size.x,e=a.size.y,f=b.data,g=0,h=0;d>h;h++)g+=c[h],f[h]=g;for(var i=1;e>i;i++){g=0;for(var j=0;d>j;j++)g+=c[i*d+j],f[i*d+j]=g+f[(i-1)*d+j]}},e.thresholdImage=function(a,b,c){c||(c=a);for(var d=a.data,e=d.length,f=c.data;e--;)f[e]=d[e]b;b++)e[b]=0;for(;d--;)e[c[d]]++;return e},e.otsuThreshold=function(a,b){function d(a,b){var c,d=0;for(c=a;b>=c;c++)d+=h[c];return d}function f(a,b){var c,d=0;for(c=a;b>=c;c++)d+=c*h[c];return d}function g(){var b,g,i,j,k,l,m,n=[0];for(h=e.computeHistogram(a),j=1;255>j;j++)b=d(0,j),g=d(j+1,255),i=b*g,0===i&&(i=1),k=f(0,j)*g,l=f(j+1,255)*b,m=k-l,n[j]=m*m/i;return c.maxIndex(n)}var h,i;return i=g(),e.thresholdImage(a,i,b),i},e.computeBinaryImage=function(a,b,c){e.computeIntegralImage(a,b),c||(c=a);var d,f,g,h,i,j,k,l=a.data,m=c.data,n=a.size.x,o=a.size.y,p=b.data,q=0,r=3,s=(2*r+1)*(2*r+1);for(d=0;r>=d;d++)for(f=0;n>f;f++)m[d*n+f]=0,m[(o-1-d)*n+f]=0;for(d=r;o-r>d;d++)for(f=0;r>=f;f++)m[d*n+f]=0,m[d*n+(n-1-f)]=0;for(d=r+1;o-r-1>d;d++)for(f=r+1;n-r>f;f++)g=p[(d-r-1)*n+(f-r-1)],h=p[(d-r-1)*n+(f+r)],i=p[(d+r)*n+(f-r-1)],j=p[(d+r)*n+(f+r)],q=j-i-h+g,k=q/s,m[d*n+f]=l[d*n+f]>k+5?0:1},e.cluster=function(b,c,d){function e(a){var b=!1;for(g=0;gb.x-j&&a.xb.y-k&&a.yd;d++){for(h=Math.floor(Math.random()*a.length),f=[],i=h,f.push(a[i]);null!==(i=c(i,!0));)f.push(a[i]);if(h>0)for(i=h;null!==(i=c(i,!1));)f.push(a[i]);f.length>g.length&&(g=f)}return g}},e.DILATE=1,e.ERODE=2,e.dilate=function(a,b){var c,d,e,f,g,h,i,j=a.data,k=b.data,l=a.size.y,m=a.size.x;for(c=1;l-1>c;c++)for(d=1;m-1>d;d++)f=c-1,g=c+1,h=d-1,i=d+1,e=j[f*m+h]+j[f*m+i]+j[c*m+d]+j[g*m+h]+j[g*m+i],k[c*m+d]=e>0?1:0},e.erode=function(a,b){var c,d,e,f,g,h,i,j=a.data,k=b.data,l=a.size.y,m=a.size.x;for(c=1;l-1>c;c++)for(d=1;m-1>d;d++)f=c-1,g=c+1,h=d-1,i=d+1,e=j[f*m+h]+j[f*m+i]+j[c*m+d]+j[g*m+h]+j[g*m+i],k[c*m+d]=5===e?1:0},e.subtract=function(a,b,c){c||(c=a);for(var d=a.data.length,e=a.data,f=b.data,g=c.data;d--;)g[d]=e[d]-f[d]},e.bitwiseOr=function(a,b,c){c||(c=a);for(var d=a.data.length,e=a.data,f=b.data,g=c.data;d--;)g[d]=e[d]||f[d]},e.countNonZero=function(a){for(var b=a.data.length,c=a.data,d=0;b--;)d+=c[b];return d},e.topGeneric=function(a,b,c){var d,e,f,g,h=0,i=0,j=[];for(d=0;b>d;d++)j[d]={score:0,item:null};for(d=0;di)for(f=j[h],f.score=e,f.item=a[d],i=Number.MAX_VALUE,g=0;b>g;g++)j[g].scoref;){for(d=0;h>d;d++)c[i]=Math.floor((.299*a[4*e+0]+.587*a[4*e+1]+.114*a[4*e+2]+(.299*a[4*(e+1)+0]+.587*a[4*(e+1)+1]+.114*a[4*(e+1)+2])+(.299*a[4*f+0]+.587*a[4*f+1]+.114*a[4*f+2])+(.299*a[4*(f+1)+0]+.587*a[4*(f+1)+1]+.114*a[4*(f+1)+2]))/4),i++,e+=2,f+=2;e+=j,f+=j}},e.computeGray=function(a,b){var c=a.length/4,d=0;for(d=0;c>d;d++)b[d]=Math.floor(.299*a[4*d+0]+.587*a[4*d+1]+.114*a[4*d+2])},e.loadImageArray=function(a,b,c){c||(c=document.createElement("canvas"));var d=new Image;d.callback=b,d.onload=function(){c.width=this.width,c.height=this.height;var a=c.getContext("2d");a.drawImage(this,0,0);var b=new Uint8Array(this.width*this.height);a.drawImage(this,0,0);var d=a.getImageData(0,0,this.width,this.height).data;e.computeGray(d,b),this.callback(b,{x:this.width,y:this.height},this)},d.src=a},e.halfSample=function(a,b){for(var c=a.data,d=a.size.x,e=b.data,f=0,g=d,h=c.length,i=d/2,j=0;h>g;){for(var k=0;i>k;k++)e[j]=Math.floor((c[f]+c[f+1]+c[g]+c[g+1])/4),j++,f+=2,g+=2;f+=d,g+=d}},e.hsv2rgb=function(a,b){var c=a[0],d=a[1],e=a[2],f=e*d,g=f*(1-Math.abs(c/60%2-1)),h=e-f,i=0,j=0,k=0;return b=b||[0,0,0],60>c?(i=f,j=g):120>c?(i=g,j=f):180>c?(j=f,k=g):240>c?(j=g,k=f):300>c?(i=g,k=f):360>c&&(i=f,k=g),b[0]=255*(i+h)|0,b[1]=255*(j+h)|0,b[2]=255*(k+h)|0,b},e}),c("image_wrapper",["subImage","cv_utils","array_helper"],function(a,b,c){function d(a,b,d,e){b?this.data=b:d?(this.data=new d(a.x*a.y),d===Array&&e&&c.init(this.data,0)):(this.data=new Uint8Array(a.x*a.y),Uint8Array===Array&&e&&c.init(this.data,0)),this.size=a}return d.prototype.inImageWithBorder=function(a,b){return a.x>=b&&a.y>=b&&a.x=0&&u>=0&&n-1>v&&o-1>w){for(g=s,j=0;m>j;++j,i.add(g,y))for(k=0;l>k;++k,i.add(g,p))b.set(k,j,x(a,g[0],g[1]));return 0}var z=n-1,A=o-1,B=0;for(g=s,j=0;m>j;++j,i.add(g,y))for(k=0;l>k;++k,i.add(g,p))0<=g[0]&&0<=g[1]&&g[0]c;c++)for(d=0;e>d;d++)a.data[d*f+c]=this.data[(b.y+d)*this.size.x+b.x+c]},d.prototype.copyTo=function(a){for(var b=this.data.length,c=this.data,d=a.data;b--;)d[b]=c[b]},d.prototype.get=function(a,b){return this.data[b*this.size.x+a]},d.prototype.getSafe=function(a,b){var c;if(!this.indexMapping){for(this.indexMapping={x:[],y:[]},c=0;ca;a++)d[a]=d[(c-1)*b+a]=0;for(a=1;c-1>a;a++)d[a*b]=d[a*b+(b-1)]=0},d.prototype.invert=function(){for(var a=this.data,b=a.length;b--;)a[b]=a[b]?0:1},d.prototype.convolve=function(a){var b,c,d,e,f=a.length/2|0,g=0;for(c=0;c=e;e++)for(d=-f;f>=d;d++)g+=a[e+f][d+f]*this.getSafe(b+d,c+e);this.data[c*this.size.x+b]=g}},d.prototype.moments=function(a){var b,c,d,e,f,g,h,j,k,l,m,n,o=this.data,p=this.size.y,q=this.size.x,r=[],s=[],t=Math.PI,u=t/4;if(0>=a)return s;for(f=0;a>f;f++)r[f]={m00:0,m01:0,m10:0,m11:0,m02:0,m20:0,theta:0,rad:0};for(c=0;p>c;c++)for(e=c*c,b=0;q>b;b++)d=o[c*q+b],d>0&&(g=r[d-1],g.m00+=1,g.m01+=c,g.m10+=b,g.m11+=b*c,g.m02+=e,g.m20+=b*b);for(f=0;a>f;f++)g=r[f],isNaN(g.m00)||0===g.m00||(l=g.m10/g.m00,m=g.m01/g.m00,h=g.m11/g.m00-l*m,j=g.m02/g.m00-m*m,k=g.m20/g.m00-l*l,n=(j-k)/(2*h),n=.5*Math.atan(n)+(h>=0?u:-u)+t,g.theta=(180*n/t+90)%180-90,g.theta<0&&(g.theta+=180),g.rad=n>t?n-t:n,g.vec=i.create([Math.cos(n),Math.sin(n)]),s.push(g));return s},d.prototype.show=function(a,b){var c,d,e,f,g,h,i;for(b||(b=1),c=a.getContext("2d"),a.width=this.size.x,a.height=this.size.y,d=c.getImageData(0,0,a.width,a.height),e=d.data,f=0,i=0;ic||c>360)&&(c=360);for(var e=[0,1,1],f=[0,0,0],g=[255,255,255],h=[0,0,0],i=[],j=a.getContext("2d"),k=j.getImageData(d.x,d.y,this.size.x,this.size.y),l=k.data,m=this.data.length;m--;)e[0]=this.data[m]*c,i=e[0]<=0?g:e[0]>=360?h:b.hsv2rgb(e,f),l[4*m+0]=i[0],l[4*m+1]=i[1],l[4*m+2]=i[2],l[4*m+3]=255;j.putImageData(k,d.x,d.y)},d}),c("tracer",[],function(){var a={searchDirections:[[0,1],[1,1],[1,0],[1,-1],[0,-1],[-1,-1],[-1,0],[-1,1]],create:function(a,b){function c(a,b,c,d){var e,k,l;for(e=0;7>e;e++){if(k=a.cy+i[a.dir][0],l=a.cx+i[a.dir][1],f=k*j+l,g[f]===b&&(0===h[f]||h[f]===c))return h[f]=c,a.cy=k,a.cx=l,!0;0===h[f]&&(h[f]=d),a.dir=(a.dir+1)%8}return!1}function d(a,b,c){return{dir:c,x:a,y:b,next:null,prev:null}}function e(a,b,e,f,g){var h,i,j,k=null,l={cx:b,cy:a,dir:0};if(c(l,f,e,g)){k=d(b,a,l.dir),h=k,j=l.dir,i=d(l.cx,l.cy,0),i.prev=h,h.next=i,i.next=null,h=i;do l.dir=(l.dir+6)%8,c(l,f,e,g),j!=l.dir?(h.dir=l.dir,i=d(l.cx,l.cy,0),i.prev=h,h.next=i,i.next=null,h=i):(h.dir=j,h.x=l.cx,h.y=l.cy),j=l.dir;while(l.cx!=b||l.cy!=a);k.prev=h.prev,h.prev.next=k}return k}var f,g=a.data,h=b.data,i=this.searchDirections,j=a.size.x;return{trace:function(a,b,d,e){return c(a,b,d,e)},contourTracing:function(a,b,c,d,f){return e(a,b,c,d,f)}}}};return a}),c("rasterizer",["tracer"],function(a){var b={createContour2D:function(){return{dir:null,index:null,firstVertex:null,insideContours:null,nextpeer:null,prevpeer:null}},CONTOUR_DIR:{CW_DIR:0,CCW_DIR:1,UNKNOWN_DIR:2},DIR:{OUTSIDE_EDGE:-32767,INSIDE_EDGE:-32766},create:function(c,d){var e=c.data,f=d.data,g=c.size.x,h=c.size.y,i=a.create(c,d);return{rasterize:function(a){var c,d,j,k,l,m,n,o,p,q,r,s,t=[],u=0;for(s=0;400>s;s++)t[s]=0;for(t[0]=e[0],p=null,m=1;h-1>m;m++)for(k=0,d=t[0],l=1;g-1>l;l++)if(r=m*g+l,0===f[r])if(c=e[r],c!==d){if(0===k)j=u+1,t[j]=c,d=c,n=i.contourTracing(m,l,j,c,b.DIR.OUTSIDE_EDGE),null!==n&&(u++,k=j,o=b.createContour2D(),o.dir=b.CONTOUR_DIR.CW_DIR,o.index=k,o.firstVertex=n,o.nextpeer=p,o.insideContours=null,null!==p&&(p.prevpeer=o),p=o);else if(n=i.contourTracing(m,l,b.DIR.INSIDE_EDGE,c,k),null!==n){for(o=b.createContour2D(),o.firstVertex=n,o.insideContours=null,o.dir=0===a?b.CONTOUR_DIR.CCW_DIR:b.CONTOUR_DIR.CW_DIR,o.index=a,q=p;null!==q&&q.index!==k;)q=q.nextpeer;null!==q&&(o.nextpeer=q.insideContours,null!==q.insideContours&&(q.insideContours.prevpeer=o),q.insideContours=o)}}else f[r]=k;else f[r]===b.DIR.OUTSIDE_EDGE||f[r]===b.DIR.INSIDE_EDGE?(k=0,d=f[r]===b.DIR.INSIDE_EDGE?e[r]:t[0]):(k=f[r],d=t[k]);for(q=p;null!==q;)q.index=a,q=q.nextpeer;return{cc:p,count:u}},debug:{drawContour:function(a,c){var d,e,f,g=a.getContext("2d"),h=c;for(g.strokeStyle="red",g.fillStyle="red",g.lineWidth=1,d=null!==h?h.insideContours:null;null!==h;){switch(null!==d?(e=d,d=d.nextpeer):(e=h,h=h.nextpeer,d=null!==h?h.insideContours:null),e.dir){case b.CONTOUR_DIR.CW_DIR:g.strokeStyle="red";break;case b.CONTOUR_DIR.CCW_DIR:g.strokeStyle="blue";break;case b.CONTOUR_DIR.UNKNOWN_DIR:g.strokeStyle="green"}f=e.firstVertex,g.beginPath(),g.moveTo(f.x,f.y);do f=f.next,g.lineTo(f.x,f.y);while(f!==e.firstVertex);g.stroke()}}}}}};return b}),c("skeletonizer",[],function(){function a(a,b,c){"use asm";function d(a,b){a|=0,b|=0;var c=0,d=0,e=0,f=0,g=0,h=0,i=0,j=0;for(c=1;(c|0)<(n-1|0);c=c+1|0)for(j=j+n|0,d=1;(d|0)<(n-1|0);d=d+1|0)f=j-n|0,g=j+n|0,h=d-1|0,i=d+1|0,e=(m[a+f+h|0]|0)+(m[a+f+i|0]|0)+(m[a+j+d|0]|0)+(m[a+g+h|0]|0)+(m[a+g+i|0]|0)|0,m[b+j+d|0]=(e|0)==5?1:0}function e(a,b,c){a|=0,b|=0,c|=0;var d=0;for(d=o(n,n)|0;(d|0)>0;)d=d-1|0,m[c+d|0]=(m[a+d|0]|0)-(m[b+d|0]|0)|0}function f(a,b,c){a|=0,b|=0,c|=0;var d=0;for(d=o(n,n)|0;(d|0)>0;)d=d-1|0,m[c+d|0]=m[a+d|0]|0|(m[b+d|0]|0)|0}function g(a){a|=0;var b=0,c=0;for(c=o(n,n)|0;(c|0)>0;)c=c-1|0,b=(b|0)+(m[a+c|0]|0)|0;return b|0}function h(a,b){a|=0,b|=0;var c=0;for(c=o(n,n)|0;(c|0)>0;)c=c-1|0,m[a+c|0]=b}function i(a,b){a|=0,b|=0;var c=0,d=0,e=0,f=0,g=0,h=0,i=0,j=0;for(c=1;(c|0)<(n-1|0);c=c+1|0)for(j=j+n|0,d=1;(d|0)<(n-1|0);d=d+1|0)f=j-n|0,g=j+n|0,h=d-1|0,i=d+1|0,e=(m[a+f+h|0]|0)+(m[a+f+i|0]|0)+(m[a+j+d|0]|0)+(m[a+g+h|0]|0)+(m[a+g+i|0]|0)|0,m[b+j+d|0]=(e|0)>0?1:0}function j(a,b){a|=0,b|=0;var c=0;for(c=o(n,n)|0;(c|0)>0;)c=c-1|0,m[b+c|0]=m[a+c|0]|0}function k(a){a|=0;var b=0,c=0;for(b=0;(b|0)<(n-1|0);b=b+1|0)m[a+b|0]=0,m[a+c|0]=0,c=c+n-1|0,m[a+c|0]=0,c=c+1|0;for(b=0;(b|0)<(n|0);b=b+1|0)m[a+c|0]=0,c=c+1|0}function l(){var a=0,b=0,c=0,l=0,m=0,p=0;b=o(n,n)|0,c=b+b|0,l=c+b|0,h(l,0),k(a);do d(a,b),i(b,c),e(a,c,c),f(l,c,l),j(b,a),m=g(a)|0,p=(m|0)==0|0;while(!p)}var m=new a.Uint8Array(c),n=b.size|0,o=a.Math.imul;return{skeletonize:l}}return a}),c("image_debug",[],function(){return{drawRect:function(a,b,c,d){c.strokeStyle=d.color,c.fillStyle=d.color,c.lineWidth=1,c.beginPath(),c.strokeRect(a.x,a.y,b.x,b.y)},drawPath:function(a,b,c,d){c.strokeStyle=d.color,c.fillStyle=d.color,c.lineWidth=d.lineWidth,c.beginPath(),c.moveTo(a[0][b.x],a[0][b.y]);for(var e=1;eb&&(b+=180),b=(180-b)*Math.PI/180,f=h.create([Math.cos(b),-Math.sin(b),Math.sin(b),Math.cos(b)]),c=0;cd;d++)h.xVec2(f,e.box[d]);u.boxFromPatches.showTransformed&&g.drawPath(e.box,{x:0,y:1},H.ctx.binary,{color:"#99ff00",lineWidth:2})}for(c=0;cd;d++)e.box[d][0]n&&(n=e.box[d][0]),e.box[d][1]o&&(o=e.box[d][1]);for(j=[[l,m],[n,m],[n,o],[l,o]],u.boxFromPatches.showTransformedBox&&g.drawPath(j,{x:0,y:1},H.ctx.binary,{color:"#ff0000",lineWidth:2}),k=G?2:1,f=h.inverse(f),d=0;4>d;d++)h.xVec2(f,j[d]);for(u.boxFromPatches.showBB&&g.drawPath(j,{x:0,y:1},H.ctx.binary,{color:"#ff0000",lineWidth:2}),d=0;4>d;d++)i.scale(j[d],k);return j}function m(){b.otsuThreshold(v,C),C.zeroBorder(),u.showCanvas&&C.show(H.dom.binary,255)}function n(){var a,b,d,e,h,i,j,k,l=[];for(a=0;ab;b++)d.push(0);for(c=A.data.length;c--;)A.data[c]>0&&d[A.data[c]-1]++;return d=d.map(function(a,b){return{val:a,label:b+1}}),d.sort(function(a,b){return b.val-a.val}),e=d.filter(function(a){return a.val>=5})}function p(a,c){var d,e,f,h,i,j=[],k=[],m=[0,1,1],n=[0,0,0];for(d=0;d=2){for(e=0;e6&&k.push(a[e]);if(k.length>=2){for(j=k.length,g=q(k),f=0,e=0;e1&&g.length>=k.length/4*3&&g.length>a.length/4&&(f/=g.length,h={index:b[1]*I.x+b[0],pos:{x:c,y:d},box:[i.create([c,d]),i.create([c+x.size.x,d]),i.create([c+x.size.x,d+x.size.y]),i.create([c,d+x.size.y])],moments:g,rad:f,vec:i.create([Math.cos(f),Math.sin(f)])},l.push(h))}}return l}function t(a){function c(){var a;for(a=0;al&&e(h))):A.data[h]=Number.MAX_VALUE}var h,j,k=0,l=.95,m=0,n=[0,1,1],o=[0,0,0];for(f.init(z.data,0),f.init(A.data,0),f.init(B.data,null),h=0;h0&&A.data[h]<=k&&(j=B.data[h],n[0]=A.data[h]/(k+1)*360,b.hsv2rgb(n,o),g.drawRect(j.pos,x.size,H.ctx.binary,{color:"rgb("+o.join(",")+")",lineWidth:2}));return k}var u,v,w,x,y,z,A,B,C,D,E,F,G=!0,H={ctx:{binary:null},dom:{binary:null}},I={x:0,y:0};return{init:function(a,b){u=a,E=b.inputImageWrapper,j(),k()},locate:function(){var a,c=[],d=[];if(G&&b.halfSample(E,v),m(),a=n(),!(a.length=e?null:(c=o(e),0===c.length?null:d=p(c,e))}}}}),c("bresenham",[],function(){var a={},b={DIR:{UP:1,DOWN:-1}};return a.getBarcodeLine=function(a,b,c){function d(a,b){l=s[b*t+a],u+=l,v=v>l?l:v,w=l>w?l:w,r.push(l)}var e,f,g,h,i,j,k,l,m=0|b.x,n=0|b.y,o=0|c.x,p=0|c.y,q=Math.abs(p-n)>Math.abs(o-m),r=[],s=a.data,t=a.size.x,u=0,v=255,w=0;for(q&&(j=m,m=n,n=j,j=o,o=p,p=j),m>o&&(j=m,m=o,o=j,j=n,n=p,p=j),e=o-m,f=Math.abs(p-n),g=e/2|0,i=n,h=p>n?1:-1,k=m;o>k;k++)q?d(i,k):d(k,i),g-=f,0>g&&(i+=h,g+=e);return{line:r,min:v,max:w}},a.toBinaryLine=function(a){var c,d,e,f,g,h=a.min,i=a.max,j=a.line,k=h+(i-h)/2,l=[],m=(i-h)/8,n=-m;for(d=j[0]>k?b.DIR.DOWN:b.DIR.UP,l.push({pos:0,val:j[0]}),f=0;fc?b.DIR.UP:c>m?b.DIR.DOWN:d,d!==e&&(l.push({pos:f,val:j[f]}),d=e);for(l.push({pos:j.length,val:j[j.length-1]}),g=l[0].pos;gk?0:1;for(f=1;fl[f].val?l[f].val+(l[f+1].val-l[f].val)/2|0:l[f+1].val+(l[f].val-l[f+1].val)/2|0,g=l[f].pos;gm?0:1;return{line:j,threshold:m}},a.debug={printFrequency:function(a,b){var c,d=b.getContext("2d");for(b.width=a.length,b.height=256,d.beginPath(),d.strokeStyle="blue",c=0;cd&&null===i;d++)e=g/h*d*(d%2===0?-1:1),f={y:e*j,x:e*l},b[0].y+=f.x,b[0].x-=f.y,b[1].y+=f.x,b[1].x-=f.y,i=k(b);return i}function m(a){var d,e,f,g=n.ctx.overlay;return c.drawBoundingBox&&g&&b.drawPath(a,{x:0,y:1},g,{color:"blue",lineWidth:2}),d=j(a),e=Math.atan2(d[1].y-d[0].y,d[1].x-d[0].x),d=i(d,e,10),null===d?null:(f=k(d),null===f&&(f=l(a,d,e)),null===f?null:(f&&c.drawScanline&&g&&b.drawPath(d,{x:"x",y:"y"},g,{color:"red",lineWidth:3}),{codeResult:f.codeResult,line:d,angle:e,pattern:f.barcodeLine.line,threshold:f.barcodeLine.threshold}))}var n={ctx:{frequency:null,pattern:null,overlay:null},dom:{frequency:null,pattern:null,overlay:null}},o=[],p=null;return f(),g(),h(),{decodeFromBoundingBox:function(a){return m(a)},decodeFromBoundingBoxes:function(a){var b,c;for(b=0;b1?(k.x=i.size,k.y=j.y/j.x*i.size):(k.y=i.size,k.x=j.x/j.y*i.size)),d=j.x,e=k.x,f=j.y,g=k.y,p=c?c:document.createElement("canvas"),p.width=k.x,p.height=k.y,q=p.getContext("2d"),r=new Uint8Array(k.x*k.y),h.attachData=function(a){r=a},h.getData=function(){return r},h.grab=function(){var c,h=i.halfSample,j=b.getFrame();return j?(q.drawImage(j,l,m,d,f,n,o,e,g),c=q.getImageData(0,0,k.x,k.y).data,h?a.grayAndHalfSampleFromCanvasData(c,k,r):a.computeGray(c,r),!0):!1},h.getSize=function(){return k},h},b}),c("html_utils",[],function(){function a(a){var b=document.createElement("div");for(b.innerHTML=a;b.firstChild;)return b.firstChild}function b(a,c){for(var d in c)try{a[d]=c[d].constructor==Object?b(a[d],c[d]):c[d]}catch(e){a[d]=c[d]}return a}return{createNode:function(b){return a(b)},mergeObjects:function(a,c){return b(a,c)}}}),c("config",[],function(){var a={inputStream:{name:"Live",type:"LiveStream"},tracking:!1,debug:!1,controls:!1,locate:!0,visual:{show:!0},decoder:{drawBoundingBox:!0,showFrequency:!1,drawScanline:!0,showPattern:!1,readers:["code_128_reader"]},locator:{showCanvas:!1,showPatches:!1,showFoundPatches:!1,showSkeleton:!1,showLabels:!1,showPatchLabels:!1,showRemainingPatchLabels:!1,boxFromPatches:{showTransformed:!1,showTransformedBox:!1,showBB:!1}}};return a}),c("events",[],function(){var a=function(){function a(a){return e[a]||(e[a]={subscribers:[]}),e[a]}function b(){e={}}function c(a,b){a.async?setTimeout(function(){a.callback.call(null,b)},4):a.callback.call(null,b)}function d(b,c,d){var e;if("function"==typeof c)e={callback:c,async:d};else if(e=c,!e.callback)throw"Callback was not specified on options";a(b).subscribers.push(e)}var e={};return{subscribe:function(a,b,c){return d(a,b,c)},publish:function(b,d){var e=a(b),f=e.subscribers;e.subscribers=f.filter(function(a){return c(a,d),!a.once})},once:function(a,b,c){d(a,{callback:b,async:c,once:!0})},unsubscribe:function(c,d){var e;c?(e=a(c),e.subscribers=e&&d?e.subscribers.filter(function(a){return a.callback!==d}):[]):b()}}}();return a}),c("camera_access",[],function(){function a(a,b,c){navigator.getUserMedia(a,function(a){d=a;var c=window.URL&&window.URL.createObjectURL(a)||a;b.apply(null,[c])},c)}function b(b,c,d){a(b,function(a){c.src=a,c.addEventListener("loadeddata",function(){function a(){b>0?c.videoWidth>0&&c.videoHeight>0?(console.log(c.videoWidth+"px x "+c.videoHeight+"px"),d()):window.setTimeout(a,500):d("Unable to play video stream. Is webcam working?"),b--}var b=10;a()},!1),c.play()},function(a){console.log(a)})}function c(a,c){"undefined"!=typeof MediaStreamTrack.getSources?MediaStreamTrack.getSources(function(d){for(var e,f=0;f!=d.length;++f){var g=d[f];"video"==g.kind&&"environment"==g.facing&&(e=g.id)}var h={audio:!1,video:{optional:[{sourceId:e}]}};b(h,a,c)}):b({video:!0,audio:!1},a,c)}var d;return{request:function(a,b){c(a,b)},release:function(){var a=d&&d.getVideoTracks();a.length&&a[0].stop(),d=null}}}),c("quagga",["code_128_reader","ean_reader","input_stream","image_wrapper","barcode_locator","barcode_decoder","frame_grabber","html_utils","config","events","camera_access"],function(a,b,c,d,e,f,g,h,j,k,l){function m(a){j=h.mergeObjects(j,a),o()}function n(){for(var a=[{node:document.querySelector("div[data-controls]"),prop:j.controls},{node:B.dom.overlay,prop:j.visual.show}],b=0;b Date: Sun, 18 Jan 2015 22:11:41 +0100 Subject: [PATCH 4/9] Spawning multiple workers for entire pipeline; API change for Quagga.init; Added async-library --- Gruntfile.js | 7 +- dist/quagga.js | 1555 ++++++++++++++++++++++++++++++++----- example/live_w_locator.js | 7 +- example/static_images.js | 7 +- src/barcode_decoder.js | 8 +- src/barcode_locator.js | 133 +--- src/config.js | 8 +- src/quagga.js | 284 +++++-- src/vendor/async.js | 1123 ++++++++++++++++++++++++++ 9 files changed, 2756 insertions(+), 376 deletions(-) create mode 100644 src/vendor/async.js diff --git a/Gruntfile.js b/Gruntfile.js index c3f88ad..a76d850 100644 --- a/Gruntfile.js +++ b/Gruntfile.js @@ -48,13 +48,18 @@ module.exports = function(grunt) { "glMatrixAddon" : { "deps" : ["glMatrix"], "exports" : "glMatrixAddon" + }, + "async": { + "deps": [], + "exports": "async" } }, "paths" : { "typedefs" : "typedefs", "glMatrix" : "vendor/glMatrix", - "glMatrixAddon" : "glMatrixAddon" + "glMatrixAddon" : "glMatrixAddon", + "async": "vendor/async" } } } diff --git a/dist/quagga.js b/dist/quagga.js index 30a3d7f..c7e3918 100644 --- a/dist/quagga.js +++ b/dist/quagga.js @@ -5721,10 +5721,7 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I _numPatches = {x: 0, y: 0}, _inputImageWrapper, _skeletonizer, - self = this, - _worker, - _locatedCb, - _initialized; + self = this; function initBuffers() { var skeletonImageData; @@ -6172,122 +6169,44 @@ function(ImageWrapper, CVUtils, Rasterizer, Tracer, skeletonizer, ArrayHelper, I return label; } - function initWorker(cb) { - var tmpData, - blobURL; - - blobURL = generateWorkerBlob(); - _worker = new Worker(blobURL); - URL.revokeObjectURL(blobURL); - - tmpData = _inputImageWrapper.data; - _inputImageWrapper.data = null; // do not send the data along - _worker.postMessage({cmd: 'init', inputImageWrapper: _inputImageWrapper, config: _config}); - _inputImageWrapper.data = tmpData; - _worker.onmessage = function(e) { - if (e.data.event === 'initialized') { - _initialized = true; - cb(); - } else if (e.data.event === 'located') { - _inputImageWrapper.data = new Uint8Array(e.data.buffer); - _locatedCb(e.data.result); - } - }; - } - - function generateWorkerBlob() { - var blob, - quaggaAbsoluteUrl, - scripts = document.getElementsByTagName('script'), - regex = new RegExp('\/' + _config.scriptName + '$'); - - quaggaAbsoluteUrl = Array.prototype.slice.apply(scripts).filter(function(script) { - return script.src && script.src.match(regex); - }).map(function(script) { - return script.src; - })[0]; - - /* jshint ignore:start */ - blob = new Blob(['(' + - (function(scriptUrl){ - importScripts(scriptUrl); - var inputImageWrapper, - config, - Locator = Quagga.Locator; - - self.onmessage = function(e) { - if (e.data.cmd === 'init') { - inputImageWrapper = e.data.inputImageWrapper; - config = e.data.config; - - config.useWorker = false; - Locator.init(inputImageWrapper, config, function() { - self.postMessage({'event': 'initialized'}); - }); - } else if (e.data.cmd === 'locate') { - inputImageWrapper.data = new Uint8Array(e.data.buffer); - Locator.locate(function(result) { - self.postMessage({'event': 'located', result: result, buffer : inputImageWrapper.data}, [inputImageWrapper.data.buffer]); - }); - } - }; - }).toString() + ')("' + quaggaAbsoluteUrl + '");' - ], {type : 'text/javascript'}); - - /* jshint ignore:end */ - return window.URL.createObjectURL(blob); - } - - return { - init : function(inputImageWrapper, config, cb) { + init : function(inputImageWrapper, config) { _config = config; _inputImageWrapper = inputImageWrapper; - // 1. check config for web-worker - if (_config.useWorker) { - initWorker(cb); - } else { - initBuffers(); - initCanvas(); - cb(); - } + initBuffers(); + initCanvas(); }, - locate : function(cb) { + locate : function() { var patchesFound, topLabels = [], boxes = []; - if (_config.useWorker) { - _locatedCb = cb; - _worker.postMessage({cmd: 'locate', buffer: _inputImageWrapper.data}, [_inputImageWrapper.data.buffer]); - } else { - if (_config.halfSample) { - CVUtils.halfSample(_inputImageWrapper, _currentImageWrapper); - } - - binarizeImage(); - patchesFound = findPatches(); - // return unless 5% or more patches are found - if (patchesFound.length < _numPatches.x * _numPatches.y * 0.05) { - return cb(null); - } + if (_config.halfSample) { + CVUtils.halfSample(_inputImageWrapper, _currentImageWrapper); + } - // rasterrize area by comparing angular similarity; - var maxLabel = rasterizeAngularSimilarity(patchesFound); - if (maxLabel <= 1) { - return cb(null); - } + binarizeImage(); + patchesFound = findPatches(); + // return unless 5% or more patches are found + if (patchesFound.length < _numPatches.x * _numPatches.y * 0.05) { + return null; + } - // search for area with the most patches (biggest connected area) - topLabels = findBiggestConnectedAreas(maxLabel); - if (topLabels.length === 0) { - return cb(null); - } + // rasterrize area by comparing angular similarity; + var maxLabel = rasterizeAngularSimilarity(patchesFound); + if (maxLabel <= 1) { + return null; + } - boxes = findBoxes(topLabels, maxLabel); - cb(boxes); + // search for area with the most patches (biggest connected area) + topLabels = findBiggestConnectedAreas(maxLabel); + if (topLabels.length === 0) { + return null; } + + boxes = findBoxes(topLabels, maxLabel); + return boxes; } }; }); @@ -6526,7 +6445,7 @@ define('barcode_decoder',["bresenham", "image_debug", 'code_128_reader', 'ean_re initConfig(); function initCanvas() { - var $debug = document.querySelector("#debug.detection"); + /* var $debug = document.querySelector("#debug.detection"); _canvas.dom.frequency = document.querySelector("canvas.frequency"); if (!_canvas.dom.frequency) { _canvas.dom.frequency = document.createElement("canvas"); @@ -6550,7 +6469,7 @@ define('barcode_decoder',["bresenham", "image_debug", 'code_128_reader', 'ean_re _canvas.dom.overlay = document.querySelector("canvas.drawingBuffer"); if (_canvas.dom.overlay) { _canvas.ctx.overlay = _canvas.dom.overlay.getContext("2d"); - } + } */ } function initReaders() { @@ -6562,7 +6481,7 @@ define('barcode_decoder',["bresenham", "image_debug", 'code_128_reader', 'ean_re } function initConfig() { - var i, + /* var i, vis = [{ node : _canvas.dom.frequency, prop : config.showFrequency @@ -6577,7 +6496,7 @@ define('barcode_decoder',["bresenham", "image_debug", 'code_128_reader', 'ean_re } else { vis[i].node.style.display = "none"; } - } + } */ } /** @@ -6892,13 +6811,15 @@ define('config',[],function(){ debug: false, controls: false, locate: true, + numOfWorkers: 4, + scriptName: 'quagga.js', visual: { show: true }, decoder:{ - drawBoundingBox: true, + drawBoundingBox: false, showFrequency: false, - drawScanline: true, + drawScanline: false, showPattern: false, readers: [ 'code_128_reader' @@ -6906,8 +6827,6 @@ define('config',[],function(){ }, locator: { halfSample: true, - useWorker: true, - scriptName: 'quagga.js', showCanvas: false, showPatches: false, showFoundPatches: false, @@ -7119,11 +7038,1135 @@ define('camera_access',[],function() { } }; }); +/*! + * async + * https://github.com/caolan/async + * + * Copyright 2010-2014 Caolan McMahon + * Released under the MIT license + */ +/*jshint onevar: false, indent:4 */ +/*global setImmediate: false, setTimeout: false, console: false */ +(function () { + + var async = {}; + + // global on the server, window in the browser + var root, previous_async; + + root = this; + if (root != null) { + previous_async = root.async; + } + + async.noConflict = function () { + root.async = previous_async; + return async; + }; + + function only_once(fn) { + var called = false; + return function() { + if (called) throw new Error("Callback was already called."); + called = true; + fn.apply(root, arguments); + } + } + + //// cross-browser compatiblity functions //// + + var _toString = Object.prototype.toString; + + var _isArray = Array.isArray || function (obj) { + return _toString.call(obj) === '[object Array]'; + }; + + var _each = function (arr, iterator) { + for (var i = 0; i < arr.length; i += 1) { + iterator(arr[i], i, arr); + } + }; + + var _map = function (arr, iterator) { + if (arr.map) { + return arr.map(iterator); + } + var results = []; + _each(arr, function (x, i, a) { + results.push(iterator(x, i, a)); + }); + return results; + }; + + var _reduce = function (arr, iterator, memo) { + if (arr.reduce) { + return arr.reduce(iterator, memo); + } + _each(arr, function (x, i, a) { + memo = iterator(memo, x, i, a); + }); + return memo; + }; + + var _keys = function (obj) { + if (Object.keys) { + return Object.keys(obj); + } + var keys = []; + for (var k in obj) { + if (obj.hasOwnProperty(k)) { + keys.push(k); + } + } + return keys; + }; + + //// exported async module functions //// + + //// nextTick implementation with browser-compatible fallback //// + if (typeof process === 'undefined' || !(process.nextTick)) { + if (typeof setImmediate === 'function') { + async.nextTick = function (fn) { + // not a direct alias for IE10 compatibility + setImmediate(fn); + }; + async.setImmediate = async.nextTick; + } + else { + async.nextTick = function (fn) { + setTimeout(fn, 0); + }; + async.setImmediate = async.nextTick; + } + } + else { + async.nextTick = process.nextTick; + if (typeof setImmediate !== 'undefined') { + async.setImmediate = function (fn) { + // not a direct alias for IE10 compatibility + setImmediate(fn); + }; + } + else { + async.setImmediate = async.nextTick; + } + } + + async.each = function (arr, iterator, callback) { + callback = callback || function () {}; + if (!arr.length) { + return callback(); + } + var completed = 0; + _each(arr, function (x) { + iterator(x, only_once(done) ); + }); + function done(err) { + if (err) { + callback(err); + callback = function () {}; + } + else { + completed += 1; + if (completed >= arr.length) { + callback(); + } + } + } + }; + async.forEach = async.each; + + async.eachSeries = function (arr, iterator, callback) { + callback = callback || function () {}; + if (!arr.length) { + return callback(); + } + var completed = 0; + var iterate = function () { + iterator(arr[completed], function (err) { + if (err) { + callback(err); + callback = function () {}; + } + else { + completed += 1; + if (completed >= arr.length) { + callback(); + } + else { + iterate(); + } + } + }); + }; + iterate(); + }; + async.forEachSeries = async.eachSeries; + + async.eachLimit = function (arr, limit, iterator, callback) { + var fn = _eachLimit(limit); + fn.apply(null, [arr, iterator, callback]); + }; + async.forEachLimit = async.eachLimit; + + var _eachLimit = function (limit) { + + return function (arr, iterator, callback) { + callback = callback || function () {}; + if (!arr.length || limit <= 0) { + return callback(); + } + var completed = 0; + var started = 0; + var running = 0; + + (function replenish () { + if (completed >= arr.length) { + return callback(); + } + + while (running < limit && started < arr.length) { + started += 1; + running += 1; + iterator(arr[started - 1], function (err) { + if (err) { + callback(err); + callback = function () {}; + } + else { + completed += 1; + running -= 1; + if (completed >= arr.length) { + callback(); + } + else { + replenish(); + } + } + }); + } + })(); + }; + }; + + + var doParallel = function (fn) { + return function () { + var args = Array.prototype.slice.call(arguments); + return fn.apply(null, [async.each].concat(args)); + }; + }; + var doParallelLimit = function(limit, fn) { + return function () { + var args = Array.prototype.slice.call(arguments); + return fn.apply(null, [_eachLimit(limit)].concat(args)); + }; + }; + var doSeries = function (fn) { + return function () { + var args = Array.prototype.slice.call(arguments); + return fn.apply(null, [async.eachSeries].concat(args)); + }; + }; + + + var _asyncMap = function (eachfn, arr, iterator, callback) { + arr = _map(arr, function (x, i) { + return {index: i, value: x}; + }); + if (!callback) { + eachfn(arr, function (x, callback) { + iterator(x.value, function (err) { + callback(err); + }); + }); + } else { + var results = []; + eachfn(arr, function (x, callback) { + iterator(x.value, function (err, v) { + results[x.index] = v; + callback(err); + }); + }, function (err) { + callback(err, results); + }); + } + }; + async.map = doParallel(_asyncMap); + async.mapSeries = doSeries(_asyncMap); + async.mapLimit = function (arr, limit, iterator, callback) { + return _mapLimit(limit)(arr, iterator, callback); + }; + + var _mapLimit = function(limit) { + return doParallelLimit(limit, _asyncMap); + }; + + // reduce only has a series version, as doing reduce in parallel won't + // work in many situations. + async.reduce = function (arr, memo, iterator, callback) { + async.eachSeries(arr, function (x, callback) { + iterator(memo, x, function (err, v) { + memo = v; + callback(err); + }); + }, function (err) { + callback(err, memo); + }); + }; + // inject alias + async.inject = async.reduce; + // foldl alias + async.foldl = async.reduce; + + async.reduceRight = function (arr, memo, iterator, callback) { + var reversed = _map(arr, function (x) { + return x; + }).reverse(); + async.reduce(reversed, memo, iterator, callback); + }; + // foldr alias + async.foldr = async.reduceRight; + + var _filter = function (eachfn, arr, iterator, callback) { + var results = []; + arr = _map(arr, function (x, i) { + return {index: i, value: x}; + }); + eachfn(arr, function (x, callback) { + iterator(x.value, function (v) { + if (v) { + results.push(x); + } + callback(); + }); + }, function (err) { + callback(_map(results.sort(function (a, b) { + return a.index - b.index; + }), function (x) { + return x.value; + })); + }); + }; + async.filter = doParallel(_filter); + async.filterSeries = doSeries(_filter); + // select alias + async.select = async.filter; + async.selectSeries = async.filterSeries; + + var _reject = function (eachfn, arr, iterator, callback) { + var results = []; + arr = _map(arr, function (x, i) { + return {index: i, value: x}; + }); + eachfn(arr, function (x, callback) { + iterator(x.value, function (v) { + if (!v) { + results.push(x); + } + callback(); + }); + }, function (err) { + callback(_map(results.sort(function (a, b) { + return a.index - b.index; + }), function (x) { + return x.value; + })); + }); + }; + async.reject = doParallel(_reject); + async.rejectSeries = doSeries(_reject); + + var _detect = function (eachfn, arr, iterator, main_callback) { + eachfn(arr, function (x, callback) { + iterator(x, function (result) { + if (result) { + main_callback(x); + main_callback = function () {}; + } + else { + callback(); + } + }); + }, function (err) { + main_callback(); + }); + }; + async.detect = doParallel(_detect); + async.detectSeries = doSeries(_detect); + + async.some = function (arr, iterator, main_callback) { + async.each(arr, function (x, callback) { + iterator(x, function (v) { + if (v) { + main_callback(true); + main_callback = function () {}; + } + callback(); + }); + }, function (err) { + main_callback(false); + }); + }; + // any alias + async.any = async.some; + + async.every = function (arr, iterator, main_callback) { + async.each(arr, function (x, callback) { + iterator(x, function (v) { + if (!v) { + main_callback(false); + main_callback = function () {}; + } + callback(); + }); + }, function (err) { + main_callback(true); + }); + }; + // all alias + async.all = async.every; + + async.sortBy = function (arr, iterator, callback) { + async.map(arr, function (x, callback) { + iterator(x, function (err, criteria) { + if (err) { + callback(err); + } + else { + callback(null, {value: x, criteria: criteria}); + } + }); + }, function (err, results) { + if (err) { + return callback(err); + } + else { + var fn = function (left, right) { + var a = left.criteria, b = right.criteria; + return a < b ? -1 : a > b ? 1 : 0; + }; + callback(null, _map(results.sort(fn), function (x) { + return x.value; + })); + } + }); + }; + + async.auto = function (tasks, callback) { + callback = callback || function () {}; + var keys = _keys(tasks); + var remainingTasks = keys.length + if (!remainingTasks) { + return callback(); + } + + var results = {}; + + var listeners = []; + var addListener = function (fn) { + listeners.unshift(fn); + }; + var removeListener = function (fn) { + for (var i = 0; i < listeners.length; i += 1) { + if (listeners[i] === fn) { + listeners.splice(i, 1); + return; + } + } + }; + var taskComplete = function () { + remainingTasks-- + _each(listeners.slice(0), function (fn) { + fn(); + }); + }; + + addListener(function () { + if (!remainingTasks) { + var theCallback = callback; + // prevent final callback from calling itself if it errors + callback = function () {}; + + theCallback(null, results); + } + }); + + _each(keys, function (k) { + var task = _isArray(tasks[k]) ? tasks[k]: [tasks[k]]; + var taskCallback = function (err) { + var args = Array.prototype.slice.call(arguments, 1); + if (args.length <= 1) { + args = args[0]; + } + if (err) { + var safeResults = {}; + _each(_keys(results), function(rkey) { + safeResults[rkey] = results[rkey]; + }); + safeResults[k] = args; + callback(err, safeResults); + // stop subsequent errors hitting callback multiple times + callback = function () {}; + } + else { + results[k] = args; + async.setImmediate(taskComplete); + } + }; + var requires = task.slice(0, Math.abs(task.length - 1)) || []; + var ready = function () { + return _reduce(requires, function (a, x) { + return (a && results.hasOwnProperty(x)); + }, true) && !results.hasOwnProperty(k); + }; + if (ready()) { + task[task.length - 1](taskCallback, results); + } + else { + var listener = function () { + if (ready()) { + removeListener(listener); + task[task.length - 1](taskCallback, results); + } + }; + addListener(listener); + } + }); + }; + + async.retry = function(times, task, callback) { + var DEFAULT_TIMES = 5; + var attempts = []; + // Use defaults if times not passed + if (typeof times === 'function') { + callback = task; + task = times; + times = DEFAULT_TIMES; + } + // Make sure times is a number + times = parseInt(times, 10) || DEFAULT_TIMES; + var wrappedTask = function(wrappedCallback, wrappedResults) { + var retryAttempt = function(task, finalAttempt) { + return function(seriesCallback) { + task(function(err, result){ + seriesCallback(!err || finalAttempt, {err: err, result: result}); + }, wrappedResults); + }; + }; + while (times) { + attempts.push(retryAttempt(task, !(times-=1))); + } + async.series(attempts, function(done, data){ + data = data[data.length - 1]; + (wrappedCallback || callback)(data.err, data.result); + }); + } + // If a callback is passed, run this as a controll flow + return callback ? wrappedTask() : wrappedTask + }; + + async.waterfall = function (tasks, callback) { + callback = callback || function () {}; + if (!_isArray(tasks)) { + var err = new Error('First argument to waterfall must be an array of functions'); + return callback(err); + } + if (!tasks.length) { + return callback(); + } + var wrapIterator = function (iterator) { + return function (err) { + if (err) { + callback.apply(null, arguments); + callback = function () {}; + } + else { + var args = Array.prototype.slice.call(arguments, 1); + var next = iterator.next(); + if (next) { + args.push(wrapIterator(next)); + } + else { + args.push(callback); + } + async.setImmediate(function () { + iterator.apply(null, args); + }); + } + }; + }; + wrapIterator(async.iterator(tasks))(); + }; + + var _parallel = function(eachfn, tasks, callback) { + callback = callback || function () {}; + if (_isArray(tasks)) { + eachfn.map(tasks, function (fn, callback) { + if (fn) { + fn(function (err) { + var args = Array.prototype.slice.call(arguments, 1); + if (args.length <= 1) { + args = args[0]; + } + callback.call(null, err, args); + }); + } + }, callback); + } + else { + var results = {}; + eachfn.each(_keys(tasks), function (k, callback) { + tasks[k](function (err) { + var args = Array.prototype.slice.call(arguments, 1); + if (args.length <= 1) { + args = args[0]; + } + results[k] = args; + callback(err); + }); + }, function (err) { + callback(err, results); + }); + } + }; + + async.parallel = function (tasks, callback) { + _parallel({ map: async.map, each: async.each }, tasks, callback); + }; + + async.parallelLimit = function(tasks, limit, callback) { + _parallel({ map: _mapLimit(limit), each: _eachLimit(limit) }, tasks, callback); + }; + + async.series = function (tasks, callback) { + callback = callback || function () {}; + if (_isArray(tasks)) { + async.mapSeries(tasks, function (fn, callback) { + if (fn) { + fn(function (err) { + var args = Array.prototype.slice.call(arguments, 1); + if (args.length <= 1) { + args = args[0]; + } + callback.call(null, err, args); + }); + } + }, callback); + } + else { + var results = {}; + async.eachSeries(_keys(tasks), function (k, callback) { + tasks[k](function (err) { + var args = Array.prototype.slice.call(arguments, 1); + if (args.length <= 1) { + args = args[0]; + } + results[k] = args; + callback(err); + }); + }, function (err) { + callback(err, results); + }); + } + }; + + async.iterator = function (tasks) { + var makeCallback = function (index) { + var fn = function () { + if (tasks.length) { + tasks[index].apply(null, arguments); + } + return fn.next(); + }; + fn.next = function () { + return (index < tasks.length - 1) ? makeCallback(index + 1): null; + }; + return fn; + }; + return makeCallback(0); + }; + + async.apply = function (fn) { + var args = Array.prototype.slice.call(arguments, 1); + return function () { + return fn.apply( + null, args.concat(Array.prototype.slice.call(arguments)) + ); + }; + }; + + var _concat = function (eachfn, arr, fn, callback) { + var r = []; + eachfn(arr, function (x, cb) { + fn(x, function (err, y) { + r = r.concat(y || []); + cb(err); + }); + }, function (err) { + callback(err, r); + }); + }; + async.concat = doParallel(_concat); + async.concatSeries = doSeries(_concat); + + async.whilst = function (test, iterator, callback) { + if (test()) { + iterator(function (err) { + if (err) { + return callback(err); + } + async.whilst(test, iterator, callback); + }); + } + else { + callback(); + } + }; + + async.doWhilst = function (iterator, test, callback) { + iterator(function (err) { + if (err) { + return callback(err); + } + var args = Array.prototype.slice.call(arguments, 1); + if (test.apply(null, args)) { + async.doWhilst(iterator, test, callback); + } + else { + callback(); + } + }); + }; + + async.until = function (test, iterator, callback) { + if (!test()) { + iterator(function (err) { + if (err) { + return callback(err); + } + async.until(test, iterator, callback); + }); + } + else { + callback(); + } + }; + + async.doUntil = function (iterator, test, callback) { + iterator(function (err) { + if (err) { + return callback(err); + } + var args = Array.prototype.slice.call(arguments, 1); + if (!test.apply(null, args)) { + async.doUntil(iterator, test, callback); + } + else { + callback(); + } + }); + }; + + async.queue = function (worker, concurrency) { + if (concurrency === undefined) { + concurrency = 1; + } + function _insert(q, data, pos, callback) { + if (!q.started){ + q.started = true; + } + if (!_isArray(data)) { + data = [data]; + } + if(data.length == 0) { + // call drain immediately if there are no tasks + return async.setImmediate(function() { + if (q.drain) { + q.drain(); + } + }); + } + _each(data, function(task) { + var item = { + data: task, + callback: typeof callback === 'function' ? callback : null + }; + + if (pos) { + q.tasks.unshift(item); + } else { + q.tasks.push(item); + } + + if (q.saturated && q.tasks.length === q.concurrency) { + q.saturated(); + } + async.setImmediate(q.process); + }); + } + + var workers = 0; + var q = { + tasks: [], + concurrency: concurrency, + saturated: null, + empty: null, + drain: null, + started: false, + paused: false, + push: function (data, callback) { + _insert(q, data, false, callback); + }, + kill: function () { + q.drain = null; + q.tasks = []; + }, + unshift: function (data, callback) { + _insert(q, data, true, callback); + }, + process: function () { + if (!q.paused && workers < q.concurrency && q.tasks.length) { + var task = q.tasks.shift(); + if (q.empty && q.tasks.length === 0) { + q.empty(); + } + workers += 1; + var next = function () { + workers -= 1; + if (task.callback) { + task.callback.apply(task, arguments); + } + if (q.drain && q.tasks.length + workers === 0) { + q.drain(); + } + q.process(); + }; + var cb = only_once(next); + worker(task.data, cb); + } + }, + length: function () { + return q.tasks.length; + }, + running: function () { + return workers; + }, + idle: function() { + return q.tasks.length + workers === 0; + }, + pause: function () { + if (q.paused === true) { return; } + q.paused = true; + }, + resume: function () { + if (q.paused === false) { return; } + q.paused = false; + // Need to call q.process once per concurrent + // worker to preserve full concurrency after pause + for (var w = 1; w <= q.concurrency; w++) { + async.setImmediate(q.process); + } + } + }; + return q; + }; + + async.priorityQueue = function (worker, concurrency) { + + function _compareTasks(a, b){ + return a.priority - b.priority; + }; + + function _binarySearch(sequence, item, compare) { + var beg = -1, + end = sequence.length - 1; + while (beg < end) { + var mid = beg + ((end - beg + 1) >>> 1); + if (compare(item, sequence[mid]) >= 0) { + beg = mid; + } else { + end = mid - 1; + } + } + return beg; + } + + function _insert(q, data, priority, callback) { + if (!q.started){ + q.started = true; + } + if (!_isArray(data)) { + data = [data]; + } + if(data.length == 0) { + // call drain immediately if there are no tasks + return async.setImmediate(function() { + if (q.drain) { + q.drain(); + } + }); + } + _each(data, function(task) { + var item = { + data: task, + priority: priority, + callback: typeof callback === 'function' ? callback : null + }; + + q.tasks.splice(_binarySearch(q.tasks, item, _compareTasks) + 1, 0, item); + + if (q.saturated && q.tasks.length === q.concurrency) { + q.saturated(); + } + async.setImmediate(q.process); + }); + } + + // Start with a normal queue + var q = async.queue(worker, concurrency); + + // Override push to accept second parameter representing priority + q.push = function (data, priority, callback) { + _insert(q, data, priority, callback); + }; + + // Remove unshift function + delete q.unshift; + + return q; + }; + + async.cargo = function (worker, payload) { + var working = false, + tasks = []; + + var cargo = { + tasks: tasks, + payload: payload, + saturated: null, + empty: null, + drain: null, + drained: true, + push: function (data, callback) { + if (!_isArray(data)) { + data = [data]; + } + _each(data, function(task) { + tasks.push({ + data: task, + callback: typeof callback === 'function' ? callback : null + }); + cargo.drained = false; + if (cargo.saturated && tasks.length === payload) { + cargo.saturated(); + } + }); + async.setImmediate(cargo.process); + }, + process: function process() { + if (working) return; + if (tasks.length === 0) { + if(cargo.drain && !cargo.drained) cargo.drain(); + cargo.drained = true; + return; + } + + var ts = typeof payload === 'number' + ? tasks.splice(0, payload) + : tasks.splice(0, tasks.length); + + var ds = _map(ts, function (task) { + return task.data; + }); + + if(cargo.empty) cargo.empty(); + working = true; + worker(ds, function () { + working = false; + + var args = arguments; + _each(ts, function (data) { + if (data.callback) { + data.callback.apply(null, args); + } + }); + + process(); + }); + }, + length: function () { + return tasks.length; + }, + running: function () { + return working; + } + }; + return cargo; + }; + + var _console_fn = function (name) { + return function (fn) { + var args = Array.prototype.slice.call(arguments, 1); + fn.apply(null, args.concat([function (err) { + var args = Array.prototype.slice.call(arguments, 1); + if (typeof console !== 'undefined') { + if (err) { + if (console.error) { + console.error(err); + } + } + else if (console[name]) { + _each(args, function (x) { + console[name](x); + }); + } + } + }])); + }; + }; + async.log = _console_fn('log'); + async.dir = _console_fn('dir'); + /*async.info = _console_fn('info'); + async.warn = _console_fn('warn'); + async.error = _console_fn('error');*/ + + async.memoize = function (fn, hasher) { + var memo = {}; + var queues = {}; + hasher = hasher || function (x) { + return x; + }; + var memoized = function () { + var args = Array.prototype.slice.call(arguments); + var callback = args.pop(); + var key = hasher.apply(null, args); + if (key in memo) { + async.nextTick(function () { + callback.apply(null, memo[key]); + }); + } + else if (key in queues) { + queues[key].push(callback); + } + else { + queues[key] = [callback]; + fn.apply(null, args.concat([function () { + memo[key] = arguments; + var q = queues[key]; + delete queues[key]; + for (var i = 0, l = q.length; i < l; i++) { + q[i].apply(null, arguments); + } + }])); + } + }; + memoized.memo = memo; + memoized.unmemoized = fn; + return memoized; + }; + + async.unmemoize = function (fn) { + return function () { + return (fn.unmemoized || fn).apply(null, arguments); + }; + }; + + async.times = function (count, iterator, callback) { + var counter = []; + for (var i = 0; i < count; i++) { + counter.push(i); + } + return async.map(counter, iterator, callback); + }; + + async.timesSeries = function (count, iterator, callback) { + var counter = []; + for (var i = 0; i < count; i++) { + counter.push(i); + } + return async.mapSeries(counter, iterator, callback); + }; + + async.seq = function (/* functions... */) { + var fns = arguments; + return function () { + var that = this; + var args = Array.prototype.slice.call(arguments); + var callback = args.pop(); + async.reduce(fns, args, function (newargs, fn, cb) { + fn.apply(that, newargs.concat([function () { + var err = arguments[0]; + var nextargs = Array.prototype.slice.call(arguments, 1); + cb(err, nextargs); + }])) + }, + function (err, results) { + callback.apply(that, [err].concat(results)); + }); + }; + }; + + async.compose = function (/* functions... */) { + return async.seq.apply(null, Array.prototype.reverse.call(arguments)); + }; + + var _applyEach = function (eachfn, fns /*args...*/) { + var go = function () { + var that = this; + var args = Array.prototype.slice.call(arguments); + var callback = args.pop(); + return eachfn(fns, function (fn, cb) { + fn.apply(that, args.concat([cb])); + }, + callback); + }; + if (arguments.length > 2) { + var args = Array.prototype.slice.call(arguments, 2); + return go.apply(this, args); + } + else { + return go; + } + }; + async.applyEach = doParallel(_applyEach); + async.applyEachSeries = doSeries(_applyEach); + + async.forever = function (fn, callback) { + function next(err) { + if (err) { + if (callback) { + return callback(err); + } + throw err; + } + fn(next); + } + next(); + }; + + // Node.js + if (typeof module !== 'undefined' && module.exports) { + module.exports = async; + } + // AMD / RequireJS + else if (typeof define !== 'undefined' && define.amd) { + define('async',[], function () { + return async; + }); + } + // included directly via