From 6d05be3a44d28479b6e1328e2814f8e656756910 Mon Sep 17 00:00:00 2001 From: Christoph Oberhofer Date: Sat, 30 Jul 2016 17:54:23 +0200 Subject: [PATCH] Added v1.0.0-beta.1 examples --- Gemfile.lock | 7 + _layouts/examples.html | 6 +- stylesheets/example.css | 33 +- v1.0.0-beta.1/examples/file_input.html | 86 + v1.0.0-beta.1/examples/file_input.js | 185 + v1.0.0-beta.1/examples/index.md | 29 + v1.0.0-beta.1/examples/js/quagga.js | 15661 +++++++++++++++++++ v1.0.0-beta.1/examples/js/quagga.min.js | 4 + v1.0.0-beta.1/examples/live_w_locator.html | 81 + v1.0.0-beta.1/examples/live_w_locator.js | 180 + v1.0.0-beta.1/examples/static_images.html | 47 + v1.0.0-beta.1/examples/static_images.js | 183 + 12 files changed, 16480 insertions(+), 22 deletions(-) create mode 100644 v1.0.0-beta.1/examples/file_input.html create mode 100644 v1.0.0-beta.1/examples/file_input.js create mode 100644 v1.0.0-beta.1/examples/index.md create mode 100644 v1.0.0-beta.1/examples/js/quagga.js create mode 100644 v1.0.0-beta.1/examples/js/quagga.min.js create mode 100644 v1.0.0-beta.1/examples/live_w_locator.html create mode 100644 v1.0.0-beta.1/examples/live_w_locator.js create mode 100644 v1.0.0-beta.1/examples/static_images.html create mode 100644 v1.0.0-beta.1/examples/static_images.js diff --git a/Gemfile.lock b/Gemfile.lock index 586bcc8..a132787 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -25,6 +25,7 @@ GEM execjs (2.6.0) fast-stemmer (1.0.2) ffi (1.9.10) + ffi (1.9.10-x64-mingw32) ffi (1.9.10-x86-mingw32) gemoji (2.1.0) github-pages (39) @@ -105,6 +106,8 @@ GEM net-dns (0.8.0) nokogiri (1.6.6.2) mini_portile (~> 0.6.0) + nokogiri (1.6.6.2-x64-mingw32) + mini_portile (~> 0.6.0) nokogiri (1.6.6.2-x86-mingw32) mini_portile (~> 0.6.0) parslet (1.5.0) @@ -135,7 +138,11 @@ GEM PLATFORMS ruby + x64-mingw32 x86-mingw32 DEPENDENCIES github-pages + +BUNDLED WITH + 1.12.5 diff --git a/_layouts/examples.html b/_layouts/examples.html index 54c1eeb..4adb789 100644 --- a/_layouts/examples.html +++ b/_layouts/examples.html @@ -5,9 +5,9 @@ layout: default

Examples

{{ content }} diff --git a/stylesheets/example.css b/stylesheets/example.css index 89707dc..5856460 100644 --- a/stylesheets/example.css +++ b/stylesheets/example.css @@ -20,14 +20,19 @@ width: 640px; } -/* line 6, ../sass/_viewport.scss */ -#interactive.viewport canvas, video { - float: left; - width: 640px; +#interactive.viewport { + position: relative; } -/* line 10, ../sass/_viewport.scss */ -#interactive.viewport canvas.drawingBuffer, video.drawingBuffer { - margin-left: -640px; + +#interactive.viewport > canvas, #interactive.viewport > video { + max-width: 100%; + width: 100%; +} + +canvas.drawing, canvas.drawingBuffer { + position: absolute; + left: 0; + top: 0; } /* line 16, ../sass/_viewport.scss */ @@ -139,27 +144,17 @@ overflow: hidden; } - /* line 11, ../sass/phone/_viewport.scss */ - #interactive.viewport canvas, video { - width: 100%; - height: auto; - } - /* line 15, ../sass/phone/_viewport.scss */ - #interactive.viewport canvas.drawingBuffer, video.drawingBuffer { - margin-left: -300px; - } - /* line 20, ../sass/phone/_viewport.scss */ #result_strip { margin-top: 5px; padding-top: 5px; } - + #result_strip ul.thumbnails { width: 100%; height: auto; } - + /* line 24, ../sass/phone/_viewport.scss */ #result_strip ul.thumbnails > li { width: 150px; diff --git a/v1.0.0-beta.1/examples/file_input.html b/v1.0.0-beta.1/examples/file_input.html new file mode 100644 index 0000000..44b2508 --- /dev/null +++ b/v1.0.0-beta.1/examples/file_input.html @@ -0,0 +1,86 @@ +--- +layout: examples +title: Demo with file-input +showInMenu: false +--- + + +
+

Working with file-input

+

This example let's you select an image from your local filesystem. + There is no server interaction needed as the file is + simply accessed through the + File API. +

This also works great on a wide range of mobile-phones where the + camera access through getUserMedia is still very + limited.

+

If the default configuration does not suit your use-case, you can + adjust various parameters of the localization and decoding process.

+
+
+ + +
+
+ + + + + +
+
+
+
    +
    +
    + +
    +
    + + + diff --git a/v1.0.0-beta.1/examples/file_input.js b/v1.0.0-beta.1/examples/file_input.js new file mode 100644 index 0000000..f5cd40f --- /dev/null +++ b/v1.0.0-beta.1/examples/file_input.js @@ -0,0 +1,185 @@ +$(function() { + var App = { + init: function() { + this.overlay = document.querySelector('#interactive canvas.drawing'); + App.attachListeners(); + }, + attachListeners: function() { + var self = this; + + $(".controls input[type=file]").on("change", function(e) { + if (e.target.files && e.target.files.length) { + App.decode(e.target.files[0]); + } + }); + + $(".controls button").on("click", function(e) { + var input = document.querySelector(".controls input[type=file]"); + if (input.files && input.files.length) { + App.decode(input.files[0]); + } + }); + + $(".controls .reader-config-group").on("change", "input, select", function(e) { + e.preventDefault(); + var $target = $(e.target), + value = $target.attr("type") === "checkbox" ? $target.prop("checked") : $target.val(), + name = $target.attr("name"), + state = self._convertNameToState(name); + + console.log("Value of "+ state + " changed to " + value); + self.setState(state, value); + }); + + }, + _accessByPath: function(obj, path, val) { + var parts = path.split('.'), + depth = parts.length, + setter = (typeof val !== "undefined") ? true : false; + + return parts.reduce(function(o, key, i) { + if (setter && (i + 1) === depth) { + o[key] = val; + } + return key in o ? o[key] : {}; + }, obj); + }, + _convertNameToState: function(name) { + return name.replace("_", ".").split("-").reduce(function(result, value) { + return result + value.charAt(0).toUpperCase() + value.substring(1); + }); + }, + detachListeners: function() { + $(".controls input[type=file]").off("change"); + $(".controls .reader-config-group").off("change", "input, select"); + $(".controls button").off("click"); + + }, + decode: function(file) { + this.detachListeners(); + var scanner = Quagga + .config(this.state) + .fromSource(file, {size: this.state.inputStream.size}); + scanner + .toPromise() + .then(function(result) { + addToResults(scanner, result); + return result; + }) + .catch(function(result) { + console.log('Not found', result); + return result; + }) + .then(function(result) { + drawResult(scanner, result); + this.attachListeners(); + }.bind(this)); + }, + setState: function(path, value) { + var self = this; + + if (typeof self._accessByPath(self.inputMapper, path) === "function") { + value = self._accessByPath(self.inputMapper, path)(value); + } + + self._accessByPath(self.state, path, value); + + console.log(JSON.stringify(self.state)); + App.detachListeners(); + App.init(); + }, + inputMapper: { + inputStream: { + size: function(value){ + return parseInt(value); + } + }, + numOfWorkers: function(value) { + return parseInt(value); + }, + decoder: { + readers: function(value) { + if (value === 'ean_extended') { + return [{ + format: "ean_reader", + config: { + supplements: [ + 'ean_5_reader', 'ean_2_reader' + ] + } + }]; + } + return [{ + format: value + "_reader", + config: {} + }]; + } + } + }, + state: { + inputStream: { + size: 800 + }, + locator: { + patchSize: "medium", + halfSample: false + }, + numOfWorkers: 1, + decoder: { + readers: [{ + format: "code_128_reader", + config: {} + }] + }, + locate: true, + src: null + } + }; + + App.init(); + + function drawResult(scanner, result) { + var processingCanvas = scanner.getCanvas(), + canvas = App.overlay, + ctx = canvas.getContext("2d"); + + canvas.setAttribute('width', processingCanvas.getAttribute('width')); + canvas.setAttribute('height', processingCanvas.getAttribute('height')); + + if (result) { + if (result.boxes) { + ctx.clearRect(0, 0, parseInt(canvas.getAttribute("width")), parseInt(canvas.getAttribute("height"))); + result.boxes.filter(function (box) { + return box !== result.box; + }).forEach(function (box) { + Quagga.ImageDebug.drawPath(box, {x: 0, y: 1}, ctx, {color: "green", lineWidth: 2}); + }); + } + + if (result.box) { + Quagga.ImageDebug.drawPath(result.box, {x: 0, y: 1}, ctx, {color: "#00F", lineWidth: 2}); + } + + if (result.codeResult && result.codeResult.code) { + Quagga.ImageDebug.drawPath(result.line, {x: 'x', y: 'y'}, ctx, {color: 'red', lineWidth: 3}); + } + + if (App.state.inputStream.area) { + var area = calculateRectFromArea(canvas, App.state.inputStream.area); + drawingCtx.strokeStyle = "#0F0"; + drawingCtx.strokeRect(area.x, area.y, area.width, area.height); + } + } + }; + + function addToResults(scanner, result) { + var code = result.codeResult.code, + $node, + canvas = scanner.getCanvas(); + + $node = $('

    • '); + $node.find("img").attr("src", canvas.toDataURL()); + $node.find("h4.code").html(code); + $("#result_strip ul.thumbnails").prepend($node); + } +}); diff --git a/v1.0.0-beta.1/examples/index.md b/v1.0.0-beta.1/examples/index.md new file mode 100644 index 0000000..ada5fc6 --- /dev/null +++ b/v1.0.0-beta.1/examples/index.md @@ -0,0 +1,29 @@ +--- +layout: default +title: Examples +showInMenu: true +--- + +Examples +======== + +The following examples showcase some of the features offered by QuaggaJS. + +## Using static image files + +[This example](static_images.html) shows the capabilities of QuaggaJS using images taken under various conditions. + +[![Image 1]({{ site.baseurl }}/assets/example_static_01.jpg) ![Image 2]({{ site.baseurl }}/assets/example_static_02.jpg) ![Image 3]({{ site.baseurl }}/assets/example_static_03.jpg) ![Image 4]({{ site.baseurl }}/assets/example_static_04.jpg)](static_images.html) + +## Using the live-stream from your webcam + +This is the preferred mode of using QuaggaJS. [This example](live_w_locator.html) demonstrates the real-time decoding capabilities of QuaggaJS by using your +webcam as a barcode-scanner. + +[![Live 1]({{ site.baseurl }}/assets/example_live_01.jpg)](live_w_locator.html) + +## Using the File API + +Instead of directly accessing the user's webcam, [this example](file_input.html) shows you how to use QuaggaJS with the HTML5 File API to decode a pre-taken image. + +[![File Input 1]({{ site.baseurl }}/assets/example_file_input_01.jpg)](file_input.html) diff --git a/v1.0.0-beta.1/examples/js/quagga.js b/v1.0.0-beta.1/examples/js/quagga.js new file mode 100644 index 0000000..a567423 --- /dev/null +++ b/v1.0.0-beta.1/examples/js/quagga.js @@ -0,0 +1,15661 @@ +(function webpackUniversalModuleDefinition(root, factory) { + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(factory.toString()).default; + else if(typeof exports === 'object') + exports["Quagga"] = factory(factory.toString()).default; + else + root["Quagga"] = factory(factory.toString()).default; +})(this, function(__factorySource__) { +return /******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) +/******/ return installedModules[moduleId].e; +/******/ +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ e: {}, +/******/ i: moduleId, +/******/ l: false +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.e, module, module.e, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.e; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = "/"; +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(__webpack_require__.s = 220); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ function(module, exports, __webpack_require__) { + + /** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @type {Function} + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is correctly classified, + * else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */ + var isArray = Array.isArray; + + module.e = isArray; + + +/***/ }, +/* 1 */ +/***/ function(module, exports, __webpack_require__) { + + /* + * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. + */ + /* eslint-env node */ + 'use strict'; + + var logDisabled_ = true; + + // Utility methods. + var utils = { + disableLog: function(bool) { + if (typeof bool !== 'boolean') { + return new Error('Argument type: ' + typeof bool + + '. Please use a boolean.'); + } + logDisabled_ = bool; + return (bool) ? 'adapter.js logging disabled' : + 'adapter.js logging enabled'; + }, + + log: function() { + if (typeof window === 'object') { + if (logDisabled_) { + return; + } + if (typeof console !== 'undefined' && typeof console.log === 'function') { + console.log.apply(console, arguments); + } + } + }, + + /** + * Extract browser version out of the provided user agent string. + * + * @param {!string} uastring userAgent string. + * @param {!string} expr Regular expression used as match criteria. + * @param {!number} pos position in the version string to be returned. + * @return {!number} browser version. + */ + extractVersion: function(uastring, expr, pos) { + var match = uastring.match(expr); + return match && match.length >= pos && parseInt(match[pos], 10); + }, + + /** + * Browser detector. + * + * @return {object} result containing browser, version and minVersion + * properties. + */ + detectBrowser: function() { + // Returned result object. + var result = {}; + result.browser = null; + result.version = null; + result.minVersion = null; + + // Fail early if it's not a browser + if (typeof window === 'undefined' || !window.navigator) { + result.browser = 'Not a browser.'; + return result; + } + + // Firefox. + if (navigator.mozGetUserMedia) { + result.browser = 'firefox'; + result.version = this.extractVersion(navigator.userAgent, + /Firefox\/([0-9]+)\./, 1); + result.minVersion = 31; + + // all webkit-based browsers + } else if (navigator.webkitGetUserMedia) { + // Chrome, Chromium, Webview, Opera, all use the chrome shim for now + if (window.webkitRTCPeerConnection) { + result.browser = 'chrome'; + result.version = this.extractVersion(navigator.userAgent, + /Chrom(e|ium)\/([0-9]+)\./, 2); + result.minVersion = 38; + + // Safari or unknown webkit-based + // for the time being Safari has support for MediaStreams but not webRTC + } else { + // Safari UA substrings of interest for reference: + // - webkit version: AppleWebKit/602.1.25 (also used in Op,Cr) + // - safari UI version: Version/9.0.3 (unique to Safari) + // - safari UI webkit version: Safari/601.4.4 (also used in Op,Cr) + // + // if the webkit version and safari UI webkit versions are equals, + // ... this is a stable version. + // + // only the internal webkit version is important today to know if + // media streams are supported + // + if (navigator.userAgent.match(/Version\/(\d+).(\d+)/)) { + result.browser = 'safari'; + result.version = this.extractVersion(navigator.userAgent, + /AppleWebKit\/([0-9]+)\./, 1); + result.minVersion = 602; + + // unknown webkit-based browser + } else { + result.browser = 'Unsupported webkit-based browser ' + + 'with GUM support but no WebRTC support.'; + return result; + } + } + + // Edge. + } else if (navigator.mediaDevices && + navigator.userAgent.match(/Edge\/(\d+).(\d+)$/)) { + result.browser = 'edge'; + result.version = this.extractVersion(navigator.userAgent, + /Edge\/(\d+).(\d+)$/, 2); + result.minVersion = 10547; + + // Default fallthrough: not supported. + } else { + result.browser = 'Not a supported browser.'; + return result; + } + + // Warn if version is less than minVersion. + if (result.version < result.minVersion) { + utils.log('Browser: ' + result.browser + ' Version: ' + result.version + + ' < minimum supported version: ' + result.minVersion + + '\n some things might not work!'); + } + + return result; + } + }; + + // Export. + module.e = { + log: utils.log, + disableLog: utils.disableLog, + browserDetails: utils.detectBrowser(), + extractVersion: utils.extractVersion + }; + + +/***/ }, +/* 2 */ +/***/ function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(global) {var checkGlobal = __webpack_require__(143); + + /** Detect free variable `global` from Node.js. */ + var freeGlobal = checkGlobal(typeof global == 'object' && global); + + /** Detect free variable `self`. */ + var freeSelf = checkGlobal(typeof self == 'object' && self); + + /** Detect `this` as the global object. */ + var thisGlobal = checkGlobal(typeof this == 'object' && this); + + /** Used as a reference to the global object. */ + var root = freeGlobal || freeSelf || thisGlobal || Function('return this')(); + + module.e = root; + + /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) + +/***/ }, +/* 3 */ +/***/ function(module, exports, __webpack_require__) { + + /** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/6.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ + function isObject(value) { + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); + } + + module.e = isObject; + + +/***/ }, +/* 4 */ +/***/ function(module, exports, __webpack_require__) { + + /** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ + function isObjectLike(value) { + return !!value && typeof value == 'object'; + } + + module.e = isObjectLike; + + +/***/ }, +/* 5 */ +/***/ function(module, exports, __webpack_require__) { + + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_lodash_merge__ = __webpack_require__(9); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_lodash_merge___default = __WEBPACK_IMPORTED_MODULE_0_lodash_merge__ && __WEBPACK_IMPORTED_MODULE_0_lodash_merge__.__esModule ? function() { return __WEBPACK_IMPORTED_MODULE_0_lodash_merge__['default'] } : function() { return __WEBPACK_IMPORTED_MODULE_0_lodash_merge__; } + /* harmony import */ Object.defineProperty(__WEBPACK_IMPORTED_MODULE_0_lodash_merge___default, 'a', { get: __WEBPACK_IMPORTED_MODULE_0_lodash_merge___default }); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__barcode_reader__ = __webpack_require__(11); + + + var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; + + + + + function EANReader(opts, supplements) { + opts = /* harmony import */__WEBPACK_IMPORTED_MODULE_0_lodash_merge___default.a.bind()(getDefaulConfig(), opts); + /* harmony import */__WEBPACK_IMPORTED_MODULE_1__barcode_reader__["a"].call(this, opts, supplements); + } + + function getDefaulConfig() { + var config = {}; + + Object.keys(EANReader.CONFIG_KEYS).forEach(function (key) { + config[key] = EANReader.CONFIG_KEYS[key].default; + }); + return config; + } + + var properties = { + CODE_L_START: { value: 0 }, + CODE_G_START: { value: 10 }, + START_PATTERN: { value: [1, 1, 1] }, + STOP_PATTERN: { value: [1, 1, 1] }, + MIDDLE_PATTERN: { value: [1, 1, 1, 1, 1] }, + EXTENSION_START_PATTERN: { value: [1, 1, 2] }, + 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] }, + SINGLE_CODE_ERROR: { value: 0.70 }, + AVG_CODE_ERROR: { value: 0.48 }, + FORMAT: { value: "ean_13", writeable: false } + }; + + EANReader.prototype = Object.create(/* harmony import */__WEBPACK_IMPORTED_MODULE_1__barcode_reader__["a"].prototype, properties); + EANReader.prototype.constructor = EANReader; + + EANReader.prototype._decodeCode = function (start, coderange) { + var counter = [0, 0, 0, 0], + i, + self = this, + offset = start, + isWhite = !self._row[offset], + counterPos = 0, + bestMatch = { + error: Number.MAX_VALUE, + code: -1, + start: start, + end: start + }, + code, + error; + + if (!coderange) { + coderange = self.CODE_PATTERN.length; + } + + for (i = offset; i < self._row.length; i++) { + if (self._row[i] ^ isWhite) { + counter[counterPos]++; + } else { + if (counterPos === counter.length - 1) { + for (code = 0; code < coderange; code++) { + error = self._matchPattern(counter, self.CODE_PATTERN[code]); + if (error < bestMatch.error) { + bestMatch.code = code; + bestMatch.error = error; + } + } + bestMatch.end = i; + if (bestMatch.error > self.AVG_CODE_ERROR) { + return null; + } + return bestMatch; + } else { + counterPos++; + } + counter[counterPos] = 1; + isWhite = !isWhite; + } + } + return null; + }; + + EANReader.prototype._findPattern = function (pattern, offset, isWhite, tryHarder, epsilon) { + var counter = [], + self = this, + i, + counterPos = 0, + bestMatch = { + error: Number.MAX_VALUE, + code: -1, + start: 0, + end: 0 + }, + error, + j, + sum; + + if (!offset) { + offset = self._nextSet(self._row); + } + + if (isWhite === undefined) { + isWhite = false; + } + + if (tryHarder === undefined) { + tryHarder = true; + } + + if (epsilon === undefined) { + epsilon = self.AVG_CODE_ERROR; + } + + for (i = 0; i < pattern.length; i++) { + counter[i] = 0; + } + + for (i = offset; i < self._row.length; i++) { + if (self._row[i] ^ isWhite) { + counter[counterPos]++; + } else { + if (counterPos === counter.length - 1) { + sum = 0; + for (j = 0; j < counter.length; j++) { + sum += counter[j]; + } + error = self._matchPattern(counter, pattern); + + if (error < epsilon) { + bestMatch.error = error; + bestMatch.start = i - sum; + bestMatch.end = i; + return bestMatch; + } + if (tryHarder) { + for (j = 0; j < counter.length - 2; j++) { + counter[j] = counter[j + 2]; + } + counter[counter.length - 2] = 0; + counter[counter.length - 1] = 0; + counterPos--; + } else { + return null; + } + } else { + counterPos++; + } + counter[counterPos] = 1; + isWhite = !isWhite; + } + } + return null; + }; + + EANReader.prototype._findStart = function () { + var self = this, + leadingWhitespaceStart, + offset = self._nextSet(self._row), + startInfo; + + while (!startInfo) { + startInfo = self._findPattern(self.START_PATTERN, offset); + if (!startInfo) { + return null; + } + leadingWhitespaceStart = startInfo.start - (startInfo.end - startInfo.start); + if (leadingWhitespaceStart >= 0) { + if (self._matchRange(leadingWhitespaceStart, startInfo.start, 0)) { + return startInfo; + } + } + offset = startInfo.end; + startInfo = null; + } + }; + + EANReader.prototype._verifyTrailingWhitespace = function (endInfo) { + var self = this, + trailingWhitespaceEnd; + + trailingWhitespaceEnd = endInfo.end + (endInfo.end - endInfo.start); + if (trailingWhitespaceEnd < self._row.length) { + if (self._matchRange(endInfo.end, trailingWhitespaceEnd, 0)) { + return endInfo; + } + } + return null; + }; + + EANReader.prototype._findEnd = function (offset, isWhite) { + var self = this, + endInfo = self._findPattern(self.STOP_PATTERN, offset, isWhite, false); + + return endInfo !== null ? self._verifyTrailingWhitespace(endInfo) : null; + }; + + EANReader.prototype._calculateFirstDigit = function (codeFrequency) { + var i, + self = this; + + for (i = 0; i < self.CODE_FREQUENCY.length; i++) { + if (codeFrequency === self.CODE_FREQUENCY[i]) { + return i; + } + } + return null; + }; + + EANReader.prototype._decodePayload = function (code, result, decodedCodes) { + var i, + self = this, + codeFrequency = 0x0, + firstDigit; + + for (i = 0; i < 6; i++) { + code = self._decodeCode(code.end); + if (!code) { + return null; + } + if (code.code >= self.CODE_G_START) { + code.code = code.code - self.CODE_G_START; + codeFrequency |= 1 << 5 - i; + } else { + codeFrequency |= 0 << 5 - i; + } + result.push(code.code); + decodedCodes.push(code); + } + + firstDigit = self._calculateFirstDigit(codeFrequency); + if (firstDigit === null) { + return null; + } + result.unshift(firstDigit); + + code = self._findPattern(self.MIDDLE_PATTERN, code.end, true, false); + if (code === null) { + return null; + } + decodedCodes.push(code); + + for (i = 0; i < 6; i++) { + code = self._decodeCode(code.end, self.CODE_G_START); + if (!code) { + return null; + } + decodedCodes.push(code); + result.push(code.code); + } + + return code; + }; + + EANReader.prototype._decode = function () { + var startInfo, + self = this, + code, + result = [], + decodedCodes = [], + resultInfo = {}; + + startInfo = self._findStart(); + if (!startInfo) { + return null; + } + code = { + code: startInfo.code, + start: startInfo.start, + end: startInfo.end + }; + decodedCodes.push(code); + code = self._decodePayload(code, result, decodedCodes); + if (!code) { + return null; + } + code = self._findEnd(code.end, false); + if (!code) { + return null; + } + + decodedCodes.push(code); + + // Checksum + if (!self._checksum(result)) { + return null; + } + + if (this.supplements.length > 0) { + var ext = this._decodeExtensions(code.end); + if (!ext) { + return null; + } + var lastCode = ext.decodedCodes[ext.decodedCodes.length - 1], + endInfo = { + start: lastCode.start + ((lastCode.end - lastCode.start) / 2 | 0), + end: lastCode.end + }; + if (!self._verifyTrailingWhitespace(endInfo)) { + return null; + } + resultInfo = { + supplement: ext, + code: result.join("") + ext.code + }; + } + + return _extends({ + code: result.join(""), + start: startInfo.start, + end: code.end, + codeset: "", + startInfo: startInfo, + decodedCodes: decodedCodes + }, resultInfo); + }; + + EANReader.prototype._decodeExtensions = function (offset) { + var i, + start = this._nextSet(this._row, offset), + startInfo = this._findPattern(this.EXTENSION_START_PATTERN, start, false, false), + result; + + if (startInfo === null) { + return null; + } + + for (i = 0; i < this.supplements.length; i++) { + result = this.supplements[i].decode(this._row, startInfo.end); + if (result !== null) { + return { + code: result.code, + start: start, + startInfo: startInfo, + end: result.end, + codeset: "", + decodedCodes: result.decodedCodes + }; + } + } + return null; + }; + + EANReader.prototype._checksum = function (result) { + var sum = 0, + i; + + for (i = result.length - 2; i >= 0; i -= 2) { + sum += result[i]; + } + sum *= 3; + for (i = result.length - 1; i >= 0; i -= 2) { + sum += result[i]; + } + return sum % 10 === 0; + }; + + EANReader.CONFIG_KEYS = { + supplements: { + 'type': 'arrayOf(string)', + 'default': [], + 'description': 'Allowed extensions to be decoded (2 and/or 5)' + } + }; + + /* harmony default export */ exports["a"] = EANReader; + +/***/ }, +/* 6 */ +/***/ function(module, exports, __webpack_require__) { + + var baseIsNative = __webpack_require__(129), + getValue = __webpack_require__(160); + + /** + * Gets the native function at `key` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the method to get. + * @returns {*} Returns the function if it's native, else `undefined`. + */ + function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : undefined; + } + + module.e = getNative; + + +/***/ }, +/* 7 */ +/***/ function(module, exports, __webpack_require__) { + + var isSymbol = __webpack_require__(28); + + /** Used as references for various `Number` constants. */ + var INFINITY = 1 / 0; + + /** + * Converts `value` to a string key if it's not a string or symbol. + * + * @private + * @param {*} value The value to inspect. + * @returns {string|symbol} Returns the key. + */ + function toKey(value) { + if (typeof value == 'string' || isSymbol(value)) { + return value; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; + } + + module.e = toKey; + + +/***/ }, +/* 8 */ +/***/ function(module, exports, __webpack_require__) { + + var baseHas = __webpack_require__(59), + baseKeys = __webpack_require__(131), + indexKeys = __webpack_require__(67), + isArrayLike = __webpack_require__(26), + isIndex = __webpack_require__(22), + isPrototype = __webpack_require__(40); + + /** + * Creates an array of the own enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. See the + * [ES spec](http://ecma-international.org/ecma-262/6.0/#sec-object.keys) + * for more details. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keys(new Foo); + * // => ['a', 'b'] (iteration order is not guaranteed) + * + * _.keys('hi'); + * // => ['0', '1'] + */ + function keys(object) { + var isProto = isPrototype(object); + if (!(isProto || isArrayLike(object))) { + return baseKeys(object); + } + var indexes = indexKeys(object), + skipIndexes = !!indexes, + result = indexes || [], + length = result.length; + + for (var key in object) { + if (baseHas(object, key) && + !(skipIndexes && (key == 'length' || isIndex(key, length))) && + !(isProto && key == 'constructor')) { + result.push(key); + } + } + return result; + } + + module.e = keys; + + +/***/ }, +/* 9 */ +/***/ function(module, exports, __webpack_require__) { + + var baseMerge = __webpack_require__(135), + createAssigner = __webpack_require__(153); + + /** + * This method is like `_.assign` except that it recursively merges own and + * inherited enumerable string keyed properties of source objects into the + * destination object. Source properties that resolve to `undefined` are + * skipped if a destination value exists. Array and plain object properties + * are merged recursively. Other objects and value types are overridden by + * assignment. Source objects are applied from left to right. Subsequent + * sources overwrite property assignments of previous sources. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 0.5.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @example + * + * var users = { + * 'data': [{ 'user': 'barney' }, { 'user': 'fred' }] + * }; + * + * var ages = { + * 'data': [{ 'age': 36 }, { 'age': 40 }] + * }; + * + * _.merge(users, ages); + * // => { 'data': [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }] } + */ + var merge = createAssigner(function(object, source, srcIndex) { + baseMerge(object, source, srcIndex); + }); + + module.e = merge; + + +/***/ }, +/* 10 */ +/***/ function(module, exports, __webpack_require__) { + + /* harmony default export */ exports["a"] = { + drawRect: function drawRect(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 drawPath(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(); + }, + drawImage: function drawImage(imageData, size, ctx) { + var canvasData = ctx.getImageData(0, 0, size.x, size.y), + data = canvasData.data, + imageDataPos = imageData.length, + canvasDataPos = data.length, + value; + + if (canvasDataPos / imageDataPos !== 4) { + return false; + } + while (imageDataPos--) { + value = imageData[imageDataPos]; + data[--canvasDataPos] = 255; + data[--canvasDataPos] = value; + data[--canvasDataPos] = value; + data[--canvasDataPos] = value; + } + ctx.putImageData(canvasData, 0, 0); + return true; + } + }; + +/***/ }, +/* 11 */ +/***/ function(module, exports, __webpack_require__) { + + function BarcodeReader(config, supplements) { + this._row = []; + this.config = config || {}; + this.supplements = supplements; + return this; + } + + BarcodeReader.prototype._nextUnset = function (line, start) { + var i; + + if (start === undefined) { + start = 0; + } + for (i = start; i < line.length; i++) { + if (!line[i]) { + return i; + } + } + return line.length; + }; + + BarcodeReader.prototype._matchPattern = function (counter, code, maxSingleError) { + var i, + error = 0, + singleError = 0, + sum = 0, + modulo = 0, + barWidth, + count, + scaled; + + maxSingleError = maxSingleError || this.SINGLE_CODE_ERROR || 1; + + for (i = 0; i < counter.length; i++) { + sum += counter[i]; + modulo += code[i]; + } + if (sum < modulo) { + return Number.MAX_VALUE; + } + barWidth = sum / modulo; + maxSingleError *= barWidth; + + for (i = 0; i < counter.length; i++) { + count = counter[i]; + scaled = code[i] * barWidth; + singleError = Math.abs(count - scaled) / scaled; + if (singleError > maxSingleError) { + return Number.MAX_VALUE; + } + error += singleError; + } + return error / modulo; + }; + + BarcodeReader.prototype._nextSet = function (line, offset) { + var i; + + offset = offset || 0; + for (i = offset; i < line.length; i++) { + if (line[i]) { + return i; + } + } + return line.length; + }; + + BarcodeReader.prototype._correctBars = function (counter, correction, indices) { + var length = indices.length, + tmp = 0; + while (length--) { + tmp = counter[indices[length]] * (1 - (1 - correction) / 2); + if (tmp > 1) { + counter[indices[length]] = tmp; + } + } + }; + + BarcodeReader.prototype._matchTrace = function (cmpCounter, epsilon) { + var counter = [], + i, + self = this, + offset = self._nextSet(self._row), + isWhite = !self._row[offset], + counterPos = 0, + bestMatch = { + error: Number.MAX_VALUE, + code: -1, + start: 0 + }, + error; + + if (cmpCounter) { + for (i = 0; i < cmpCounter.length; i++) { + counter.push(0); + } + for (i = offset; i < self._row.length; i++) { + if (self._row[i] ^ isWhite) { + counter[counterPos]++; + } else { + if (counterPos === counter.length - 1) { + error = self._matchPattern(counter, cmpCounter); + + if (error < epsilon) { + bestMatch.start = i - offset; + bestMatch.end = i; + bestMatch.counter = counter; + return bestMatch; + } else { + return null; + } + } else { + counterPos++; + } + counter[counterPos] = 1; + isWhite = !isWhite; + } + } + } else { + counter.push(0); + for (i = offset; i < self._row.length; i++) { + if (self._row[i] ^ isWhite) { + counter[counterPos]++; + } else { + counterPos++; + counter.push(0); + counter[counterPos] = 1; + isWhite = !isWhite; + } + } + } + + // if cmpCounter was not given + bestMatch.start = offset; + bestMatch.end = self._row.length - 1; + bestMatch.counter = counter; + return bestMatch; + }; + + BarcodeReader.prototype.decodePattern = function (pattern) { + var self = this, + result; + + self._row = pattern; + result = self._decode(); + if (result === null) { + self._row.reverse(); + result = self._decode(); + if (result) { + result.direction = BarcodeReader.DIRECTION.REVERSE; + result.start = self._row.length - result.start; + result.end = self._row.length - result.end; + } + } else { + result.direction = BarcodeReader.DIRECTION.FORWARD; + } + if (result) { + result.format = self.FORMAT; + } + return result; + }; + + BarcodeReader.prototype._matchRange = function (start, end, value) { + var i; + + start = start < 0 ? 0 : start; + for (i = start; i < end; i++) { + if (this._row[i] !== value) { + return false; + } + } + return true; + }; + + BarcodeReader.prototype._fillCounters = function (offset, end, isWhite) { + var self = this, + counterPos = 0, + i, + counters = []; + + isWhite = typeof isWhite !== 'undefined' ? isWhite : true; + offset = typeof offset !== 'undefined' ? offset : self._nextUnset(self._row); + end = end || self._row.length; + + counters[counterPos] = 0; + for (i = offset; i < end; i++) { + if (self._row[i] ^ isWhite) { + counters[counterPos]++; + } else { + counterPos++; + counters[counterPos] = 1; + isWhite = !isWhite; + } + } + return counters; + }; + + Object.defineProperty(BarcodeReader.prototype, "FORMAT", { + value: 'unknown', + writeable: false + }); + + BarcodeReader.DIRECTION = { + FORWARD: 1, + REVERSE: -1 + }; + + BarcodeReader.Exception = { + StartNotFoundException: "Start-Info was not found!", + CodeNotFoundException: "Code could not be found!", + PatternNotFoundException: "Pattern could not be found!" + }; + + BarcodeReader.CONFIG_KEYS = {}; + + /* harmony default export */ exports["a"] = BarcodeReader; + +/***/ }, +/* 12 */ +/***/ function(module, exports, __webpack_require__) { + + module.e = clone + + /** + * Creates a new vec2 initialized with values from an existing vector + * + * @param {vec2} a vector to clone + * @returns {vec2} a new 2D vector + */ + function clone(a) { + var out = new Float32Array(2) + out[0] = a[0] + out[1] = a[1] + return out + } + +/***/ }, +/* 13 */ +/***/ function(module, exports, __webpack_require__) { + + var isArrayLikeObject = __webpack_require__(73); + + /** `Object#toString` result references. */ + var argsTag = '[object Arguments]'; + + /** Used for built-in method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) + * of values. + */ + var objectToString = objectProto.toString; + + /** Built-in value references. */ + var propertyIsEnumerable = objectProto.propertyIsEnumerable; + + /** + * Checks if `value` is likely an `arguments` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is correctly classified, + * else `false`. + * @example + * + * _.isArguments(function() { return arguments; }()); + * // => true + * + * _.isArguments([1, 2, 3]); + * // => false + */ + function isArguments(value) { + // Safari 8.1 incorrectly makes `arguments.callee` enumerable in strict mode. + return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') && + (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag); + } + + module.e = isArguments; + + +/***/ }, +/* 14 */ +/***/ function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(3); + + /** `Object#toString` result references. */ + var funcTag = '[object Function]', + genTag = '[object GeneratorFunction]'; + + /** Used for built-in method references. */ + var objectProto = Object.prototype; + + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) + * of values. + */ + var objectToString = objectProto.toString; + + /** + * Checks if `value` is classified as a `Function` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is correctly classified, + * else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false + */ + function isFunction(value) { + // The use of `Object#toString` avoids issues with the `typeof` operator + // in Safari 8 which returns 'object' for typed array and weak map constructors, + // and PhantomJS 1.9 which returns 'function' for `NodeList` instances. + var tag = isObject(value) ? objectToString.call(value) : ''; + return tag == funcTag || tag == genTag; + } + + module.e = isFunction; + + +/***/ }, +/* 15 */ +/***/ function(module, exports, __webpack_require__) { + + /* harmony default export */ exports["a"] = { + init: function init(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 shuffle(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 toPointList(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 threshold(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 maxIndex(arr) { + var i, + max = 0; + for (i = 0; i < arr.length; i++) { + if (arr[i] > arr[max]) { + max = i; + } + } + return max; + }, + + max: function max(arr) { + var i, + max = 0; + for (i = 0; i < arr.length; i++) { + if (arr[i] > max) { + max = arr[i]; + } + } + return max; + }, + + sum: function sum(arr) { + var length = arr.length, + sum = 0; + + while (length--) { + sum += arr[length]; + } + return sum; + } + }; + +/***/ }, +/* 16 */ +/***/ function(module, exports, __webpack_require__) { + + var listCacheClear = __webpack_require__(176), + listCacheDelete = __webpack_require__(177), + listCacheGet = __webpack_require__(178), + listCacheHas = __webpack_require__(179), + listCacheSet = __webpack_require__(180); + + /** + * Creates an list cache object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function ListCache(entries) { + var index = -1, + length = entries ? entries.length : 0; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + + // Add methods to `ListCache`. + ListCache.prototype.clear = listCacheClear; + ListCache.prototype['delete'] = listCacheDelete; + ListCache.prototype.get = listCacheGet; + ListCache.prototype.has = listCacheHas; + ListCache.prototype.set = listCacheSet; + + module.e = ListCache; + + +/***/ }, +/* 17 */ +/***/ function(module, exports, __webpack_require__) { + + var ListCache = __webpack_require__(16), + stackClear = __webpack_require__(188), + stackDelete = __webpack_require__(189), + stackGet = __webpack_require__(190), + stackHas = __webpack_require__(191), + stackSet = __webpack_require__(192); + + /** + * Creates a stack cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function Stack(entries) { + this.__data__ = new ListCache(entries); + } + + // Add methods to `Stack`. + Stack.prototype.clear = stackClear; + Stack.prototype['delete'] = stackDelete; + Stack.prototype.get = stackGet; + Stack.prototype.has = stackHas; + Stack.prototype.set = stackSet; + + module.e = Stack; + + +/***/ }, +/* 18 */ +/***/ function(module, exports, __webpack_require__) { + + var eq = __webpack_require__(25); + + /** + * Gets the index at which the `key` is found in `array` of key-value pairs. + * + * @private + * @param {Array} array The array to search. + * @param {*} key The key to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + function assocIndexOf(array, key) { + var length = array.length; + while (length--) { + if (eq(array[length][0], key)) { + return length; + } + } + return -1; + } + + module.e = assocIndexOf; + + +/***/ }, +/* 19 */ +/***/ function(module, exports, __webpack_require__) { + + var isKeyable = __webpack_require__(173); + + /** + * Gets the data for `map`. + * + * @private + * @param {Object} map The map to query. + * @param {string} key The reference key. + * @returns {*} Returns the map data. + */ + function getMapData(map, key) { + var data = map.__data__; + return isKeyable(key) + ? data[typeof key == 'string' ? 'string' : 'hash'] + : data.map; + } + + module.e = getMapData; + + +/***/ }, +/* 20 */ +/***/ function(module, exports, __webpack_require__) { + + /* Built-in method references for those with the same name as other `lodash` methods. */ + var nativeGetPrototype = Object.getPrototypeOf; + + /** + * Gets the `[[Prototype]]` of `value`. + * + * @private + * @param {*} value The value to query. + * @returns {null|Object} Returns the `[[Prototype]]`. + */ + function getPrototype(value) { + return nativeGetPrototype(Object(value)); + } + + module.e = getPrototype; + + +/***/ }, +/* 21 */ +/***/ function(module, exports, __webpack_require__) { + + /** + * Checks if `value` is a host object in IE < 9. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a host object, else `false`. + */ + function isHostObject(value) { + // Many host objects are `Object` objects that can coerce to strings + // despite having improperly defined `toString` methods. + var result = false; + if (value != null && typeof value.toString != 'function') { + try { + result = !!(value + ''); + } catch (e) {} + } + return result; + } + + module.e = isHostObject; + + +/***/ }, +/* 22 */ +/***/ function(module, exports, __webpack_require__) { + + /** Used as references for various `Number` constants. */ + var MAX_SAFE_INTEGER = 9007199254740991; + + /** Used to detect unsigned integer values. */ + var reIsUint = /^(?:0|[1-9]\d*)$/; + + /** + * Checks if `value` is a valid array-like index. + * + * @private + * @param {*} value The value to check. + * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. + * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. + */ + function isIndex(value, length) { + length = length == null ? MAX_SAFE_INTEGER : length; + return !!length && + (typeof value == 'number' || reIsUint.test(value)) && + (value > -1 && value % 1 == 0 && value < length); + } + + module.e = isIndex; + + +/***/ }, +/* 23 */ +/***/ function(module, exports, __webpack_require__) { + + var isArray = __webpack_require__(0), + isSymbol = __webpack_require__(28); + + /** Used to match property names within property paths. */ + var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, + reIsPlainProp = /^\w*$/; + + /** + * Checks if `value` is a property name and not a property path. + * + * @private + * @param {*} value The value to check. + * @param {Object} [object] The object to query keys on. + * @returns {boolean} Returns `true` if `value` is a property name, else `false`. + */ + function isKey(value, object) { + if (isArray(value)) { + return false; + } + var type = typeof value; + if (type == 'number' || type == 'symbol' || type == 'boolean' || + value == null || isSymbol(value)) { + return true; + } + return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || + (object != null && value in Object(object)); + } + + module.e = isKey; + + +/***/ }, +/* 24 */ +/***/ function(module, exports, __webpack_require__) { + + var getNative = __webpack_require__(6); + + /* Built-in method references that are verified to be native. */ + var nativeCreate = getNative(Object, 'create'); + + module.e = nativeCreate; + + +/***/ }, +/* 25 */ +/***/ function(module, exports, __webpack_require__) { + + /** + * Performs a + * [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'user': 'fred' }; + * var other = { 'user': 'fred' }; + * + * _.eq(object, object); + * // => true + * + * _.eq(object, other); + * // => false + * + * _.eq('a', 'a'); + * // => true + * + * _.eq('a', Object('a')); + * // => false + * + * _.eq(NaN, NaN); + * // => true + */ + function eq(value, other) { + return value === other || (value !== value && other !== other); + } + + module.e = eq; + + +/***/ }, +/* 26 */ +/***/ function(module, exports, __webpack_require__) { + + var getLength = __webpack_require__(157), + isFunction = __webpack_require__(14), + isLength = __webpack_require__(27); + + /** + * Checks if `value` is array-like. A value is considered array-like if it's + * not a function and has a `value.length` that's an integer greater than or + * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is array-like, else `false`. + * @example + * + * _.isArrayLike([1, 2, 3]); + * // => true + * + * _.isArrayLike(document.body.children); + * // => true + * + * _.isArrayLike('abc'); + * // => true + * + * _.isArrayLike(_.noop); + * // => false + */ + function isArrayLike(value) { + return value != null && isLength(getLength(value)) && !isFunction(value); + } + + module.e = isArrayLike; + + +/***/ }, +/* 27 */ +/***/ function(module, exports, __webpack_require__) { + + /** Used as references for various `Number` constants. */ + var MAX_SAFE_INTEGER = 9007199254740991; + + /** + * Checks if `value` is a valid array-like length. + * + * **Note:** This function is loosely based on + * [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a valid length, + * else `false`. + * @example + * + * _.isLength(3); + * // => true + * + * _.isLength(Number.MIN_VALUE); + * // => false + * + * _.isLength(Infinity); + * // => false + * + * _.isLength('3'); + * // => false + */ + function isLength(value) { + return typeof value == 'number' && + value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; + } + + module.e = isLength; + + +/***/ }, +/* 28 */ +/***/ function(module, exports, __webpack_require__) { + + var isObjectLike = __webpack_require__(4); + + /** `Object#toString` result references. */ + var symbolTag = '[object Symbol]'; + + /** Used for built-in method references. */ + var objectProto = Object.prototype; + + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) + * of values. + */ + var objectToString = objectProto.toString; + + /** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is correctly classified, + * else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ + function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && objectToString.call(value) == symbolTag); + } + + module.e = isSymbol; + + +/***/ }, +/* 29 */ +/***/ function(module, exports, __webpack_require__) { + + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__cluster__ = __webpack_require__(77); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__array_helper__ = __webpack_require__(15); + /* harmony export */ exports["f"] = imageRef;/* unused harmony export computeIntegralImage2 *//* unused harmony export computeIntegralImage *//* unused harmony export thresholdImage *//* unused harmony export computeHistogram *//* unused harmony export sharpenLine *//* unused harmony export determineOtsuThreshold *//* harmony export */ exports["c"] = otsuThreshold;/* unused harmony export computeBinaryImage *//* harmony export */ exports["d"] = cluster;/* unused harmony export dilate *//* unused harmony export erode *//* unused harmony export subtract *//* unused harmony export bitwiseOr *//* unused harmony export countNonZero *//* harmony export */ exports["e"] = topGeneric;/* unused harmony export grayArrayFromImage *//* unused harmony export grayArrayFromContext *//* harmony export */ exports["i"] = grayAndHalfSampleFromCanvasData;/* harmony export */ exports["j"] = computeGray;/* unused harmony export loadImageArray *//* harmony export */ exports["g"] = halfSample;/* harmony export */ exports["a"] = hsv2rgb;/* unused harmony export _computeDivisors *//* harmony export */ exports["b"] = calculatePatchSize;/* unused harmony export _parseCSSDimensionValues *//* harmony export */ exports["h"] = computeImageArea; + + var vec2 = { + clone: __webpack_require__(12) + }; + var vec3 = { + clone: __webpack_require__(108) + }; + + /** + * @param x x-coordinate + * @param y y-coordinate + * @return ImageReference {x,y} Coordinate + */ + function imageRef(x, y) { + var that = { + x: x, + y: y, + toVec2: function toVec2() { + return vec2.clone([this.x, this.y]); + }, + toVec3: function toVec3() { + return vec3.clone([this.x, this.y, 1]); + }, + round: function round() { + 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 + */ + function computeIntegralImage2(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++; + } + } + }; + + function computeIntegralImage(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]; + } + } + }; + + function thresholdImage(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; + } + }; + + function computeHistogram(imageWrapper, bitsPerPixel) { + if (!bitsPerPixel) { + bitsPerPixel = 8; + } + var imageData = imageWrapper.data, + length = imageData.length, + bitShift = 8 - bitsPerPixel, + bucketCnt = 1 << bitsPerPixel, + hist = new Int32Array(bucketCnt); + + while (length--) { + hist[imageData[length] >> bitShift]++; + } + return hist; + }; + + function sharpenLine(line) { + var i, + length = line.length, + left = line[0], + center = line[1], + right; + + for (i = 1; i < length - 1; i++) { + right = line[i + 1]; + // -1 4 -1 kernel + line[i - 1] = center * 2 - left - right & 255; + left = center; + center = right; + } + return line; + }; + + function determineOtsuThreshold(imageWrapper, bitsPerPixel) { + if (!bitsPerPixel) { + bitsPerPixel = 8; + } + var hist, + threshold, + bitShift = 8 - bitsPerPixel; + + 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, + max = (1 << bitsPerPixel) - 1; + + hist = computeHistogram(imageWrapper, bitsPerPixel); + for (k = 1; k < max; k++) { + p1 = px(0, k); + p2 = px(k + 1, max); + p12 = p1 * p2; + if (p12 === 0) { + p12 = 1; + } + m1 = mx(0, k) * p2; + m2 = mx(k + 1, max) * p1; + m12 = m1 - m2; + vet[k] = m12 * m12 / p12; + } + return /* harmony import */__WEBPACK_IMPORTED_MODULE_1__array_helper__["a"].maxIndex(vet); + } + + threshold = determineThreshold(); + return threshold << bitShift; + }; + + function otsuThreshold(imageWrapper, targetWrapper) { + var threshold = determineOtsuThreshold(imageWrapper); + + thresholdImage(imageWrapper, threshold, targetWrapper); + return threshold; + }; + + // local thresholding + function computeBinaryImage(imageWrapper, integralWrapper, targetWrapper) { + 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; + } + } + }; + + function cluster(points, threshold, property) { + var i, + k, + cluster, + point, + clusters = []; + + if (!property) { + property = "rad"; + } + + function addToCluster(newPoint) { + var found = false; + for (k = 0; k < clusters.length; k++) { + cluster = clusters[k]; + if (cluster.fits(newPoint)) { + cluster.add(newPoint); + found = true; + } + } + return found; + } + + // iterate over each cloud + for (i = 0; i < points.length; i++) { + point = /* harmony import */__WEBPACK_IMPORTED_MODULE_0__cluster__["a"].createPoint(points[i], i, property); + if (!addToCluster(point)) { + clusters.push(/* harmony import */__WEBPACK_IMPORTED_MODULE_0__cluster__["a"].create(point, threshold)); + } + } + return clusters; + }; + + var Tracer = { + trace: function trace(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; + } + };/* unused harmony export Tracer */ + + var DILATE = 1;/* unused harmony export DILATE */ + var ERODE = 2;/* unused harmony export ERODE */ + + function dilate(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 + xStart2] + inImageData[v * width + u] + inImageData[yStart2 * width + xStart1] + inImageData[yStart2 * width + xStart2]; + outImageData[v * width + u] = sum > 0 ? 1 : 0; + } + } + }; + + function erode(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 + xStart2] + inImageData[v * width + u] + inImageData[yStart2 * width + xStart1] + inImageData[yStart2 * width + xStart2]; + outImageData[v * width + u] = sum === 5 ? 1 : 0; + } + } + }; + + function subtract(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]; + } + }; + + function bitwiseOr(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]; + } + }; + + function countNonZero(imageWrapper) { + var length = imageWrapper.data.length, + data = imageWrapper.data, + sum = 0; + + while (length--) { + sum += data[length]; + } + return sum; + }; + + function topGeneric(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; + }; + + function grayArrayFromImage(htmlImage, offsetX, ctx, array) { + ctx.drawImage(htmlImage, offsetX, 0, htmlImage.width, htmlImage.height); + var ctxData = ctx.getImageData(offsetX, 0, htmlImage.width, htmlImage.height).data; + computeGray(ctxData, array); + }; + + function grayArrayFromContext(ctx, size, offset, array) { + var ctxData = ctx.getImageData(offset.x, offset.y, size.x, size.y).data; + computeGray(ctxData, array); + }; + + function grayAndHalfSampleFromCanvasData(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; + } + }; + + function computeGray(imageData, outArray, config) { + var l = imageData.length / 4 | 0, + i, + singleChannel = config && config.singleChannel === true; + + if (singleChannel) { + for (i = 0; i < l; i++) { + outArray[i] = imageData[i * 4 + 0]; + } + } else { + for (i = 0; i < l; i++) { + outArray[i] = Math.floor(0.299 * imageData[i * 4 + 0] + 0.587 * imageData[i * 4 + 1] + 0.114 * imageData[i * 4 + 2]); + } + } + }; + + function loadImageArray(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; + 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 + */ + function halfSample(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; + } + }; + + function hsv2rgb(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; + }; + + function _computeDivisors(n) { + var largeDivisors = [], + divisors = [], + i; + + for (i = 1; i < Math.sqrt(n) + 1; i++) { + if (n % i === 0) { + divisors.push(i); + if (i !== n / i) { + largeDivisors.unshift(Math.floor(n / i)); + } + } + } + return divisors.concat(largeDivisors); + }; + + function _computeIntersection(arr1, arr2) { + var i = 0, + j = 0, + result = []; + + while (i < arr1.length && j < arr2.length) { + if (arr1[i] === arr2[j]) { + result.push(arr1[i]); + i++; + j++; + } else if (arr1[i] > arr2[j]) { + j++; + } else { + i++; + } + } + return result; + }; + + function calculatePatchSize(patchSize, imgSize) { + var divisorsX = _computeDivisors(imgSize.x), + divisorsY = _computeDivisors(imgSize.y), + wideSide = Math.max(imgSize.x, imgSize.y), + common = _computeIntersection(divisorsX, divisorsY), + nrOfPatchesList = [8, 10, 15, 20, 32, 60, 80], + nrOfPatchesMap = { + "x-small": 5, + "small": 4, + "medium": 3, + "large": 2, + "x-large": 1 + }, + nrOfPatchesIdx = nrOfPatchesMap[patchSize] || nrOfPatchesMap.medium, + nrOfPatches = nrOfPatchesList[nrOfPatchesIdx], + desiredPatchSize = Math.floor(wideSide / nrOfPatches), + optimalPatchSize; + + function findPatchSizeForDivisors(divisors) { + var i = 0, + found = divisors[Math.floor(divisors.length / 2)]; + + while (i < divisors.length - 1 && divisors[i] < desiredPatchSize) { + i++; + } + if (i > 0) { + if (Math.abs(divisors[i] - desiredPatchSize) > Math.abs(divisors[i - 1] - desiredPatchSize)) { + found = divisors[i - 1]; + } else { + found = divisors[i]; + } + } + if (desiredPatchSize / found < nrOfPatchesList[nrOfPatchesIdx + 1] / nrOfPatchesList[nrOfPatchesIdx] && desiredPatchSize / found > nrOfPatchesList[nrOfPatchesIdx - 1] / nrOfPatchesList[nrOfPatchesIdx]) { + return { x: found, y: found }; + } + return null; + } + + optimalPatchSize = findPatchSizeForDivisors(common); + if (!optimalPatchSize) { + optimalPatchSize = findPatchSizeForDivisors(_computeDivisors(wideSide)); + if (!optimalPatchSize) { + optimalPatchSize = findPatchSizeForDivisors(_computeDivisors(desiredPatchSize * nrOfPatches)); + } + } + return optimalPatchSize; + }; + + function _parseCSSDimensionValues(value) { + var dimension = { + value: parseFloat(value), + unit: value.indexOf("%") === value.length - 1 ? "%" : "%" + }; + + return dimension; + }; + + var _dimensionsConverters = { + top: function top(dimension, context) { + if (dimension.unit === "%") { + return Math.floor(context.height * (dimension.value / 100)); + } + }, + right: function right(dimension, context) { + if (dimension.unit === "%") { + return Math.floor(context.width - context.width * (dimension.value / 100)); + } + }, + bottom: function bottom(dimension, context) { + if (dimension.unit === "%") { + return Math.floor(context.height - context.height * (dimension.value / 100)); + } + }, + left: function left(dimension, context) { + if (dimension.unit === "%") { + return Math.floor(context.width * (dimension.value / 100)); + } + } + };/* unused harmony export _dimensionsConverters */ + + function computeImageArea(inputWidth, inputHeight, area) { + var context = { width: inputWidth, height: inputHeight }; + + var parsedArea = Object.keys(area).reduce(function (result, key) { + var value = area[key], + parsed = _parseCSSDimensionValues(value), + calculated = _dimensionsConverters[key](parsed, context); + + result[key] = calculated; + return result; + }, {}); + + return { + sx: parsedArea.left, + sy: parsedArea.top, + sw: parsedArea.right - parsedArea.left, + sh: parsedArea.bottom - parsedArea.top + }; + }; + +/***/ }, +/* 30 */ +/***/ function(module, exports, __webpack_require__) { + + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__subImage__ = __webpack_require__(80); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__common_cv_utils__ = __webpack_require__(29); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__common_array_helper__ = __webpack_require__(15); + + + + var vec2 = { + clone: __webpack_require__(12) + }; + + /** + * 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) { + /* harmony import */__WEBPACK_IMPORTED_MODULE_2__common_array_helper__["a"].init(this.data, 0); + } + } else { + this.data = new Uint8Array(size.x * size.y); + if (Uint8Array === Array && initialize) { + /* harmony import */__WEBPACK_IMPORTED_MODULE_2__common_array_helper__["a"].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; + }; + + /** + * 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 /* harmony import */__WEBPACK_IMPORTED_MODULE_0__subImage__["a"](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.clone([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 : /* harmony import */__WEBPACK_IMPORTED_MODULE_1__common_cv_utils__["a"].bind()(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); + }; + + /* harmony default export */ exports["a"] = ImageWrapper; + +/***/ }, +/* 31 */ +/***/ function(module, exports, __webpack_require__) { + + var mapCacheClear = __webpack_require__(181), + mapCacheDelete = __webpack_require__(182), + mapCacheGet = __webpack_require__(183), + mapCacheHas = __webpack_require__(184), + mapCacheSet = __webpack_require__(185); + + /** + * Creates a map cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function MapCache(entries) { + var index = -1, + length = entries ? entries.length : 0; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + + // Add methods to `MapCache`. + MapCache.prototype.clear = mapCacheClear; + MapCache.prototype['delete'] = mapCacheDelete; + MapCache.prototype.get = mapCacheGet; + MapCache.prototype.has = mapCacheHas; + MapCache.prototype.set = mapCacheSet; + + module.e = MapCache; + + +/***/ }, +/* 32 */ +/***/ function(module, exports, __webpack_require__) { + + var root = __webpack_require__(2); + + /** Built-in value references. */ + var Symbol = root.Symbol; + + module.e = Symbol; + + +/***/ }, +/* 33 */ +/***/ function(module, exports, __webpack_require__) { + + /** + * A specialized version of `_.map` for arrays without support for iteratee + * shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + */ + function arrayMap(array, iteratee) { + var index = -1, + length = array ? array.length : 0, + result = Array(length); + + while (++index < length) { + result[index] = iteratee(array[index], index, array); + } + return result; + } + + module.e = arrayMap; + + +/***/ }, +/* 34 */ +/***/ function(module, exports, __webpack_require__) { + + /** + * Appends the elements of `values` to `array`. + * + * @private + * @param {Array} array The array to modify. + * @param {Array} values The values to append. + * @returns {Array} Returns `array`. + */ + function arrayPush(array, values) { + var index = -1, + length = values.length, + offset = array.length; + + while (++index < length) { + array[offset + index] = values[index]; + } + return array; + } + + module.e = arrayPush; + + +/***/ }, +/* 35 */ +/***/ function(module, exports, __webpack_require__) { + + /** + * A specialized version of `_.reduce` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @param {boolean} [initAccum] Specify using the first element of `array` as + * the initial value. + * @returns {*} Returns the accumulated value. + */ + function arrayReduce(array, iteratee, accumulator, initAccum) { + var index = -1, + length = array ? array.length : 0; + + if (initAccum && length) { + accumulator = array[++index]; + } + while (++index < length) { + accumulator = iteratee(accumulator, array[index], index, array); + } + return accumulator; + } + + module.e = arrayReduce; + + +/***/ }, +/* 36 */ +/***/ function(module, exports, __webpack_require__) { + + var Uint8Array = __webpack_require__(52); + + /** + * Creates a clone of `arrayBuffer`. + * + * @private + * @param {ArrayBuffer} arrayBuffer The array buffer to clone. + * @returns {ArrayBuffer} Returns the cloned array buffer. + */ + function cloneArrayBuffer(arrayBuffer) { + var result = new arrayBuffer.constructor(arrayBuffer.byteLength); + new Uint8Array(result).set(new Uint8Array(arrayBuffer)); + return result; + } + + module.e = cloneArrayBuffer; + + +/***/ }, +/* 37 */ +/***/ function(module, exports, __webpack_require__) { + + var assignValue = __webpack_require__(55); + + /** + * Copies properties of `source` to `object`. + * + * @private + * @param {Object} source The object to copy properties from. + * @param {Array} props The property identifiers to copy. + * @param {Object} [object={}] The object to copy properties to. + * @param {Function} [customizer] The function to customize copied values. + * @returns {Object} Returns `object`. + */ + function copyObject(source, props, object, customizer) { + object || (object = {}); + + var index = -1, + length = props.length; + + while (++index < length) { + var key = props[index]; + + var newValue = customizer + ? customizer(object[key], source[key], key, object, source) + : source[key]; + + assignValue(object, key, newValue); + } + return object; + } + + module.e = copyObject; + + +/***/ }, +/* 38 */ +/***/ function(module, exports, __webpack_require__) { + + var stubArray = __webpack_require__(203); + + /** Built-in value references. */ + var getOwnPropertySymbols = Object.getOwnPropertySymbols; + + /** + * Creates an array of the own enumerable symbol properties of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of symbols. + */ + function getSymbols(object) { + // Coerce `object` to an object to avoid non-object errors in V8. + // See https://bugs.chromium.org/p/v8/issues/detail?id=3443 for more details. + return getOwnPropertySymbols(Object(object)); + } + + // Fallback for IE < 11. + if (!getOwnPropertySymbols) { + getSymbols = stubArray; + } + + module.e = getSymbols; + + +/***/ }, +/* 39 */ +/***/ function(module, exports, __webpack_require__) { + + var DataView = __webpack_require__(109), + Map = __webpack_require__(50), + Promise = __webpack_require__(111), + Set = __webpack_require__(113), + WeakMap = __webpack_require__(114), + toSource = __webpack_require__(72); + + /** `Object#toString` result references. */ + var mapTag = '[object Map]', + objectTag = '[object Object]', + promiseTag = '[object Promise]', + setTag = '[object Set]', + weakMapTag = '[object WeakMap]'; + + var dataViewTag = '[object DataView]'; + + /** Used for built-in method references. */ + var objectProto = Object.prototype; + + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) + * of values. + */ + var objectToString = objectProto.toString; + + /** Used to detect maps, sets, and weakmaps. */ + var dataViewCtorString = toSource(DataView), + mapCtorString = toSource(Map), + promiseCtorString = toSource(Promise), + setCtorString = toSource(Set), + weakMapCtorString = toSource(WeakMap); + + /** + * Gets the `toStringTag` of `value`. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ + function getTag(value) { + return objectToString.call(value); + } + + // Fallback for data views, maps, sets, and weak maps in IE 11, + // for data views in Edge, and promises in Node.js. + if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) || + (Map && getTag(new Map) != mapTag) || + (Promise && getTag(Promise.resolve()) != promiseTag) || + (Set && getTag(new Set) != setTag) || + (WeakMap && getTag(new WeakMap) != weakMapTag)) { + getTag = function(value) { + var result = objectToString.call(value), + Ctor = result == objectTag ? value.constructor : undefined, + ctorString = Ctor ? toSource(Ctor) : undefined; + + if (ctorString) { + switch (ctorString) { + case dataViewCtorString: return dataViewTag; + case mapCtorString: return mapTag; + case promiseCtorString: return promiseTag; + case setCtorString: return setTag; + case weakMapCtorString: return weakMapTag; + } + } + return result; + }; + } + + module.e = getTag; + + +/***/ }, +/* 40 */ +/***/ function(module, exports, __webpack_require__) { + + /** Used for built-in method references. */ + var objectProto = Object.prototype; + + /** + * Checks if `value` is likely a prototype object. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. + */ + function isPrototype(value) { + var Ctor = value && value.constructor, + proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; + + return value === proto; + } + + module.e = isPrototype; + + +/***/ }, +/* 41 */ +/***/ function(module, exports, __webpack_require__) { + + var isArray = __webpack_require__(0), + isObjectLike = __webpack_require__(4); + + /** `Object#toString` result references. */ + var stringTag = '[object String]'; + + /** Used for built-in method references. */ + var objectProto = Object.prototype; + + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) + * of values. + */ + var objectToString = objectProto.toString; + + /** + * Checks if `value` is classified as a `String` primitive or object. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is correctly classified, + * else `false`. + * @example + * + * _.isString('abc'); + * // => true + * + * _.isString(1); + * // => false + */ + function isString(value) { + return typeof value == 'string' || + (!isArray(value) && isObjectLike(value) && objectToString.call(value) == stringTag); + } + + module.e = isString; + + +/***/ }, +/* 42 */ +/***/ function(module, exports, __webpack_require__) { + + var isLength = __webpack_require__(27), + isObjectLike = __webpack_require__(4); + + /** `Object#toString` result references. */ + var argsTag = '[object Arguments]', + arrayTag = '[object Array]', + boolTag = '[object Boolean]', + dateTag = '[object Date]', + errorTag = '[object Error]', + funcTag = '[object Function]', + mapTag = '[object Map]', + numberTag = '[object Number]', + objectTag = '[object Object]', + regexpTag = '[object RegExp]', + setTag = '[object Set]', + stringTag = '[object String]', + weakMapTag = '[object WeakMap]'; + + var arrayBufferTag = '[object ArrayBuffer]', + dataViewTag = '[object DataView]', + float32Tag = '[object Float32Array]', + float64Tag = '[object Float64Array]', + int8Tag = '[object Int8Array]', + int16Tag = '[object Int16Array]', + int32Tag = '[object Int32Array]', + uint8Tag = '[object Uint8Array]', + uint8ClampedTag = '[object Uint8ClampedArray]', + uint16Tag = '[object Uint16Array]', + uint32Tag = '[object Uint32Array]'; + + /** Used to identify `toStringTag` values of typed arrays. */ + var typedArrayTags = {}; + typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = + typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = + typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = + typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = + typedArrayTags[uint32Tag] = true; + typedArrayTags[argsTag] = typedArrayTags[arrayTag] = + typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = + typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = + typedArrayTags[errorTag] = typedArrayTags[funcTag] = + typedArrayTags[mapTag] = typedArrayTags[numberTag] = + typedArrayTags[objectTag] = typedArrayTags[regexpTag] = + typedArrayTags[setTag] = typedArrayTags[stringTag] = + typedArrayTags[weakMapTag] = false; + + /** Used for built-in method references. */ + var objectProto = Object.prototype; + + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) + * of values. + */ + var objectToString = objectProto.toString; + + /** + * Checks if `value` is classified as a typed array. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is correctly classified, + * else `false`. + * @example + * + * _.isTypedArray(new Uint8Array); + * // => true + * + * _.isTypedArray([]); + * // => false + */ + function isTypedArray(value) { + return isObjectLike(value) && + isLength(value.length) && !!typedArrayTags[objectToString.call(value)]; + } + + module.e = isTypedArray; + + +/***/ }, +/* 43 */ +/***/ function(module, exports, __webpack_require__) { + + var baseKeysIn = __webpack_require__(132), + indexKeys = __webpack_require__(67), + isIndex = __webpack_require__(22), + isPrototype = __webpack_require__(40); + + /** Used for built-in method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * Creates an array of the own and inherited enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keysIn(new Foo); + * // => ['a', 'b', 'c'] (iteration order is not guaranteed) + */ + function keysIn(object) { + var index = -1, + isProto = isPrototype(object), + props = baseKeysIn(object), + propsLength = props.length, + indexes = indexKeys(object), + skipIndexes = !!indexes, + result = indexes || [], + length = result.length; + + while (++index < propsLength) { + var key = props[index]; + if (!(skipIndexes && (key == 'length' || isIndex(key, length))) && + !(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) { + result.push(key); + } + } + return result; + } + + module.e = keysIn; + + +/***/ }, +/* 44 */ +/***/ function(module, exports, __webpack_require__) { + + var apply = __webpack_require__(117), + toInteger = __webpack_require__(206); + + /** Used as the `TypeError` message for "Functions" methods. */ + var FUNC_ERROR_TEXT = 'Expected a function'; + + /* Built-in method references for those with the same name as other `lodash` methods. */ + var nativeMax = Math.max; + + /** + * Creates a function that invokes `func` with the `this` binding of the + * created function and arguments from `start` and beyond provided as + * an array. + * + * **Note:** This method is based on the + * [rest parameter](https://mdn.io/rest_parameters). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Function + * @param {Function} func The function to apply a rest parameter to. + * @param {number} [start=func.length-1] The start position of the rest parameter. + * @returns {Function} Returns the new function. + * @example + * + * var say = _.rest(function(what, names) { + * return what + ' ' + _.initial(names).join(', ') + + * (_.size(names) > 1 ? ', & ' : '') + _.last(names); + * }); + * + * say('hello', 'fred', 'barney', 'pebbles'); + * // => 'hello fred, barney, & pebbles' + */ + function rest(func, start) { + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + start = nativeMax(start === undefined ? (func.length - 1) : toInteger(start), 0); + return function() { + var args = arguments, + index = -1, + length = nativeMax(args.length - start, 0), + array = Array(length); + + while (++index < length) { + array[index] = args[start + index]; + } + switch (start) { + case 0: return func.call(this, array); + case 1: return func.call(this, args[0], array); + case 2: return func.call(this, args[0], args[1], array); + } + var otherArgs = Array(start + 1); + index = -1; + while (++index < start) { + otherArgs[index] = args[index]; + } + otherArgs[start] = array; + return apply(func, this, otherArgs); + }; + } + + module.e = rest; + + +/***/ }, +/* 45 */ +/***/ function(module, exports, __webpack_require__) { + + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__common_image_debug__ = __webpack_require__(10); + + + function contains(codeResult, list) { + if (list) { + return list.some(function (item) { + return Object.keys(item).every(function (key) { + return item[key] === codeResult[key]; + }); + }); + } + return false; + } + + function passesFilter(codeResult, filter) { + if (typeof filter === 'function') { + return filter(codeResult); + } + return true; + } + + /* harmony default export */ exports["a"] = { + create: function create(config) { + var canvas = document.createElement("canvas"), + ctx = canvas.getContext("2d"), + results = [], + capacity = config.capacity || 20, + capture = config.capture === true; + + function matchesConstraints(codeResult) { + return capacity && codeResult && !contains(codeResult, config.blacklist) && passesFilter(codeResult, config.filter); + } + + return { + addResult: function addResult(data, imageSize, codeResult) { + var result = {}; + + if (matchesConstraints(codeResult)) { + capacity--; + result.codeResult = codeResult; + if (capture) { + canvas.width = imageSize.x; + canvas.height = imageSize.y; + /* harmony import */__WEBPACK_IMPORTED_MODULE_0__common_image_debug__["a"].drawImage(data, imageSize, ctx); + result.frame = canvas.toDataURL(); + } + results.push(result); + } + }, + getResults: function getResults() { + return results; + } + }; + } + }; + +/***/ }, +/* 46 */ +/***/ function(module, exports, __webpack_require__) { + + var config = void 0; + + if (true) { + config = __webpack_require__(82); + } else if (ENV.node) { + config = require('./config.node.js'); + } else { + config = require('./config.prod.js'); + } + + /* harmony default export */ exports["a"] = config; + +/***/ }, +/* 47 */ +/***/ function(module, exports, __webpack_require__) { + + /** + * http://www.codeproject.com/Tips/407172/Connected-Component-Labeling-and-Vectorization + */ + var Tracer = { + searchDirections: [[0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1, -1], [-1, 0], [-1, 1]], + create: function create(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 trace(current, color, label, edgelabel) { + return _trace(current, color, label, edgelabel); + }, + contourTracing: function contourTracing(sy, sx, label, color, edgelabel) { + return _contourTracing(sy, sx, label, color, edgelabel); + } + }; + } + }; + + /* harmony default export */ exports["a"] = Tracer; + +/***/ }, +/* 48 */ +/***/ function(module, exports, __webpack_require__) { + + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__barcode_reader__ = __webpack_require__(11); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__common_array_helper__ = __webpack_require__(15); + + + + function Code39Reader() { + /* harmony import */__WEBPACK_IMPORTED_MODULE_0__barcode_reader__["a"].call(this); + } + + var properties = { + ALPHABETH_STRING: { value: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. *$/+%" }, + ALPHABET: { value: [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 45, 46, 32, 42, 36, 47, 43, 37] }, + CHARACTER_ENCODINGS: { value: [0x034, 0x121, 0x061, 0x160, 0x031, 0x130, 0x070, 0x025, 0x124, 0x064, 0x109, 0x049, 0x148, 0x019, 0x118, 0x058, 0x00D, 0x10C, 0x04C, 0x01C, 0x103, 0x043, 0x142, 0x013, 0x112, 0x052, 0x007, 0x106, 0x046, 0x016, 0x181, 0x0C1, 0x1C0, 0x091, 0x190, 0x0D0, 0x085, 0x184, 0x0C4, 0x094, 0x0A8, 0x0A2, 0x08A, 0x02A] }, + ASTERISK: { value: 0x094 }, + FORMAT: { value: "code_39", writeable: false } + }; + + Code39Reader.prototype = Object.create(/* harmony import */__WEBPACK_IMPORTED_MODULE_0__barcode_reader__["a"].prototype, properties); + Code39Reader.prototype.constructor = Code39Reader; + + Code39Reader.prototype._toCounters = function (start, counter) { + var self = this, + numCounters = counter.length, + end = self._row.length, + isWhite = !self._row[start], + i, + counterPos = 0; + + /* harmony import */__WEBPACK_IMPORTED_MODULE_1__common_array_helper__["a"].init(counter, 0); + + for (i = start; i < end; i++) { + if (self._row[i] ^ isWhite) { + counter[counterPos]++; + } else { + counterPos++; + if (counterPos === numCounters) { + break; + } else { + counter[counterPos] = 1; + isWhite = !isWhite; + } + } + } + + return counter; + }; + + Code39Reader.prototype._decode = function () { + var self = this, + counters = [0, 0, 0, 0, 0, 0, 0, 0, 0], + result = [], + start = self._findStart(), + decodedChar, + lastStart, + pattern, + nextStart; + + if (!start) { + return null; + } + nextStart = self._nextSet(self._row, start.end); + + do { + counters = self._toCounters(nextStart, counters); + pattern = self._toPattern(counters); + if (pattern < 0) { + return null; + } + decodedChar = self._patternToChar(pattern); + if (decodedChar < 0) { + return null; + } + result.push(decodedChar); + lastStart = nextStart; + nextStart += /* harmony import */__WEBPACK_IMPORTED_MODULE_1__common_array_helper__["a"].sum(counters); + nextStart = self._nextSet(self._row, nextStart); + } while (decodedChar !== '*'); + result.pop(); + + if (!result.length) { + return null; + } + + if (!self._verifyTrailingWhitespace(lastStart, nextStart, counters)) { + return null; + } + + return { + code: result.join(""), + start: start.start, + end: nextStart, + startInfo: start, + decodedCodes: result + }; + }; + + Code39Reader.prototype._verifyTrailingWhitespace = function (lastStart, nextStart, counters) { + var trailingWhitespaceEnd, + patternSize = /* harmony import */__WEBPACK_IMPORTED_MODULE_1__common_array_helper__["a"].sum(counters); + + trailingWhitespaceEnd = nextStart - lastStart - patternSize; + if (trailingWhitespaceEnd * 3 >= patternSize) { + return true; + } + return false; + }; + + Code39Reader.prototype._patternToChar = function (pattern) { + var i, + self = this; + + for (i = 0; i < self.CHARACTER_ENCODINGS.length; i++) { + if (self.CHARACTER_ENCODINGS[i] === pattern) { + return String.fromCharCode(self.ALPHABET[i]); + } + } + return -1; + }; + + Code39Reader.prototype._findNextWidth = function (counters, current) { + var i, + minWidth = Number.MAX_VALUE; + + for (i = 0; i < counters.length; i++) { + if (counters[i] < minWidth && counters[i] > current) { + minWidth = counters[i]; + } + } + + return minWidth; + }; + + Code39Reader.prototype._toPattern = function (counters) { + var numCounters = counters.length, + maxNarrowWidth = 0, + numWideBars = numCounters, + wideBarWidth = 0, + self = this, + pattern, + i; + + while (numWideBars > 3) { + maxNarrowWidth = self._findNextWidth(counters, maxNarrowWidth); + numWideBars = 0; + pattern = 0; + for (i = 0; i < numCounters; i++) { + if (counters[i] > maxNarrowWidth) { + pattern |= 1 << numCounters - 1 - i; + numWideBars++; + wideBarWidth += counters[i]; + } + } + + if (numWideBars === 3) { + for (i = 0; i < numCounters && numWideBars > 0; i++) { + if (counters[i] > maxNarrowWidth) { + numWideBars--; + if (counters[i] * 2 >= wideBarWidth) { + return -1; + } + } + } + return pattern; + } + } + return -1; + }; + + Code39Reader.prototype._findStart = function () { + var self = this, + offset = self._nextSet(self._row), + patternStart = offset, + counter = [0, 0, 0, 0, 0, 0, 0, 0, 0], + counterPos = 0, + isWhite = false, + i, + j, + whiteSpaceMustStart; + + for (i = offset; i < self._row.length; i++) { + if (self._row[i] ^ isWhite) { + counter[counterPos]++; + } else { + if (counterPos === counter.length - 1) { + // find start pattern + if (self._toPattern(counter) === self.ASTERISK) { + whiteSpaceMustStart = Math.floor(Math.max(0, patternStart - (i - patternStart) / 4)); + if (self._matchRange(whiteSpaceMustStart, patternStart, 0)) { + return { + start: patternStart, + end: i + }; + } + } + + patternStart += counter[0] + counter[1]; + for (j = 0; j < 7; j++) { + counter[j] = counter[j + 2]; + } + counter[7] = 0; + counter[8] = 0; + counterPos--; + } else { + counterPos++; + } + counter[counterPos] = 1; + isWhite = !isWhite; + } + } + return null; + }; + + /* harmony default export */ exports["a"] = Code39Reader; + +/***/ }, +/* 49 */ +/***/ function(module, exports, __webpack_require__) { + + module.e = dot + + /** + * Calculates the dot product of two vec2's + * + * @param {vec2} a the first operand + * @param {vec2} b the second operand + * @returns {Number} dot product of a and b + */ + function dot(a, b) { + return a[0] * b[0] + a[1] * b[1] + } + +/***/ }, +/* 50 */ +/***/ function(module, exports, __webpack_require__) { + + var getNative = __webpack_require__(6), + root = __webpack_require__(2); + + /* Built-in method references that are verified to be native. */ + var Map = getNative(root, 'Map'); + + module.e = Map; + + +/***/ }, +/* 51 */ +/***/ function(module, exports, __webpack_require__) { + + var MapCache = __webpack_require__(31), + setCacheAdd = __webpack_require__(186), + setCacheHas = __webpack_require__(187); + + /** + * + * Creates an array cache object to store unique values. + * + * @private + * @constructor + * @param {Array} [values] The values to cache. + */ + function SetCache(values) { + var index = -1, + length = values ? values.length : 0; + + this.__data__ = new MapCache; + while (++index < length) { + this.add(values[index]); + } + } + + // Add methods to `SetCache`. + SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; + SetCache.prototype.has = setCacheHas; + + module.e = SetCache; + + +/***/ }, +/* 52 */ +/***/ function(module, exports, __webpack_require__) { + + var root = __webpack_require__(2); + + /** Built-in value references. */ + var Uint8Array = root.Uint8Array; + + module.e = Uint8Array; + + +/***/ }, +/* 53 */ +/***/ function(module, exports, __webpack_require__) { + + /** + * A specialized version of `_.forEach` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns `array`. + */ + function arrayEach(array, iteratee) { + var index = -1, + length = array ? array.length : 0; + + while (++index < length) { + if (iteratee(array[index], index, array) === false) { + break; + } + } + return array; + } + + module.e = arrayEach; + + +/***/ }, +/* 54 */ +/***/ function(module, exports, __webpack_require__) { + + var eq = __webpack_require__(25); + + /** + * This function is like `assignValue` except that it doesn't assign + * `undefined` values. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ + function assignMergeValue(object, key, value) { + if ((value !== undefined && !eq(object[key], value)) || + (typeof key == 'number' && value === undefined && !(key in object))) { + object[key] = value; + } + } + + module.e = assignMergeValue; + + +/***/ }, +/* 55 */ +/***/ function(module, exports, __webpack_require__) { + + var eq = __webpack_require__(25); + + /** Used for built-in method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * Assigns `value` to `key` of `object` if the existing value is not equivalent + * using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) + * for equality comparisons. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ + function assignValue(object, key, value) { + var objValue = object[key]; + if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || + (value === undefined && !(key in object))) { + object[key] = value; + } + } + + module.e = assignValue; + + +/***/ }, +/* 56 */ +/***/ function(module, exports, __webpack_require__) { + + var arrayPush = __webpack_require__(34), + isFlattenable = __webpack_require__(171); + + /** + * The base implementation of `_.flatten` with support for restricting flattening. + * + * @private + * @param {Array} array The array to flatten. + * @param {number} depth The maximum recursion depth. + * @param {boolean} [predicate=isFlattenable] The function invoked per iteration. + * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks. + * @param {Array} [result=[]] The initial result value. + * @returns {Array} Returns the new flattened array. + */ + function baseFlatten(array, depth, predicate, isStrict, result) { + var index = -1, + length = array.length; + + predicate || (predicate = isFlattenable); + result || (result = []); + + while (++index < length) { + var value = array[index]; + if (depth > 0 && predicate(value)) { + if (depth > 1) { + // Recursively flatten arrays (susceptible to call stack limits). + baseFlatten(value, depth - 1, predicate, isStrict, result); + } else { + arrayPush(result, value); + } + } else if (!isStrict) { + result[result.length] = value; + } + } + return result; + } + + module.e = baseFlatten; + + +/***/ }, +/* 57 */ +/***/ function(module, exports, __webpack_require__) { + + var castPath = __webpack_require__(63), + isKey = __webpack_require__(23), + toKey = __webpack_require__(7); + + /** + * The base implementation of `_.get` without support for default values. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @returns {*} Returns the resolved value. + */ + function baseGet(object, path) { + path = isKey(path, object) ? [path] : castPath(path); + + var index = 0, + length = path.length; + + while (object != null && index < length) { + object = object[toKey(path[index++])]; + } + return (index && index == length) ? object : undefined; + } + + module.e = baseGet; + + +/***/ }, +/* 58 */ +/***/ function(module, exports, __webpack_require__) { + + var arrayPush = __webpack_require__(34), + isArray = __webpack_require__(0); + + /** + * The base implementation of `getAllKeys` and `getAllKeysIn` which uses + * `keysFunc` and `symbolsFunc` to get the enumerable property names and + * symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {Function} keysFunc The function to get the keys of `object`. + * @param {Function} symbolsFunc The function to get the symbols of `object`. + * @returns {Array} Returns the array of property names and symbols. + */ + function baseGetAllKeys(object, keysFunc, symbolsFunc) { + var result = keysFunc(object); + return isArray(object) ? result : arrayPush(result, symbolsFunc(object)); + } + + module.e = baseGetAllKeys; + + +/***/ }, +/* 59 */ +/***/ function(module, exports, __webpack_require__) { + + var getPrototype = __webpack_require__(20); + + /** Used for built-in method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * The base implementation of `_.has` without support for deep paths. + * + * @private + * @param {Object} [object] The object to query. + * @param {Array|string} key The key to check. + * @returns {boolean} Returns `true` if `key` exists, else `false`. + */ + function baseHas(object, key) { + // Avoid a bug in IE 10-11 where objects with a [[Prototype]] of `null`, + // that are composed entirely of index properties, return `false` for + // `hasOwnProperty` checks of them. + return object != null && + (hasOwnProperty.call(object, key) || + (typeof object == 'object' && key in object && getPrototype(object) === null)); + } + + module.e = baseHas; + + +/***/ }, +/* 60 */ +/***/ function(module, exports, __webpack_require__) { + + var baseIsEqualDeep = __webpack_require__(127), + isObject = __webpack_require__(3), + isObjectLike = __webpack_require__(4); + + /** + * The base implementation of `_.isEqual` which supports partial comparisons + * and tracks traversed objects. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @param {Function} [customizer] The function to customize comparisons. + * @param {boolean} [bitmask] The bitmask of comparison flags. + * The bitmask may be composed of the following flags: + * 1 - Unordered comparison + * 2 - Partial comparison + * @param {Object} [stack] Tracks traversed `value` and `other` objects. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + */ + function baseIsEqual(value, other, customizer, bitmask, stack) { + if (value === other) { + return true; + } + if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) { + return value !== value && other !== other; + } + return baseIsEqualDeep(value, other, baseIsEqual, customizer, bitmask, stack); + } + + module.e = baseIsEqual; + + +/***/ }, +/* 61 */ +/***/ function(module, exports, __webpack_require__) { + + var arrayReduce = __webpack_require__(35); + + /** + * The base implementation of `_.pick` without support for individual + * property identifiers. + * + * @private + * @param {Object} object The source object. + * @param {string[]} props The property identifiers to pick. + * @returns {Object} Returns the new object. + */ + function basePick(object, props) { + object = Object(object); + return arrayReduce(props, function(result, key) { + if (key in object) { + result[key] = object[key]; + } + return result; + }, {}); + } + + module.e = basePick; + + +/***/ }, +/* 62 */ +/***/ function(module, exports, __webpack_require__) { + + /** + * The base implementation of `_.property` without support for deep paths. + * + * @private + * @param {string} key The key of the property to get. + * @returns {Function} Returns the new accessor function. + */ + function baseProperty(key) { + return function(object) { + return object == null ? undefined : object[key]; + }; + } + + module.e = baseProperty; + + +/***/ }, +/* 63 */ +/***/ function(module, exports, __webpack_require__) { + + var isArray = __webpack_require__(0), + stringToPath = __webpack_require__(193); + + /** + * Casts `value` to a path array if it's not one. + * + * @private + * @param {*} value The value to inspect. + * @returns {Array} Returns the cast property path array. + */ + function castPath(value) { + return isArray(value) ? value : stringToPath(value); + } + + module.e = castPath; + + +/***/ }, +/* 64 */ +/***/ function(module, exports, __webpack_require__) { + + /** + * Copies the values of `source` to `array`. + * + * @private + * @param {Array} source The array to copy values from. + * @param {Array} [array=[]] The array to copy values to. + * @returns {Array} Returns `array`. + */ + function copyArray(source, array) { + var index = -1, + length = source.length; + + array || (array = Array(length)); + while (++index < length) { + array[index] = source[index]; + } + return array; + } + + module.e = copyArray; + + +/***/ }, +/* 65 */ +/***/ function(module, exports, __webpack_require__) { + + var SetCache = __webpack_require__(51), + arraySome = __webpack_require__(120); + + /** Used to compose bitmasks for comparison styles. */ + var UNORDERED_COMPARE_FLAG = 1, + PARTIAL_COMPARE_FLAG = 2; + + /** + * A specialized version of `baseIsEqualDeep` for arrays with support for + * partial deep comparisons. + * + * @private + * @param {Array} array The array to compare. + * @param {Array} other The other array to compare. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Function} customizer The function to customize comparisons. + * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual` + * for more details. + * @param {Object} stack Tracks traversed `array` and `other` objects. + * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. + */ + function equalArrays(array, other, equalFunc, customizer, bitmask, stack) { + var isPartial = bitmask & PARTIAL_COMPARE_FLAG, + arrLength = array.length, + othLength = other.length; + + if (arrLength != othLength && !(isPartial && othLength > arrLength)) { + return false; + } + // Assume cyclic values are equal. + var stacked = stack.get(array); + if (stacked) { + return stacked == other; + } + var index = -1, + result = true, + seen = (bitmask & UNORDERED_COMPARE_FLAG) ? new SetCache : undefined; + + stack.set(array, other); + + // Ignore non-index properties. + while (++index < arrLength) { + var arrValue = array[index], + othValue = other[index]; + + if (customizer) { + var compared = isPartial + ? customizer(othValue, arrValue, index, other, array, stack) + : customizer(arrValue, othValue, index, array, other, stack); + } + if (compared !== undefined) { + if (compared) { + continue; + } + result = false; + break; + } + // Recursively compare arrays (susceptible to call stack limits). + if (seen) { + if (!arraySome(other, function(othValue, othIndex) { + if (!seen.has(othIndex) && + (arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack))) { + return seen.add(othIndex); + } + })) { + result = false; + break; + } + } else if (!( + arrValue === othValue || + equalFunc(arrValue, othValue, customizer, bitmask, stack) + )) { + result = false; + break; + } + } + stack['delete'](array); + return result; + } + + module.e = equalArrays; + + +/***/ }, +/* 66 */ +/***/ function(module, exports, __webpack_require__) { + + var baseGetAllKeys = __webpack_require__(58), + getSymbolsIn = __webpack_require__(159), + keysIn = __webpack_require__(43); + + /** + * Creates an array of own and inherited enumerable property names and + * symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names and symbols. + */ + function getAllKeysIn(object) { + return baseGetAllKeys(object, keysIn, getSymbolsIn); + } + + module.e = getAllKeysIn; + + +/***/ }, +/* 67 */ +/***/ function(module, exports, __webpack_require__) { + + var baseTimes = __webpack_require__(139), + isArguments = __webpack_require__(13), + isArray = __webpack_require__(0), + isLength = __webpack_require__(27), + isString = __webpack_require__(41); + + /** + * Creates an array of index keys for `object` values of arrays, + * `arguments` objects, and strings, otherwise `null` is returned. + * + * @private + * @param {Object} object The object to query. + * @returns {Array|null} Returns index keys, else `null`. + */ + function indexKeys(object) { + var length = object ? object.length : undefined; + if (isLength(length) && + (isArray(object) || isString(object) || isArguments(object))) { + return baseTimes(length, String); + } + return null; + } + + module.e = indexKeys; + + +/***/ }, +/* 68 */ +/***/ function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(3); + + /** + * Checks if `value` is suitable for strict equality comparisons, i.e. `===`. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` if suitable for strict + * equality comparisons, else `false`. + */ + function isStrictComparable(value) { + return value === value && !isObject(value); + } + + module.e = isStrictComparable; + + +/***/ }, +/* 69 */ +/***/ function(module, exports, __webpack_require__) { + + /** + * Converts `map` to its key-value pairs. + * + * @private + * @param {Object} map The map to convert. + * @returns {Array} Returns the key-value pairs. + */ + function mapToArray(map) { + var index = -1, + result = Array(map.size); + + map.forEach(function(value, key) { + result[++index] = [key, value]; + }); + return result; + } + + module.e = mapToArray; + + +/***/ }, +/* 70 */ +/***/ function(module, exports, __webpack_require__) { + + /** + * A specialized version of `matchesProperty` for source values suitable + * for strict equality comparisons, i.e. `===`. + * + * @private + * @param {string} key The key of the property to get. + * @param {*} srcValue The value to match. + * @returns {Function} Returns the new spec function. + */ + function matchesStrictComparable(key, srcValue) { + return function(object) { + if (object == null) { + return false; + } + return object[key] === srcValue && + (srcValue !== undefined || (key in Object(object))); + }; + } + + module.e = matchesStrictComparable; + + +/***/ }, +/* 71 */ +/***/ function(module, exports, __webpack_require__) { + + /** + * Converts `set` to an array of its values. + * + * @private + * @param {Object} set The set to convert. + * @returns {Array} Returns the values. + */ + function setToArray(set) { + var index = -1, + result = Array(set.size); + + set.forEach(function(value) { + result[++index] = value; + }); + return result; + } + + module.e = setToArray; + + +/***/ }, +/* 72 */ +/***/ function(module, exports, __webpack_require__) { + + /** Used to resolve the decompiled source of functions. */ + var funcToString = Function.prototype.toString; + + /** + * Converts `func` to its source code. + * + * @private + * @param {Function} func The function to process. + * @returns {string} Returns the source code. + */ + function toSource(func) { + if (func != null) { + try { + return funcToString.call(func); + } catch (e) {} + try { + return (func + ''); + } catch (e) {} + } + return ''; + } + + module.e = toSource; + + +/***/ }, +/* 73 */ +/***/ function(module, exports, __webpack_require__) { + + var isArrayLike = __webpack_require__(26), + isObjectLike = __webpack_require__(4); + + /** + * This method is like `_.isArrayLike` except that it also checks if `value` + * is an object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array-like object, + * else `false`. + * @example + * + * _.isArrayLikeObject([1, 2, 3]); + * // => true + * + * _.isArrayLikeObject(document.body.children); + * // => true + * + * _.isArrayLikeObject('abc'); + * // => false + * + * _.isArrayLikeObject(_.noop); + * // => false + */ + function isArrayLikeObject(value) { + return isObjectLike(value) && isArrayLike(value); + } + + module.e = isArrayLikeObject; + + +/***/ }, +/* 74 */ +/***/ function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(module) {var root = __webpack_require__(2), + stubFalse = __webpack_require__(204); + + /** Detect free variable `exports`. */ + var freeExports = typeof exports == 'object' && exports; + + /** Detect free variable `module`. */ + var freeModule = freeExports && typeof module == 'object' && module; + + /** Detect the popular CommonJS extension `module.exports`. */ + var moduleExports = freeModule && freeModule.exports === freeExports; + + /** Built-in value references. */ + var Buffer = moduleExports ? root.Buffer : undefined; + + /** + * Checks if `value` is a buffer. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a buffer, else `false`. + * @example + * + * _.isBuffer(new Buffer(2)); + * // => true + * + * _.isBuffer(new Uint8Array(2)); + * // => false + */ + var isBuffer = !Buffer ? stubFalse : function(value) { + return value instanceof Buffer; + }; + + module.e = isBuffer; + + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(211)(module))) + +/***/ }, +/* 75 */ +/***/ function(module, exports, __webpack_require__) { + + var arrayMap = __webpack_require__(33), + baseFlatten = __webpack_require__(56), + basePick = __webpack_require__(61), + rest = __webpack_require__(44), + toKey = __webpack_require__(7); + + /** + * Creates an object composed of the picked `object` properties. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The source object. + * @param {...(string|string[])} [props] The property identifiers to pick. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.pick(object, ['a', 'c']); + * // => { 'a': 1, 'c': 3 } + */ + var pick = rest(function(object, props) { + return object == null ? {} : basePick(object, arrayMap(baseFlatten(props, 1), toKey)); + }); + + module.e = pick; + + +/***/ }, +/* 76 */ +/***/ function(module, exports, __webpack_require__) { + + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_lodash_merge__ = __webpack_require__(9); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_lodash_merge___default = __WEBPACK_IMPORTED_MODULE_0_lodash_merge__ && __WEBPACK_IMPORTED_MODULE_0_lodash_merge__.__esModule ? function() { return __WEBPACK_IMPORTED_MODULE_0_lodash_merge__['default'] } : function() { return __WEBPACK_IMPORTED_MODULE_0_lodash_merge__; } + /* harmony import */ Object.defineProperty(__WEBPACK_IMPORTED_MODULE_0_lodash_merge___default, 'a', { get: __WEBPACK_IMPORTED_MODULE_0_lodash_merge___default }); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__common_typedefs__ = __webpack_require__(81); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__common_typedefs___default = __WEBPACK_IMPORTED_MODULE_1__common_typedefs__ && __WEBPACK_IMPORTED_MODULE_1__common_typedefs__.__esModule ? function() { return __WEBPACK_IMPORTED_MODULE_1__common_typedefs__['default'] } : function() { return __WEBPACK_IMPORTED_MODULE_1__common_typedefs__; } + /* harmony import */ Object.defineProperty(__WEBPACK_IMPORTED_MODULE_1__common_typedefs___default, 'a', { get: __WEBPACK_IMPORTED_MODULE_1__common_typedefs___default }); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_webrtc_adapter__ = __webpack_require__(212); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_webrtc_adapter___default = __WEBPACK_IMPORTED_MODULE_2_webrtc_adapter__ && __WEBPACK_IMPORTED_MODULE_2_webrtc_adapter__.__esModule ? function() { return __WEBPACK_IMPORTED_MODULE_2_webrtc_adapter__['default'] } : function() { return __WEBPACK_IMPORTED_MODULE_2_webrtc_adapter__; } + /* harmony import */ Object.defineProperty(__WEBPACK_IMPORTED_MODULE_2_webrtc_adapter___default, 'a', { get: __WEBPACK_IMPORTED_MODULE_2_webrtc_adapter___default }); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__scanner__ = __webpack_require__(102); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__common_image_wrapper__ = __webpack_require__(30); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__common_image_debug__ = __webpack_require__(10); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__analytics_result_collector__ = __webpack_require__(45); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__config_config__ = __webpack_require__(46); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__input_config_factory__ = __webpack_require__(86); + + + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; }; + + + + + + + + + + + + function _fromConfig(config) { + var scanner = /* harmony import */__WEBPACK_IMPORTED_MODULE_3__scanner__["a"].bind()(); + var pendingStart = null; + var initialized = false; + return { + addEventListener: function addEventListener(eventType, cb) { + scanner.subscribe(eventType, cb); + return this; + }, + removeEventListener: function removeEventListener(eventType, cb) { + scanner.unsubscribe(eventType, cb); + return this; + }, + start: function start() { + if (scanner.isRunning()) { + return Promise.resolve(true); + } + if (pendingStart) { + return pendingStart; + } + if (initialized) { + scanner.start(); + return Promise.resolve(true); + } + pendingStart = new Promise(function (resolve, reject) { + scanner.init(config, function (error) { + if (error) { + console.log(error); + reject(error); + } + initialized = true; + scanner.start(); + resolve(); + pendingStart = null; + }); + }); + return pendingStart; + }, + stop: function stop() { + scanner.stop(); + return this; + }, + toPromise: function toPromise() { + var _this = this; + + if (config.inputStream.type === 'LiveStream' || config.inputStream.type === 'VideoStream') { + var _ret = function () { + var cancelRequested = false; + return { + v: { + cancel: function cancel() { + cancelRequested = true; + }, + + promise: new Promise(function (resolve, reject) { + function onProcessed(result) { + if (result && result.codeResult && result.codeResult.code) { + scanner.stop(); + scanner.unsubscribe("processed", onProcessed); + resolve(result); + } + if (cancelRequested) { + scanner.stop(); + scanner.unsubscribe("processed", onProcessed); + reject("cancelled!"); + } + } + scanner.subscribe("processed", onProcessed); + _this.start(); + }) + } + }; + }(); + + if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === "object") return _ret.v; + } else { + return new Promise(function (resolve, reject) { + scanner.decodeSingle(config, function (result) { + if (result && result.codeResult && result.codeResult.code) { + return resolve(result); + } + return reject(result); + }); + }); + } + }, + registerResultCollector: function registerResultCollector(resultCollector) { + scanner.registerResultCollector(resultCollector); + }, + getCanvas: function getCanvas() { + return scanner.canvas.dom.image; + } + }; + } + + function _fromSource(config, source) { + var inputConfig = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2]; + + config = /* harmony import */__WEBPACK_IMPORTED_MODULE_8__input_config_factory__["a"].bind()(config, inputConfig, source); + return _fromConfig(config); + } + + function setConfig() { + var configuration = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; + + var _merge2; + + var key = arguments[1]; + var config = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2]; + + var mergedConfig = /* harmony import */__WEBPACK_IMPORTED_MODULE_0_lodash_merge___default.a.bind()({}, configuration, (_merge2 = {}, _merge2[key] = config, _merge2)); + return createApi(mergedConfig); + } + + function createApi() { + var configuration = arguments.length <= 0 || arguments[0] === undefined ? /* harmony import */__WEBPACK_IMPORTED_MODULE_7__config_config__["a"] : arguments[0]; + + return { + fromSource: function fromSource(src, inputConfig) { + return _fromSource(configuration, src, inputConfig); + }, + fromConfig: function fromConfig(conf) { + return _fromConfig(/* harmony import */__WEBPACK_IMPORTED_MODULE_0_lodash_merge___default.a.bind()({}, configuration, conf)); + }, + decoder: function decoder(conf) { + return setConfig(configuration, "decoder", conf); + }, + locator: function locator(conf) { + return setConfig(configuration, "locator", conf); + }, + throttle: function throttle(timeInMs) { + return setConfig(configuration, "frequency", 1000 / parseInt(timeInMs)); + }, + config: function config(conf) { + return createApi(/* harmony import */__WEBPACK_IMPORTED_MODULE_0_lodash_merge___default.a.bind()({}, configuration, conf)); + }, + + ImageWrapper: /* harmony import */__WEBPACK_IMPORTED_MODULE_4__common_image_wrapper__["a"], + ImageDebug: /* harmony import */__WEBPACK_IMPORTED_MODULE_5__common_image_debug__["a"], + ResultCollector: /* harmony import */__WEBPACK_IMPORTED_MODULE_6__analytics_result_collector__["a"], + _worker: { + createScanner: /* harmony import */__WEBPACK_IMPORTED_MODULE_3__scanner__["a"] + } + }; + } + /* harmony default export */ exports["default"] = createApi(); + +/***/ }, +/* 77 */ +/***/ function(module, exports, __webpack_require__) { + + var vec2 = { + clone: __webpack_require__(12), + dot: __webpack_require__(49) + }; + + /** + * Creates a cluster for grouping similar orientations of datapoints + */ + /* harmony default export */ exports["a"] = { + create: function create(point, threshold) { + var points = [], + center = { + rad: 0, + vec: vec2.clone([0, 0]) + }, + pointMap = {}; + + function init() { + _add(point); + updateCenter(); + } + + function _add(pointToAdd) { + pointMap[pointToAdd.id] = pointToAdd; + points.push(pointToAdd); + } + + 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.clone([Math.cos(center.rad), Math.sin(center.rad)]); + } + + init(); + + return { + add: function add(pointToAdd) { + if (!pointMap[pointToAdd.id]) { + _add(pointToAdd); + updateCenter(); + } + }, + fits: function fits(otherPoint) { + // check cosine similarity to center-angle + var similarity = Math.abs(vec2.dot(otherPoint.point.vec, center.vec)); + if (similarity > threshold) { + return true; + } + return false; + }, + getPoints: function getPoints() { + return points; + }, + getCenter: function getCenter() { + return center; + } + }; + }, + createPoint: function createPoint(newPoint, id, property) { + return { + rad: newPoint[property], + point: newPoint, + id: id + }; + } + }; + +/***/ }, +/* 78 */ +/***/ function(module, exports, __webpack_require__) { + + var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; + + var hasWindow = typeof window !== 'undefined'; + var windowRef = hasWindow ? window : {}; + + var windowObjects = ["MediaStream", "HTMLImageElement", "HTMLVideoElement", "HTMLCanvasElement", "FileList", "File", "URL"]; + + var DOMHelper = windowObjects.reduce(function (result, obj) { + var _extends2; + + return _extends({}, result, (_extends2 = {}, _extends2[obj] = obj in windowRef ? windowRef[obj] : function () {}, _extends2)); + }, {}); + + DOMHelper.setObject = function (key, value) { + DOMHelper[key] = value; + }; + + /* harmony default export */ exports["a"] = DOMHelper; + +/***/ }, +/* 79 */ +/***/ function(module, exports, __webpack_require__) { + + /* harmony export */ exports["a"] = createEventedElement;function createEventedElement() { + var events = {}; + + function getEvent(eventName) { + if (!events[eventName]) { + events[eventName] = { + subscribers: [] + }; + } + return events[eventName]; + } + + function clearEvents() { + events = {}; + } + + function publishSubscription(subscription, data) { + if (subscription.async) { + setTimeout(function () { + subscription.callback(data); + }, 4); + } else { + subscription.callback(data); + } + } + + function _subscribe(event, callback, async) { + var subscription; + + if (typeof callback === "function") { + subscription = { + callback: callback, + async: async + }; + } else { + subscription = callback; + if (!subscription.callback) { + throw "Callback was not specified on options"; + } + } + + getEvent(event).subscribers.push(subscription); + } + + return { + subscribe: function subscribe(event, callback, async) { + return _subscribe(event, callback, async); + }, + publish: function publish(eventName, data) { + var event = getEvent(eventName), + subscribers = event.subscribers; + + // Publish one-time subscriptions + subscribers.filter(function (subscriber) { + return !!subscriber.once; + }).forEach(function (subscriber) { + publishSubscription(subscriber, data); + }); + + // remove them from the subscriber + event.subscribers = subscribers.filter(function (subscriber) { + return !subscriber.once; + }); + + // publish the rest + event.subscribers.forEach(function (subscriber) { + publishSubscription(subscriber, data); + }); + }, + once: function once(event, callback, async) { + _subscribe(event, { + callback: callback, + async: async, + once: true + }); + }, + unsubscribe: function unsubscribe(eventName, callback) { + var event; + + if (eventName) { + event = getEvent(eventName); + if (event && callback) { + event.subscribers = event.subscribers.filter(function (subscriber) { + return subscriber.callback !== callback; + }); + } else { + event.subscribers = []; + } + } else { + clearEvents(); + } + } + }; + }; + +/***/ }, +/* 80 */ +/***/ function(module, exports, __webpack_require__) { + + /** + * 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; + }; + + /* harmony default export */ exports["a"] = SubImage; + +/***/ }, +/* 81 */ +/***/ function(module, exports) { + + /* + * typedefs.js + * Normalizes browser-specific prefixes + */ + + if (typeof window !== 'undefined') { + window.requestAnimFrame = function () { + return window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame || function ( /* function FrameRequestCallback */callback) { + window.setTimeout(callback, 1000 / 60); + }; + }(); + } + Math.imul = Math.imul || function (a, b) { + var ah = a >>> 16 & 0xffff, + al = a & 0xffff, + bh = b >>> 16 & 0xffff, + bl = b & 0xffff; + // the shift by 0 fixes the sign on the high part + // the final |0 converts the unsigned value into a signed value + return al * bl + (ah * bl + al * bh << 16 >>> 0) | 0; + }; + +/***/ }, +/* 82 */ +/***/ function(module, exports, __webpack_require__) { + + module.e = { + inputStream: { + name: "Live", + type: "LiveStream", + constraints: { + width: 640, + height: 480, + // aspectRatio: 640/480, // optional + facingMode: "environment" }, + area: { + top: "0%", + right: "0%", + left: "0%", + bottom: "0%" + }, + singleChannel: false // true: only the red color-channel is read + }, + locate: true, + numOfWorkers: 2, + decoder: { + readers: ['code_128_reader'], + debug: { + drawBoundingBox: false, + showFrequency: false, + drawScanline: false, + showPattern: false + } + }, + locator: { + halfSample: true, + patchSize: "medium", // x-small, small, medium, large, x-large + debug: { + showCanvas: false, + showPatches: false, + showFoundPatches: false, + showSkeleton: false, + showLabels: false, + showPatchLabels: false, + showRemainingPatchLabels: false, + boxFromPatches: { + showTransformed: false, + showTransformedBox: false, + showBB: false + } + } + } + }; + +/***/ }, +/* 83 */ +/***/ function(module, exports, __webpack_require__) { + + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__bresenham__ = __webpack_require__(84); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__common_image_debug__ = __webpack_require__(10); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__reader_code_128_reader__ = __webpack_require__(94); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__reader_ean_reader__ = __webpack_require__(5); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__reader_code_39_reader__ = __webpack_require__(48); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__reader_code_39_vin_reader__ = __webpack_require__(95); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__reader_codabar_reader__ = __webpack_require__(93); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__reader_upc_reader__ = __webpack_require__(101); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__reader_ean_8_reader__ = __webpack_require__(98); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_9__reader_ean_2_reader__ = __webpack_require__(96); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__reader_ean_5_reader__ = __webpack_require__(97); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_11__reader_upc_e_reader__ = __webpack_require__(100); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_12__reader_i2of5_reader__ = __webpack_require__(99); + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; }; + + + + + + + + + + + + + + + + var READERS = { + code_128_reader: /* harmony import */__WEBPACK_IMPORTED_MODULE_2__reader_code_128_reader__["a"], + ean_reader: /* harmony import */__WEBPACK_IMPORTED_MODULE_3__reader_ean_reader__["a"], + ean_5_reader: /* harmony import */__WEBPACK_IMPORTED_MODULE_10__reader_ean_5_reader__["a"], + ean_2_reader: /* harmony import */__WEBPACK_IMPORTED_MODULE_9__reader_ean_2_reader__["a"], + ean_8_reader: /* harmony import */__WEBPACK_IMPORTED_MODULE_8__reader_ean_8_reader__["a"], + code_39_reader: /* harmony import */__WEBPACK_IMPORTED_MODULE_4__reader_code_39_reader__["a"], + code_39_vin_reader: /* harmony import */__WEBPACK_IMPORTED_MODULE_5__reader_code_39_vin_reader__["a"], + codabar_reader: /* harmony import */__WEBPACK_IMPORTED_MODULE_6__reader_codabar_reader__["a"], + upc_reader: /* harmony import */__WEBPACK_IMPORTED_MODULE_7__reader_upc_reader__["a"], + upc_e_reader: /* harmony import */__WEBPACK_IMPORTED_MODULE_11__reader_upc_e_reader__["a"], + i2of5_reader: /* harmony import */__WEBPACK_IMPORTED_MODULE_12__reader_i2of5_reader__["a"] + }; + /* harmony default export */ exports["a"] = { + create: function create(config, inputImageWrapper) { + var _canvas = { + ctx: { + frequency: null, + pattern: null, + overlay: null + }, + dom: { + frequency: null, + pattern: null, + overlay: null + } + }, + _barcodeReaders = []; + + initCanvas(); + initReaders(); + initConfig(); + + function initCanvas() { + if (true && typeof document !== 'undefined') { + var $debug = document.querySelector("#debug.detection"); + _canvas.dom.frequency = document.querySelector("canvas.frequency"); + if (!_canvas.dom.frequency) { + _canvas.dom.frequency = document.createElement("canvas"); + _canvas.dom.frequency.className = "frequency"; + if ($debug) { + $debug.appendChild(_canvas.dom.frequency); + } + } + _canvas.ctx.frequency = _canvas.dom.frequency.getContext("2d"); + + _canvas.dom.pattern = document.querySelector("canvas.patternBuffer"); + if (!_canvas.dom.pattern) { + _canvas.dom.pattern = document.createElement("canvas"); + _canvas.dom.pattern.className = "patternBuffer"; + if ($debug) { + $debug.appendChild(_canvas.dom.pattern); + } + } + _canvas.ctx.pattern = _canvas.dom.pattern.getContext("2d"); + + if ($debug) { + _canvas.dom.overlay = document.querySelector("canvas.drawingBuffer"); + if (!_canvas.dom.overlay) { + _canvas.dom.overlay = document.createElement("canvas"); + _canvas.dom.overlay.className = "drawingBuffer"; + $debug.appendChild(_canvas.dom.overlay); + } + _canvas.ctx.overlay = _canvas.dom.overlay.getContext("2d"); + } + } + } + + function initReaders() { + config.readers.forEach(function (readerConfig) { + var reader, + configuration = {}, + supplements = []; + + if ((typeof readerConfig === 'undefined' ? 'undefined' : _typeof(readerConfig)) === 'object') { + reader = readerConfig.format; + configuration = readerConfig.config; + } else if (typeof readerConfig === 'string') { + reader = readerConfig; + } + if (true) { + console.log("Before registering reader: ", reader); + } + if (configuration.supplements) { + supplements = configuration.supplements.map(function (supplement) { + return new READERS[supplement](); + }); + } + _barcodeReaders.push(new READERS[reader](configuration, supplements)); + }); + if (true) { + console.log("Registered Readers: " + _barcodeReaders.map(function (reader) { + return JSON.stringify({ format: reader.FORMAT, config: reader.config }); + }).join(', ')); + } + } + + function initConfig() { + if (true && typeof document !== 'undefined') { + var i, + vis = [{ + node: _canvas.dom.frequency, + prop: config.debug.showFrequency + }, { + node: _canvas.dom.pattern, + prop: config.debug.showPattern + }]; + + for (i = 0; i < vis.length; i++) { + if (vis[i].prop === true) { + vis[i].node.style.display = "block"; + } else { + vis[i].node.style.display = "none"; + } + } + } + } + + /** + * extend the line on both ends + * @param {Array} line + * @param {Number} angle + */ + function getExtendedLine(line, angle, ext) { + function extendLine(amount) { + var extension = { + y: amount * Math.sin(angle), + x: amount * Math.cos(angle) + }; + + line[0].y -= extension.y; + line[0].x -= extension.x; + line[1].y += extension.y; + line[1].x += extension.x; + } + + // check if inside image + extendLine(ext); + while (ext > 1 && (!inputImageWrapper.inImageWithBorder(line[0], 0) || !inputImageWrapper.inImageWithBorder(line[1], 0))) { + ext -= Math.ceil(ext / 2); + extendLine(-ext); + } + return line; + } + + function getLine(box) { + return [{ + x: (box[1][0] - box[0][0]) / 2 + box[0][0], + y: (box[1][1] - box[0][1]) / 2 + box[0][1] + }, { + x: (box[3][0] - box[2][0]) / 2 + box[2][0], + y: (box[3][1] - box[2][1]) / 2 + box[2][1] + }]; + } + + function tryDecode(line) { + var result = null, + i, + barcodeLine = /* harmony import */__WEBPACK_IMPORTED_MODULE_0__bresenham__["a"].getBarcodeLine(inputImageWrapper, line[0], line[1]); + + if (true && config.debug.showFrequency) { + /* harmony import */__WEBPACK_IMPORTED_MODULE_1__common_image_debug__["a"].drawPath(line, { x: 'x', y: 'y' }, _canvas.ctx.overlay, { color: 'red', lineWidth: 3 }); + /* harmony import */__WEBPACK_IMPORTED_MODULE_0__bresenham__["a"].debug.printFrequency(barcodeLine.line, _canvas.dom.frequency); + } + + /* harmony import */__WEBPACK_IMPORTED_MODULE_0__bresenham__["a"].toBinaryLine(barcodeLine); + + if (true && config.debug.showPattern) { + /* harmony import */__WEBPACK_IMPORTED_MODULE_0__bresenham__["a"].debug.printPattern(barcodeLine.line, _canvas.dom.pattern); + } + + for (i = 0; i < _barcodeReaders.length && result === null; i++) { + result = _barcodeReaders[i].decodePattern(barcodeLine.line); + } + if (result === null) { + return null; + } + return { + codeResult: result, + barcodeLine: barcodeLine + }; + } + + /** + * This method slices the given area apart and tries to detect a barcode-pattern + * for each slice. It returns the decoded barcode, or null if nothing was found + * @param {Array} box + * @param {Array} line + * @param {Number} lineAngle + */ + function tryDecodeBruteForce(box, line, lineAngle) { + var sideLength = Math.sqrt(Math.pow(box[1][0] - box[0][0], 2) + Math.pow(box[1][1] - box[0][1], 2)), + i, + slices = 16, + result = null, + dir, + extension, + xdir = Math.sin(lineAngle), + ydir = Math.cos(lineAngle); + + for (i = 1; i < slices && result === null; i++) { + // move line perpendicular to angle + dir = sideLength / slices * i * (i % 2 === 0 ? -1 : 1); + extension = { + y: dir * xdir, + x: dir * ydir + }; + line[0].y += extension.x; + line[0].x -= extension.y; + line[1].y += extension.x; + line[1].x -= extension.y; + + result = tryDecode(line); + } + return result; + } + + function getLineLength(line) { + return Math.sqrt(Math.pow(Math.abs(line[1].y - line[0].y), 2) + Math.pow(Math.abs(line[1].x - line[0].x), 2)); + } + + /** + * With the help of the configured readers (Code128 or EAN) this function tries to detect a + * valid barcode pattern within the given area. + * @param {Object} box The area to search in + * @returns {Object} the result {codeResult, line, angle, pattern, threshold} + */ + function _decodeFromBoundingBox(box) { + var line, + lineAngle, + ctx = _canvas.ctx.overlay, + result, + lineLength; + + if (true) { + if (config.debug.drawBoundingBox && ctx) { + /* harmony import */__WEBPACK_IMPORTED_MODULE_1__common_image_debug__["a"].drawPath(box, { x: 0, y: 1 }, ctx, { color: "blue", lineWidth: 2 }); + } + } + + line = getLine(box); + lineLength = getLineLength(line); + lineAngle = Math.atan2(line[1].y - line[0].y, line[1].x - line[0].x); + line = getExtendedLine(line, lineAngle, Math.floor(lineLength * 0.1)); + if (line === null) { + return null; + } + + result = tryDecode(line); + if (result === null) { + result = tryDecodeBruteForce(box, line, lineAngle); + } + + if (result === null) { + return null; + } + + if (true && result && config.debug.drawScanline && ctx) { + /* harmony import */__WEBPACK_IMPORTED_MODULE_1__common_image_debug__["a"].drawPath(line, { x: 'x', y: 'y' }, ctx, { color: 'red', lineWidth: 3 }); + } + + return { + codeResult: result.codeResult, + line: line, + angle: lineAngle, + pattern: result.barcodeLine.line, + threshold: result.barcodeLine.threshold + }; + } + + return { + decodeFromBoundingBox: function decodeFromBoundingBox(box) { + return _decodeFromBoundingBox(box); + }, + decodeFromBoundingBoxes: function decodeFromBoundingBoxes(boxes) { + var i, + result, + barcodes = [], + multiple = config.multiple; + + for (i = 0; i < boxes.length; i++) { + var box = boxes[i]; + result = _decodeFromBoundingBox(box) || {}; + result.box = box; + + if (multiple) { + barcodes.push(result); + } else if (result.codeResult) { + return result; + } + } + + if (multiple) { + return { + barcodes: barcodes + }; + } + }, + setReaders: function setReaders(readers) { + config.readers = readers; + _barcodeReaders.length = 0; + initReaders(); + } + }; + } + }; + +/***/ }, +/* 84 */ +/***/ function(module, exports, __webpack_require__) { + + var Bresenham = {}; + + var Slope = { + DIR: { + UP: 1, + DOWN: -1 + } + }; + /** + * Scans a line of the given image from point p1 to p2 and returns a result object containing + * gray-scale values (0-255) of the underlying pixels in addition to the min + * and max values. + * @param {Object} imageWrapper + * @param {Object} p1 The start point {x,y} + * @param {Object} p2 The end point {x,y} + * @returns {line, min, max} + */ + Bresenham.getBarcodeLine = function (imageWrapper, p1, p2) { + var x0 = p1.x | 0, + y0 = p1.y | 0, + x1 = p2.x | 0, + y1 = p2.y | 0, + steep = Math.abs(y1 - y0) > Math.abs(x1 - x0), + deltax, + deltay, + error, + ystep, + y, + tmp, + x, + line = [], + imageData = imageWrapper.data, + width = imageWrapper.size.x, + sum = 0, + val, + min = 255, + max = 0; + + function read(a, b) { + val = imageData[b * width + a]; + sum += val; + min = val < min ? val : min; + max = val > max ? val : max; + line.push(val); + } + + if (steep) { + tmp = x0; + x0 = y0; + y0 = tmp; + + tmp = x1; + x1 = y1; + y1 = tmp; + } + if (x0 > x1) { + tmp = x0; + x0 = x1; + x1 = tmp; + + tmp = y0; + y0 = y1; + y1 = tmp; + } + deltax = x1 - x0; + deltay = Math.abs(y1 - y0); + error = deltax / 2 | 0; + y = y0; + ystep = y0 < y1 ? 1 : -1; + for (x = x0; x < x1; x++) { + if (steep) { + read(y, x); + } else { + read(x, y); + } + error = error - deltay; + if (error < 0) { + y = y + ystep; + error = error + deltax; + } + } + + return { + line: line, + min: min, + max: max + }; + }; + + /** + * Converts the result from getBarcodeLine into a binary representation + * also considering the frequency and slope of the signal for more robust results + * @param {Object} result {line, min, max} + */ + Bresenham.toBinaryLine = function (result) { + var min = result.min, + max = result.max, + line = result.line, + slope, + slope2, + center = min + (max - min) / 2, + extrema = [], + currentDir, + dir, + threshold = (max - min) / 12, + rThreshold = -threshold, + i, + j; + + // 1. find extrema + currentDir = line[0] > center ? Slope.DIR.UP : Slope.DIR.DOWN; + extrema.push({ + pos: 0, + val: line[0] + }); + for (i = 0; i < line.length - 2; i++) { + slope = line[i + 1] - line[i]; + slope2 = line[i + 2] - line[i + 1]; + if (slope + slope2 < rThreshold && line[i + 1] < center * 1.5) { + dir = Slope.DIR.DOWN; + } else if (slope + slope2 > threshold && line[i + 1] > center * 0.5) { + dir = Slope.DIR.UP; + } else { + dir = currentDir; + } + + if (currentDir !== dir) { + extrema.push({ + pos: i, + val: line[i] + }); + currentDir = dir; + } + } + extrema.push({ + pos: line.length, + val: line[line.length - 1] + }); + + for (j = extrema[0].pos; j < extrema[1].pos; j++) { + line[j] = line[j] > center ? 0 : 1; + } + + // iterate over extrema and convert to binary based on avg between minmax + for (i = 1; i < extrema.length - 1; i++) { + if (extrema[i + 1].val > extrema[i].val) { + threshold = extrema[i].val + (extrema[i + 1].val - extrema[i].val) / 3 * 2 | 0; + } else { + threshold = extrema[i + 1].val + (extrema[i].val - extrema[i + 1].val) / 3 | 0; + } + + for (j = extrema[i].pos; j < extrema[i + 1].pos; j++) { + line[j] = line[j] > threshold ? 0 : 1; + } + } + + return { + line: line, + threshold: threshold + }; + }; + + /** + * Used for development only + */ + Bresenham.debug = { + printFrequency: function printFrequency(line, canvas) { + var i, + ctx = canvas.getContext("2d"); + canvas.width = line.length; + canvas.height = 256; + + ctx.beginPath(); + ctx.strokeStyle = "blue"; + for (i = 0; i < line.length; i++) { + ctx.moveTo(i, 255); + ctx.lineTo(i, 255 - line[i]); + } + ctx.stroke(); + ctx.closePath(); + }, + + printPattern: function printPattern(line, canvas) { + var ctx = canvas.getContext("2d"), + i; + + canvas.width = line.length; + ctx.fillColor = "black"; + for (i = 0; i < line.length; i++) { + if (line[i] === 1) { + ctx.fillRect(i, 0, 1, 100); + } + } + } + }; + + /* harmony default export */ exports["a"] = Bresenham; + +/***/ }, +/* 85 */ +/***/ function(module, exports, __webpack_require__) { + + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_lodash_omit__ = __webpack_require__(200); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_lodash_omit___default = __WEBPACK_IMPORTED_MODULE_0_lodash_omit__ && __WEBPACK_IMPORTED_MODULE_0_lodash_omit__.__esModule ? function() { return __WEBPACK_IMPORTED_MODULE_0_lodash_omit__['default'] } : function() { return __WEBPACK_IMPORTED_MODULE_0_lodash_omit__; } + /* harmony import */ Object.defineProperty(__WEBPACK_IMPORTED_MODULE_0_lodash_omit___default, 'a', { get: __WEBPACK_IMPORTED_MODULE_0_lodash_omit___default }); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_lodash_pick__ = __webpack_require__(75); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_lodash_pick___default = __WEBPACK_IMPORTED_MODULE_1_lodash_pick__ && __WEBPACK_IMPORTED_MODULE_1_lodash_pick__.__esModule ? function() { return __WEBPACK_IMPORTED_MODULE_1_lodash_pick__['default'] } : function() { return __WEBPACK_IMPORTED_MODULE_1_lodash_pick__; } + /* harmony import */ Object.defineProperty(__WEBPACK_IMPORTED_MODULE_1_lodash_pick___default, 'a', { get: __WEBPACK_IMPORTED_MODULE_1_lodash_pick___default }); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_lodash_merge__ = __webpack_require__(9); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_lodash_merge___default = __WEBPACK_IMPORTED_MODULE_2_lodash_merge__ && __WEBPACK_IMPORTED_MODULE_2_lodash_merge__.__esModule ? function() { return __WEBPACK_IMPORTED_MODULE_2_lodash_merge__['default'] } : function() { return __WEBPACK_IMPORTED_MODULE_2_lodash_merge__; } + /* harmony import */ Object.defineProperty(__WEBPACK_IMPORTED_MODULE_2_lodash_merge___default, 'a', { get: __WEBPACK_IMPORTED_MODULE_2_lodash_merge___default }); + + + + + var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; + + var streamRef; + + function waitForVideo(video) { + return new Promise(function (resolve, reject) { + var attempts = 10; + + function checkVideo() { + if (attempts > 0) { + if (video.videoWidth > 0 && video.videoHeight > 0) { + if (true) { + console.log(video.videoWidth + "px x " + video.videoHeight + "px"); + } + resolve(); + } else { + window.setTimeout(checkVideo, 500); + } + } else { + reject('Unable to play video stream. Is webcam working?'); + } + attempts--; + } + checkVideo(); + }); + } + + /** + * Tries to attach the camera-stream to a given video-element + * and calls the callback function when the content is ready + * @param {Object} constraints + * @param {Object} video + */ + function initCamera(video, constraints) { + return navigator.mediaDevices.getUserMedia(constraints).then(function (stream) { + return new Promise(function (resolve) { + streamRef = stream; + video.setAttribute("autoplay", 'true'); + video.srcObject = stream; + video.addEventListener('loadedmetadata', function () { + video.play(); + resolve(); + }); + }); + }).then(waitForVideo.bind(null, video)); + } + + function deprecatedConstraints(videoConstraints) { + var normalized = /* harmony import */__WEBPACK_IMPORTED_MODULE_1_lodash_pick___default.a.bind()(videoConstraints, ["width", "height", "facingMode", "aspectRatio", "deviceId"]); + + if (typeof videoConstraints.minAspectRatio !== 'undefined' && videoConstraints.minAspectRatio > 0) { + normalized.aspectRatio = videoConstraints.minAspectRatio; + console.log("WARNING: Constraint 'minAspectRatio' is deprecated; Use 'aspectRatio' instead"); + } + if (typeof videoConstraints.facing !== 'undefined') { + normalized.facingMode = videoConstraints.facing; + console.log("WARNING: Constraint 'facing' is deprecated. Use 'facingMode' instead'"); + } + return normalized; + } + + function applyCameraFacing(facing, constraints) { + if (typeof constraints.video.deviceId === 'string' && constraints.video.deviceId.length > 0) { + return Promise.resolve(_extends({}, constraints, { + video: _extends({}, /* harmony import */__WEBPACK_IMPORTED_MODULE_0_lodash_omit___default.a.bind()(constraints.video, "facingMode")) + })); + } else if (!facing) { + return Promise.resolve(constraints); + } + if (typeof MediaStreamTrack !== 'undefined' && typeof MediaStreamTrack.getSources !== 'undefined') { + return new Promise(function (resolve) { + MediaStreamTrack.getSources(function (sourceInfos) { + var videoSource = sourceInfos.filter(function (sourceInfo) { + return sourceInfo.kind === "video" && sourceInfo.facing === facing; + })[0]; + if (videoSource) { + return resolve(/* harmony import */__WEBPACK_IMPORTED_MODULE_2_lodash_merge___default.a.bind()({}, constraints, { video: { deviceId: videoSource.id } })); + } + return resolve(constraints); + }); + }); + } + return Promise.resolve(/* harmony import */__WEBPACK_IMPORTED_MODULE_2_lodash_merge___default.a.bind()({}, constraints, { video: { facingMode: facing } })); + } + + function pickConstraints(videoConstraints) { + var constraints = { + audio: false, + video: deprecatedConstraints(videoConstraints) + }; + return applyCameraFacing(constraints.video.facingMode, constraints); + } + + /* harmony default export */ exports["a"] = { + request: function request(video, videoConstraints) { + return pickConstraints(videoConstraints).then(initCamera.bind(null, video)); + }, + release: function release() { + var tracks = streamRef && streamRef.getVideoTracks(); + if (tracks && tracks.length) { + tracks[0].stop(); + } + streamRef = null; + } + }; + +/***/ }, +/* 86 */ +/***/ function(module, exports, __webpack_require__) { + + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_lodash_isEmpty__ = __webpack_require__(197); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_lodash_isEmpty___default = __WEBPACK_IMPORTED_MODULE_0_lodash_isEmpty__ && __WEBPACK_IMPORTED_MODULE_0_lodash_isEmpty__.__esModule ? function() { return __WEBPACK_IMPORTED_MODULE_0_lodash_isEmpty__['default'] } : function() { return __WEBPACK_IMPORTED_MODULE_0_lodash_isEmpty__; } + /* harmony import */ Object.defineProperty(__WEBPACK_IMPORTED_MODULE_0_lodash_isEmpty___default, 'a', { get: __WEBPACK_IMPORTED_MODULE_0_lodash_isEmpty___default }); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_lodash_omitBy__ = __webpack_require__(201); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_lodash_omitBy___default = __WEBPACK_IMPORTED_MODULE_1_lodash_omitBy__ && __WEBPACK_IMPORTED_MODULE_1_lodash_omitBy__.__esModule ? function() { return __WEBPACK_IMPORTED_MODULE_1_lodash_omitBy__['default'] } : function() { return __WEBPACK_IMPORTED_MODULE_1_lodash_omitBy__; } + /* harmony import */ Object.defineProperty(__WEBPACK_IMPORTED_MODULE_1_lodash_omitBy___default, 'a', { get: __WEBPACK_IMPORTED_MODULE_1_lodash_omitBy___default }); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_lodash_pick__ = __webpack_require__(75); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_lodash_pick___default = __WEBPACK_IMPORTED_MODULE_2_lodash_pick__ && __WEBPACK_IMPORTED_MODULE_2_lodash_pick__.__esModule ? function() { return __WEBPACK_IMPORTED_MODULE_2_lodash_pick__['default'] } : function() { return __WEBPACK_IMPORTED_MODULE_2_lodash_pick__; } + /* harmony import */ Object.defineProperty(__WEBPACK_IMPORTED_MODULE_2_lodash_pick___default, 'a', { get: __WEBPACK_IMPORTED_MODULE_2_lodash_pick___default }); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_lodash_merge__ = __webpack_require__(9); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_lodash_merge___default = __WEBPACK_IMPORTED_MODULE_3_lodash_merge__ && __WEBPACK_IMPORTED_MODULE_3_lodash_merge__.__esModule ? function() { return __WEBPACK_IMPORTED_MODULE_3_lodash_merge__['default'] } : function() { return __WEBPACK_IMPORTED_MODULE_3_lodash_merge__; } + /* harmony import */ Object.defineProperty(__WEBPACK_IMPORTED_MODULE_3_lodash_merge___default, 'a', { get: __WEBPACK_IMPORTED_MODULE_3_lodash_merge___default }); + /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__common_dom_helper__ = __webpack_require__(78); + /* harmony export */ exports["a"] = createConfigFromSource; + + + + + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; }; + + + + var isDataURL = { regex: /^\s*data:([a-z]+\/[a-z0-9\-\+]+(;[a-z\-]+\=[a-z0-9\-]+)?)?(;base64)?,[a-z0-9\!\$\&\'\,\(\)\*\+\,\;\=\-\.\_\~\:\@\/\?\%\s]*\s*$/i }, + // eslint-disable-line max-len + isBlobURL = { regex: /^\s*blob:(.*)$/i }, + isMediaURL = { regex: /^(?:(?:http[s]?|ftp):\/)?\/?(?:(?:[^:\/\s]+)(?:(?:\/\w+)*\/))?([\w\-]+\.([^#?\s]+))(?:.*)?(?:#[\w\-]+)?$/i }, + // eslint-disable-line max-len + isImageExt = { regex: /(jpe?g|png|gif|tiff)(?:\s+|$)/i }, + isVideoExt = { regex: /(webm|ogg|mp4|m4v)/i }; + + function createConfigFromSource(config, sourceConfig, source) { + if (source instanceof /* harmony import */__WEBPACK_IMPORTED_MODULE_4__common_dom_helper__["a"].MediaStream) { + return createConfigForStream(config, sourceConfig, { srcObject: source }); + } else if (source instanceof /* harmony import */__WEBPACK_IMPORTED_MODULE_4__common_dom_helper__["a"].HTMLImageElement) { + throw new Error('Source "HTMLImageElement": not yet supported'); + // return createConfigForImage(config, inputConfig, {image: source}); + } else if (source instanceof /* harmony import */__WEBPACK_IMPORTED_MODULE_4__common_dom_helper__["a"].HTMLVideoElement) { + throw new Error('Source "HTMLVideoElement": not yet supported'); + // return createConfigForVideo(config, inputConfig, {video: source}); + } else if (source instanceof /* harmony import */__WEBPACK_IMPORTED_MODULE_4__common_dom_helper__["a"].HTMLCanvasElement) { + return createConfigForCanvas(config, sourceConfig, { canvas: source }); + } else if (source instanceof /* harmony import */__WEBPACK_IMPORTED_MODULE_4__common_dom_helper__["a"].FileList) { + if (source.length > 0) { + return createConfigForFile(config, sourceConfig, source[0]); + } + } else if (source instanceof /* harmony import */__WEBPACK_IMPORTED_MODULE_4__common_dom_helper__["a"].File) { + return createConfigForFile(config, sourceConfig, source); + } else if (typeof source === 'string') { + return createConfigForString(config, sourceConfig, source); + } else if ((typeof source === 'undefined' ? 'undefined' : _typeof(source)) === 'object' && (typeof source.constraints !== 'undefined' || typeof source.area !== 'undefined')) { + return createConfigForLiveStream(config, source); + } else { + throw new Error("No source given!"); + } + } + + function createConfigForImage(config, source) { + var inputConfig = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2]; + + var staticImageConfig = { + inputStream: /* harmony import */__WEBPACK_IMPORTED_MODULE_3_lodash_merge___default.a.bind()({ + type: "ImageStream", + sequence: false, + size: 800 + }, source), + numOfWorkers: true && config.debug ? 0 : 1 + }; + return /* harmony import */__WEBPACK_IMPORTED_MODULE_3_lodash_merge___default.a.bind()(config, staticImageConfig, { numOfWorkers: typeof config.numOfWorkers === 'number' && config.numOfWorkers > 0 ? 1 : 0 }, { inputStream: /* harmony import */__WEBPACK_IMPORTED_MODULE_1_lodash_omitBy___default.a.bind()(/* harmony import */__WEBPACK_IMPORTED_MODULE_2_lodash_pick___default.a.bind()(config.inputStream, ['size']), /* harmony import */__WEBPACK_IMPORTED_MODULE_0_lodash_isEmpty___default.a) }, { inputStream: inputConfig }); + } + + function createConfigForMimeType(config, inputConfig, _ref) { + var src = _ref.src; + var mime = _ref.mime; + + var _ref2 = mime.match(/^(video|image)\/(.*)$/i) || []; + + var type = _ref2[1]; + + if (type === 'video') { + return createConfigForVideo(config, { src: src }, inputConfig); + } else if (type === 'image') { + return createConfigForImage(config, { src: src }, inputConfig); + } + throw new Error('Source with mimetype: "' + type + '" not supported'); + } + + function createConfigForFile(config, inputConfig, file) { + var src = /* harmony import */__WEBPACK_IMPORTED_MODULE_4__common_dom_helper__["a"].URL.createObjectURL(file); + return createConfigForMimeType(config, inputConfig, { + src: src, + mime: file.type + }); + } + + function createConfigForString(config) { + var inputConfig = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; + var source = arguments[2]; + + var _ref3 = source.match(isDataURL.regex) || []; + + var mime = _ref3[1]; + + if (mime) { + return createConfigForMimeType(config, inputConfig, { src: source, mime: mime }); + } + var blobURL = source.match(isBlobURL.regex); + if (blobURL) { + throw new Error('Source "objectURL": not supported'); + } + + var _ref4 = source.match(isMediaURL.regex) || []; + + var ext = _ref4[2]; + + if (ext) { + return createConfigForMediaExtension(config, inputConfig, { src: source, ext: ext }); + } + throw new Error('Source "' + source + '": not recognized'); + } + + function createConfigForMediaExtension(config, inputConfig, _ref5) { + var src = _ref5.src; + var ext = _ref5.ext; + + if (ext.match(isImageExt.regex)) { + return createConfigForImage(config, { src: src }, inputConfig); + } else if (ext.match(isVideoExt.regex)) { + return createConfigForVideo(config, { src: src }, inputConfig); + } + throw new Error('Source "MediaString": not recognized'); + } + + function createConfigForCanvas(config, _ref6) { + var canvas = _ref6.canvas; + var inputConfig = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2]; + + // TODO: adjust stream & frame-grabber + // once/continous + throw new Error('Source "Canvas": not implemented!'); + } + + function createConfigForVideo(config, source) { + var inputConfig = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2]; + + return /* harmony import */__WEBPACK_IMPORTED_MODULE_3_lodash_merge___default.a.bind()({}, config, { + inputStream: /* harmony import */__WEBPACK_IMPORTED_MODULE_3_lodash_merge___default.a.bind()({ + type: "VideoStream" + }, source) + }, { + inputStream: inputConfig + }); + } + + function createConfigForStream(config, _ref7) { + var srcObject = _ref7.srcObject; + var inputConfig = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2]; + + // TODO: attach to