530 lines
27 KiB
JavaScript
530 lines
27 KiB
JavaScript
/**
|
|
* tracking - A modern approach for Computer Vision on the web.
|
|
* @author Eduardo Lundgren <edu@rdo.io>
|
|
* @version v1.1.2
|
|
* @link http://trackingjs.com
|
|
* @license BSD
|
|
*/
|
|
!function(t, r) {
|
|
t.tracking = t.tracking || {}, tracking.inherits = function(t, r) {
|
|
function n() {
|
|
}
|
|
|
|
n.prototype = r.prototype, t.superClass_ = r.prototype, t.prototype = new n, t.prototype.constructor = t, t.base = function(t, n) {
|
|
var e = Array.prototype.slice.call(arguments, 2)
|
|
return r.prototype[n].apply(t, e)
|
|
}
|
|
}, tracking.initUserMedia_ = function(r, n) {
|
|
t.navigator.getUserMedia({ video: !0, audio: !(!n || !n.audio) }, function(n) {
|
|
try {
|
|
r.src = t.URL.createObjectURL(n)
|
|
} catch (e) {
|
|
r.src = n
|
|
}
|
|
}, function() {
|
|
throw Error('Cannot capture user camera.')
|
|
})
|
|
}, tracking.isNode = function(t) {
|
|
return t.nodeType || this.isWindow(t)
|
|
}, tracking.isWindow = function(t) {
|
|
return !!(t && t.alert && t.document)
|
|
}, tracking.one = function(t, r) {
|
|
return this.isNode(t) ? t : (r || document).querySelector(t)
|
|
}, tracking.track = function(t, r, n) {
|
|
if (t = tracking.one(t), !t) throw new Error('Element not found, try a different element or selector.')
|
|
if (!r) throw new Error('Tracker not specified, try `tracking.track(element, new tracking.FaceTracker())`.')
|
|
switch (t.nodeName.toLowerCase()) {
|
|
case'canvas':
|
|
return this.trackCanvas_(t, r, n)
|
|
case'img':
|
|
return this.trackImg_(t, r, n)
|
|
case'video':
|
|
return n && n.camera && this.initUserMedia_(t, n), this.trackVideo_(t, r, n)
|
|
default:
|
|
throw new Error('Element not supported, try in a canvas, img, or video.')
|
|
}
|
|
}, tracking.trackCanvas_ = function(t, r) {
|
|
var n = this, e = new tracking.TrackerTask(r)
|
|
return e.on('run', function() {
|
|
n.trackCanvasInternal_(t, r)
|
|
}), e.run()
|
|
}, tracking.trackCanvasInternal_ = function(t, r) {
|
|
var n = t.width, e = t.height, i = t.getContext('2d'), a = i.getImageData(0, 0, n, e)
|
|
r.track(a.data, n, e)
|
|
}, tracking.trackImg_ = function(t, r) {
|
|
var n = t.width, e = t.height, i = document.createElement('canvas')
|
|
i.width = n, i.height = e
|
|
var a = new tracking.TrackerTask(r)
|
|
return a.on('run', function() {
|
|
tracking.Canvas.loadImage(i, t.src, 0, 0, n, e, function() {
|
|
tracking.trackCanvasInternal_(i, r)
|
|
})
|
|
}), a.run()
|
|
}, tracking.trackVideo_ = function(r, n) {
|
|
var e, i, a = document.createElement('canvas'), o = a.getContext('2d'), c = function() {
|
|
e = r.offsetWidth, i = r.offsetHeight, a.width = e, a.height = i
|
|
}
|
|
c(), r.addEventListener('resize', c)
|
|
var s, g = function() {
|
|
s = t.requestAnimationFrame(function() {
|
|
if (r.readyState === r.HAVE_ENOUGH_DATA) {
|
|
try {
|
|
o.drawImage(r, 0, 0, e, i)
|
|
} catch (t) {
|
|
}
|
|
tracking.trackCanvasInternal_(a, n)
|
|
}
|
|
g()
|
|
})
|
|
}, h = new tracking.TrackerTask(n)
|
|
return h.on('stop', function() {
|
|
t.cancelAnimationFrame(s)
|
|
}), h.on('run', function() {
|
|
g()
|
|
}), h.run()
|
|
}, t.URL || (t.URL = t.URL || t.webkitURL || t.msURL || t.oURL), navigator.getUserMedia || (navigator.getUserMedia = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia || navigator.msGetUserMedia)
|
|
}(window), function() {
|
|
tracking.EventEmitter = function() {
|
|
}, tracking.EventEmitter.prototype.events_ = null, tracking.EventEmitter.prototype.addListener = function(t, r) {
|
|
if ('function' != typeof r) throw new TypeError('Listener must be a function')
|
|
return this.events_ || (this.events_ = {}), this.emit('newListener', t, r), this.events_[t] || (this.events_[t] = []), this.events_[t].push(r), this
|
|
}, tracking.EventEmitter.prototype.listeners = function(t) {
|
|
return this.events_ && this.events_[t]
|
|
}, tracking.EventEmitter.prototype.emit = function(t) {
|
|
var r = this.listeners(t)
|
|
if (r) {
|
|
for (var n = Array.prototype.slice.call(arguments, 1), e = 0; e < r.length; e++) r[e] && r[e].apply(this, n)
|
|
return !0
|
|
}
|
|
return !1
|
|
}, tracking.EventEmitter.prototype.on = tracking.EventEmitter.prototype.addListener, tracking.EventEmitter.prototype.once = function(t, r) {
|
|
var n = this
|
|
n.on(t, function e() {
|
|
n.removeListener(t, e), r.apply(this, arguments)
|
|
})
|
|
}, tracking.EventEmitter.prototype.removeAllListeners = function(t) {
|
|
return this.events_ ? (t ? delete this.events_[t] : delete this.events_, this) : this
|
|
}, tracking.EventEmitter.prototype.removeListener = function(t, r) {
|
|
if ('function' != typeof r) throw new TypeError('Listener must be a function')
|
|
if (!this.events_) return this
|
|
var n = this.listeners(t)
|
|
if (Array.isArray(n)) {
|
|
var e = n.indexOf(r)
|
|
if (0 > e) return this
|
|
n.splice(e, 1)
|
|
}
|
|
return this
|
|
}, tracking.EventEmitter.prototype.setMaxListeners = function() {
|
|
throw new Error('Not implemented')
|
|
}
|
|
}(), function() {
|
|
tracking.Canvas = {}, tracking.Canvas.loadImage = function(t, r, n, e, i, a, o) {
|
|
var c = this, s = new window.Image
|
|
s.crossOrigin = '*', s.onload = function() {
|
|
var r = t.getContext('2d')
|
|
t.width = i, t.height = a, r.drawImage(s, n, e, i, a), o && o.call(c), s = null
|
|
}, s.src = r
|
|
}
|
|
}(), function() {
|
|
tracking.DisjointSet = function(t) {
|
|
if (void 0 === t) throw new Error('DisjointSet length not specified.')
|
|
this.length = t, this.parent = new Uint32Array(t)
|
|
for (var r = 0; t > r; r++) this.parent[r] = r
|
|
}, tracking.DisjointSet.prototype.length = null, tracking.DisjointSet.prototype.parent = null, tracking.DisjointSet.prototype.find = function(t) {
|
|
return this.parent[t] === t ? t : this.parent[t] = this.find(this.parent[t])
|
|
}, tracking.DisjointSet.prototype.union = function(t, r) {
|
|
var n = this.find(t), e = this.find(r)
|
|
this.parent[n] = e
|
|
}
|
|
}(), function() {
|
|
tracking.Image = {}, tracking.Image.blur = function(t, r, n, e) {
|
|
if (e = Math.abs(e), 1 >= e) throw new Error('Diameter should be greater than 1.')
|
|
for (var i = e / 2, a = Math.ceil(e) + (1 - Math.ceil(e) % 2), o = new Float32Array(a), c = (i + .5) / 3, s = c * c, g = 1 / Math.sqrt(2 * Math.PI * s), h = -1 / (2 * c * c), k = 0, u = Math.floor(a / 2), f = 0; a > f; f++) {
|
|
var l = f - u, p = g * Math.exp(l * l * h)
|
|
o[f] = p, k += p
|
|
}
|
|
for (var v = 0; v < o.length; v++) o[v] /= k
|
|
return this.separableConvolve(t, r, n, o, o, !1)
|
|
}, tracking.Image.computeIntegralImage = function(t, r, n, e, i, a, o) {
|
|
if (arguments.length < 4) throw new Error('You should specify at least one output array in the order: sum, square, tilted, sobel.')
|
|
var c
|
|
o && (c = tracking.Image.sobel(t, r, n))
|
|
for (var s = 0; n > s; s++) {
|
|
for (var g = 0; r > g; g++) {
|
|
var h = s * r * 4 + 4 * g, k = ~~(.299 * t[h] + .587 * t[h + 1] + .114 * t[h + 2])
|
|
if (e && this.computePixelValueSAT_(e, r, s, g, k), i && this.computePixelValueSAT_(i, r, s, g, k * k), a) {
|
|
var u = h - 4 * r, f = ~~(.299 * t[u] + .587 * t[u + 1] + .114 * t[u + 2])
|
|
this.computePixelValueRSAT_(a, r, s, g, k, f || 0)
|
|
}
|
|
o && this.computePixelValueSAT_(o, r, s, g, c[h])
|
|
}
|
|
}
|
|
}, tracking.Image.computePixelValueRSAT_ = function(t, r, n, e, i, a) {
|
|
var o = n * r + e
|
|
t[o] = (t[o - r - 1] || 0) + (t[o - r + 1] || 0) - (t[o - r - r] || 0) + i + a
|
|
}, tracking.Image.computePixelValueSAT_ = function(t, r, n, e, i) {
|
|
var a = n * r + e
|
|
t[a] = (t[a - r] || 0) + (t[a - 1] || 0) + i - (t[a - r - 1] || 0)
|
|
}, tracking.Image.grayscale = function(t, r, n, e) {
|
|
for (var i = new Uint8ClampedArray(e ? t.length : t.length >> 2), a = 0, o = 0, c = 0; n > c; c++) {
|
|
for (var s = 0; r > s; s++) {
|
|
var g = .299 * t[o] + .587 * t[o + 1] + .114 * t[o + 2]
|
|
i[a++] = g, e && (i[a++] = g, i[a++] = g, i[a++] = t[o + 3]), o += 4
|
|
}
|
|
}
|
|
return i
|
|
}, tracking.Image.horizontalConvolve = function(t, r, n, e, i) {
|
|
for (var a = e.length, o = Math.floor(a / 2), c = new Float32Array(r * n * 4), s = i ? 1 : 0, g = 0; n > g; g++) {
|
|
for (var h = 0; r > h; h++) {
|
|
for (var k = g, u = h, f = 4 * (g * r + h), l = 0, p = 0, v = 0, m = 0, y = 0; a > y; y++) {
|
|
var d = k, w = Math.min(r - 1, Math.max(0, u + y - o)), T = 4 * (d * r + w), C = e[y]
|
|
l += t[T] * C, p += t[T + 1] * C, v += t[T + 2] * C, m += t[T + 3] * C
|
|
}
|
|
c[f] = l, c[f + 1] = p, c[f + 2] = v, c[f + 3] = m + s * (255 - m)
|
|
}
|
|
}
|
|
return c
|
|
}, tracking.Image.verticalConvolve = function(t, r, n, e, i) {
|
|
for (var a = e.length, o = Math.floor(a / 2), c = new Float32Array(r * n * 4), s = i ? 1 : 0, g = 0; n > g; g++) {
|
|
for (var h = 0; r > h; h++) {
|
|
for (var k = g, u = h, f = 4 * (g * r + h), l = 0, p = 0, v = 0, m = 0, y = 0; a > y; y++) {
|
|
var d = Math.min(n - 1, Math.max(0, k + y - o)), w = u, T = 4 * (d * r + w), C = e[y]
|
|
l += t[T] * C, p += t[T + 1] * C, v += t[T + 2] * C, m += t[T + 3] * C
|
|
}
|
|
c[f] = l, c[f + 1] = p, c[f + 2] = v, c[f + 3] = m + s * (255 - m)
|
|
}
|
|
}
|
|
return c
|
|
}, tracking.Image.separableConvolve = function(t, r, n, e, i, a) {
|
|
var o = this.verticalConvolve(t, r, n, i, a)
|
|
return this.horizontalConvolve(o, r, n, e, a)
|
|
}, tracking.Image.sobel = function(t, r, n) {
|
|
t = this.grayscale(t, r, n, !0)
|
|
for (var e = new Float32Array(r * n * 4), i = new Float32Array([-1, 0, 1]), a = new Float32Array([1, 2, 1]), o = this.separableConvolve(t, r, n, i, a), c = this.separableConvolve(t, r, n, a, i), s = 0; s < e.length; s += 4) {
|
|
var g = o[s], h = c[s], k = Math.sqrt(h * h + g * g)
|
|
e[s] = k, e[s + 1] = k, e[s + 2] = k, e[s + 3] = 255
|
|
}
|
|
return e
|
|
}
|
|
}(), function() {
|
|
tracking.ViolaJones = {}, tracking.ViolaJones.REGIONS_OVERLAP = .5, tracking.ViolaJones.classifiers = {}, tracking.ViolaJones.detect = function(t, r, n, e, i, a, o, c) {
|
|
var s, g = 0, h = [], k = new Int32Array(r * n), u = new Int32Array(r * n), f = new Int32Array(r * n)
|
|
o > 0 && (s = new Int32Array(r * n)), tracking.Image.computeIntegralImage(t, r, n, k, u, f, s)
|
|
for (var l = c[0], p = c[1], v = e * i, m = v * l | 0, y = v * p | 0; r > m && n > y;) {
|
|
for (var d = v * a + .5 | 0, w = 0; n - y > w; w += d) {
|
|
for (var T = 0; r - m > T; T += d) {
|
|
o > 0 && this.isTriviallyExcluded(o, s, w, T, r, m, y) || this.evalStages_(c, k, u, f, w, T, r, m, y, v) && (h[g++] = {
|
|
width: m,
|
|
height: y,
|
|
x: T,
|
|
y: w
|
|
})
|
|
}
|
|
}
|
|
v *= i, m = v * l | 0, y = v * p | 0
|
|
}
|
|
return this.mergeRectangles_(h)
|
|
}, tracking.ViolaJones.isTriviallyExcluded = function(t, r, n, e, i, a, o) {
|
|
var c = n * i + e, s = c + a, g = c + o * i, h = g + a, k = (r[c] - r[s] - r[g] + r[h]) / (a * o * 255)
|
|
return t > k ? !0 : !1
|
|
}, tracking.ViolaJones.evalStages_ = function(t, r, n, e, i, a, o, c, s, g) {
|
|
var h = 1 / (c * s), k = i * o + a, u = k + c, f = k + s * o, l = f + c, p = (r[k] - r[u] - r[f] + r[l]) * h,
|
|
v = (n[k] - n[u] - n[f] + n[l]) * h - p * p, m = 1
|
|
v > 0 && (m = Math.sqrt(v))
|
|
for (var y = t.length, d = 2; y > d;) {
|
|
for (var w = 0, T = t[d++], C = t[d++]; C--;) {
|
|
for (var _ = 0, E = t[d++], M = t[d++], x = 0; M > x; x++) {
|
|
var I, b, O, A, S = a + t[d++] * g + .5 | 0, D = i + t[d++] * g + .5 | 0, R = t[d++] * g + .5 | 0,
|
|
j = t[d++] * g + .5 | 0, F = t[d++]
|
|
E ? (I = S - j + R + (D + R + j - 1) * o, b = S + (D - 1) * o, O = S - j + (D + j - 1) * o, A = S + R + (D + R - 1) * o, _ += (e[I] + e[b] - e[O] - e[A]) * F) : (I = D * o + S, b = I + R, O = I + j * o, A = O + R, _ += (r[I] - r[b] - r[O] + r[A]) * F)
|
|
}
|
|
var L = t[d++], V = t[d++], U = t[d++]
|
|
w += L * m > _ * h ? V : U
|
|
}
|
|
if (T > w) return !1
|
|
}
|
|
return !0
|
|
}, tracking.ViolaJones.mergeRectangles_ = function(t) {
|
|
for (var r = new tracking.DisjointSet(t.length), n = 0; n < t.length; n++) {
|
|
for (var e = t[n], i = 0; i < t.length; i++) {
|
|
var a = t[i]
|
|
if (tracking.Math.intersectRect(e.x, e.y, e.x + e.width, e.y + e.height, a.x, a.y, a.x + a.width, a.y + a.height)) {
|
|
var o = Math.max(e.x, a.x), c = Math.max(e.y, a.y), s = Math.min(e.x + e.width, a.x + a.width),
|
|
g = Math.min(e.y + e.height, a.y + a.height), h = (o - s) * (c - g), k = e.width * e.height,
|
|
u = a.width * a.height
|
|
h / (k * (k / u)) >= this.REGIONS_OVERLAP && h / (u * (k / u)) >= this.REGIONS_OVERLAP && r.union(n, i)
|
|
}
|
|
}
|
|
}
|
|
for (var f = {}, l = 0; l < r.length; l++) {
|
|
var p = r.find(l)
|
|
f[p] ? (f[p].total++, f[p].width += t[l].width, f[p].height += t[l].height, f[p].x += t[l].x, f[p].y += t[l].y) : f[p] = {
|
|
total: 1,
|
|
width: t[l].width,
|
|
height: t[l].height,
|
|
x: t[l].x,
|
|
y: t[l].y
|
|
}
|
|
}
|
|
var v = []
|
|
return Object.keys(f).forEach(function(t) {
|
|
var r = f[t]
|
|
v.push({
|
|
total: r.total,
|
|
width: r.width / r.total + .5 | 0,
|
|
height: r.height / r.total + .5 | 0,
|
|
x: r.x / r.total + .5 | 0,
|
|
y: r.y / r.total + .5 | 0
|
|
})
|
|
}), v
|
|
}
|
|
}(), function() {
|
|
tracking.Brief = {}, tracking.Brief.N = 512, tracking.Brief.randomImageOffsets_ = {}, tracking.Brief.randomWindowOffsets_ = null, tracking.Brief.getDescriptors = function(t, r, n) {
|
|
for (var e = new Int32Array((n.length >> 1) * (this.N >> 5)), i = 0, a = this.getRandomOffsets_(r), o = 0, c = 0; c < n.length; c += 2) for (var s = r * n[c + 1] + n[c], g = 0, h = 0, k = this.N; k > h; h++) t[a[g++] + s] < t[a[g++] + s] && (i |= 1 << (31 & h)), h + 1 & 31 || (e[o++] = i, i = 0)
|
|
return e
|
|
}, tracking.Brief.match = function(t, r, n, e) {
|
|
for (var i = t.length >> 1, a = n.length >> 1, o = new Array(i), c = 0; i > c; c++) {
|
|
for (var s = 1 / 0, g = 0, h = 0; a > h; h++) {
|
|
for (var k = 0, u = 0, f = this.N >> 5; f > u; u++) k += tracking.Math.hammingWeight(r[c * f + u] ^ e[h * f + u])
|
|
s > k && (s = k, g = h)
|
|
}
|
|
o[c] = {
|
|
index1: c,
|
|
index2: g,
|
|
keypoint1: [t[2 * c], t[2 * c + 1]],
|
|
keypoint2: [n[2 * g], n[2 * g + 1]],
|
|
confidence: 1 - s / this.N
|
|
}
|
|
}
|
|
return o
|
|
}, tracking.Brief.reciprocalMatch = function(t, r, n, e) {
|
|
var i = []
|
|
if (0 === t.length || 0 === n.length) return i
|
|
for (var a = tracking.Brief.match(t, r, n, e), o = tracking.Brief.match(n, e, t, r), c = 0; c < a.length; c++) o[a[c].index2].index2 === c && i.push(a[c])
|
|
return i
|
|
}, tracking.Brief.getRandomOffsets_ = function(t) {
|
|
if (!this.randomWindowOffsets_) {
|
|
for (var r = 0, n = new Int32Array(4 * this.N), e = 0; e < this.N; e++) n[r++] = Math.round(tracking.Math.uniformRandom(-15, 16)), n[r++] = Math.round(tracking.Math.uniformRandom(-15, 16)), n[r++] = Math.round(tracking.Math.uniformRandom(-15, 16)), n[r++] = Math.round(tracking.Math.uniformRandom(-15, 16))
|
|
this.randomWindowOffsets_ = n
|
|
}
|
|
if (!this.randomImageOffsets_[t]) {
|
|
for (var i = 0, a = new Int32Array(2 * this.N), o = 0; o < this.N; o++) a[i++] = this.randomWindowOffsets_[4 * o] * t + this.randomWindowOffsets_[4 * o + 1], a[i++] = this.randomWindowOffsets_[4 * o + 2] * t + this.randomWindowOffsets_[4 * o + 3]
|
|
this.randomImageOffsets_[t] = a
|
|
}
|
|
return this.randomImageOffsets_[t]
|
|
}
|
|
}(), function() {
|
|
tracking.Fast = {}, tracking.Fast.THRESHOLD = 40, tracking.Fast.circles_ = {}, tracking.Fast.findCorners = function(t, r, n, e) {
|
|
var i = this.getCircleOffsets_(r), a = new Int32Array(16), o = []
|
|
void 0 === e && (e = this.THRESHOLD)
|
|
for (var c = 3; n - 3 > c; c++) {
|
|
for (var s = 3; r - 3 > s; s++) {
|
|
for (var g = c * r + s, h = t[g], k = 0; 16 > k; k++) a[k] = t[g + i[k]]
|
|
this.isCorner(h, a, e) && (o.push(s, c), s += 3)
|
|
}
|
|
}
|
|
return o
|
|
}, tracking.Fast.isBrighter = function(t, r, n) {
|
|
return t - r > n
|
|
}, tracking.Fast.isCorner = function(t, r, n) {
|
|
if (this.isTriviallyExcluded(r, t, n)) return !1
|
|
for (var e = 0; 16 > e; e++) {
|
|
for (var i = !0, a = !0, o = 0; 9 > o; o++) {
|
|
var c = r[e + o & 15]
|
|
if (!this.isBrighter(t, c, n) && (a = !1, i === !1)) break
|
|
if (!this.isDarker(t, c, n) && (i = !1, a === !1)) break
|
|
}
|
|
if (a || i) return !0
|
|
}
|
|
return !1
|
|
}, tracking.Fast.isDarker = function(t, r, n) {
|
|
return r - t > n
|
|
}, tracking.Fast.isTriviallyExcluded = function(t, r, n) {
|
|
var e = 0, i = t[8], a = t[12], o = t[4], c = t[0]
|
|
return this.isBrighter(c, r, n) && e++, this.isBrighter(o, r, n) && e++, this.isBrighter(i, r, n) && e++, this.isBrighter(a, r, n) && e++, 3 > e && (e = 0, this.isDarker(c, r, n) && e++, this.isDarker(o, r, n) && e++, this.isDarker(i, r, n) && e++, this.isDarker(a, r, n) && e++, 3 > e) ? !0 : !1
|
|
}, tracking.Fast.getCircleOffsets_ = function(t) {
|
|
if (this.circles_[t]) return this.circles_[t]
|
|
var r = new Int32Array(16)
|
|
return r[0] = -t - t - t, r[1] = r[0] + 1, r[2] = r[1] + t + 1, r[3] = r[2] + t + 1, r[4] = r[3] + t, r[5] = r[4] + t, r[6] = r[5] + t - 1, r[7] = r[6] + t - 1, r[8] = r[7] - 1, r[9] = r[8] - 1, r[10] = r[9] - t - 1, r[11] = r[10] - t - 1, r[12] = r[11] - t, r[13] = r[12] - t, r[14] = r[13] - t + 1, r[15] = r[14] - t + 1, this.circles_[t] = r, r
|
|
}
|
|
}(), function() {
|
|
tracking.Math = {}, tracking.Math.distance = function(t, r, n, e) {
|
|
var i = n - t, a = e - r
|
|
return Math.sqrt(i * i + a * a)
|
|
}, tracking.Math.hammingWeight = function(t) {
|
|
return t -= t >> 1 & 1431655765, t = (858993459 & t) + (t >> 2 & 858993459), 16843009 * (t + (t >> 4) & 252645135) >> 24
|
|
}, tracking.Math.uniformRandom = function(t, r) {
|
|
return t + Math.random() * (r - t)
|
|
}, tracking.Math.intersectRect = function(t, r, n, e, i, a, o, c) {
|
|
return !(i > n || t > o || a > e || r > c)
|
|
}
|
|
}(), function() {
|
|
tracking.Matrix = {}, tracking.Matrix.forEach = function(t, r, n, e, i) {
|
|
i = i || 1
|
|
for (var a = 0; n > a; a += i) {
|
|
for (var o = 0; r > o; o += i) {
|
|
var c = a * r * 4 + 4 * o
|
|
e.call(this, t[c], t[c + 1], t[c + 2], t[c + 3], c, a, o)
|
|
}
|
|
}
|
|
}
|
|
}(), function() {
|
|
tracking.EPnP = {}, tracking.EPnP.solve = function(t, r, n) {
|
|
}
|
|
}(), function() {
|
|
tracking.Tracker = function() {
|
|
tracking.Tracker.base(this, 'constructor')
|
|
}, tracking.inherits(tracking.Tracker, tracking.EventEmitter), tracking.Tracker.prototype.track = function() {
|
|
}
|
|
}(), function() {
|
|
tracking.TrackerTask = function(t) {
|
|
if (tracking.TrackerTask.base(this, 'constructor'), !t) throw new Error('Tracker instance not specified.')
|
|
this.setTracker(t)
|
|
}, tracking.inherits(tracking.TrackerTask, tracking.EventEmitter), tracking.TrackerTask.prototype.tracker_ = null, tracking.TrackerTask.prototype.running_ = !1, tracking.TrackerTask.prototype.getTracker = function() {
|
|
return this.tracker_
|
|
}, tracking.TrackerTask.prototype.inRunning = function() {
|
|
return this.running_
|
|
}, tracking.TrackerTask.prototype.setRunning = function(t) {
|
|
this.running_ = t
|
|
}, tracking.TrackerTask.prototype.setTracker = function(t) {
|
|
this.tracker_ = t
|
|
}, tracking.TrackerTask.prototype.run = function() {
|
|
var t = this
|
|
if (!this.inRunning()) {
|
|
return this.setRunning(!0), this.reemitTrackEvent_ = function(r) {
|
|
t.emit('track', r)
|
|
}, this.tracker_.on('track', this.reemitTrackEvent_), this.emit('run'), this
|
|
}
|
|
}, tracking.TrackerTask.prototype.stop = function() {
|
|
return this.inRunning() ? (this.setRunning(!1), this.emit('stop'), this.tracker_.removeListener('track', this.reemitTrackEvent_), this) : void 0
|
|
}
|
|
}(), function() {
|
|
tracking.ColorTracker = function(t) {
|
|
tracking.ColorTracker.base(this, 'constructor'), 'string' == typeof t && (t = [t]), t && (t.forEach(function(t) {
|
|
if (!tracking.ColorTracker.getColor(t)) throw new Error('Color not valid, try `new tracking.ColorTracker("magenta")`.')
|
|
}), this.setColors(t))
|
|
}, tracking.inherits(tracking.ColorTracker, tracking.Tracker), tracking.ColorTracker.knownColors_ = {}, tracking.ColorTracker.neighbours_ = {}, tracking.ColorTracker.registerColor = function(t, r) {
|
|
tracking.ColorTracker.knownColors_[t] = r
|
|
}, tracking.ColorTracker.getColor = function(t) {
|
|
return tracking.ColorTracker.knownColors_[t]
|
|
}, tracking.ColorTracker.prototype.colors = ['magenta'], tracking.ColorTracker.prototype.minDimension = 20, tracking.ColorTracker.prototype.maxDimension = 1 / 0, tracking.ColorTracker.prototype.minGroupSize = 30, tracking.ColorTracker.prototype.calculateDimensions_ = function(t, r) {
|
|
for (var n = -1, e = -1, i = 1 / 0, a = 1 / 0, o = 0; r > o; o += 2) {
|
|
var c = t[o], s = t[o + 1]
|
|
i > c && (i = c), c > n && (n = c), a > s && (a = s), s > e && (e = s)
|
|
}
|
|
return { width: n - i, height: e - a, x: i, y: a }
|
|
}, tracking.ColorTracker.prototype.getColors = function() {
|
|
return this.colors
|
|
}, tracking.ColorTracker.prototype.getMinDimension = function() {
|
|
return this.minDimension
|
|
}, tracking.ColorTracker.prototype.getMaxDimension = function() {
|
|
return this.maxDimension
|
|
}, tracking.ColorTracker.prototype.getMinGroupSize = function() {
|
|
return this.minGroupSize
|
|
}, tracking.ColorTracker.prototype.getNeighboursForWidth_ = function(t) {
|
|
if (tracking.ColorTracker.neighbours_[t]) return tracking.ColorTracker.neighbours_[t]
|
|
var r = new Int32Array(8)
|
|
return r[0] = 4 * -t, r[1] = 4 * -t + 4, r[2] = 4, r[3] = 4 * t + 4, r[4] = 4 * t, r[5] = 4 * t - 4, r[6] = -4, r[7] = 4 * -t - 4, tracking.ColorTracker.neighbours_[t] = r, r
|
|
}, tracking.ColorTracker.prototype.mergeRectangles_ = function(t) {
|
|
for (var r, n = [], e = this.getMinDimension(), i = this.getMaxDimension(), a = 0; a < t.length; a++) {
|
|
var o = t[a]
|
|
r = !0
|
|
for (var c = a + 1; c < t.length; c++) {
|
|
var s = t[c]
|
|
if (tracking.Math.intersectRect(o.x, o.y, o.x + o.width, o.y + o.height, s.x, s.y, s.x + s.width, s.y + s.height)) {
|
|
r = !1
|
|
var g = Math.min(o.x, s.x), h = Math.min(o.y, s.y), k = Math.max(o.x + o.width, s.x + s.width),
|
|
u = Math.max(o.y + o.height, s.y + s.height)
|
|
s.height = u - h, s.width = k - g, s.x = g, s.y = h
|
|
break
|
|
}
|
|
}
|
|
r && o.width >= e && o.height >= e && o.width <= i && o.height <= i && n.push(o)
|
|
}
|
|
return n
|
|
}, tracking.ColorTracker.prototype.setColors = function(t) {
|
|
this.colors = t
|
|
}, tracking.ColorTracker.prototype.setMinDimension = function(t) {
|
|
this.minDimension = t
|
|
}, tracking.ColorTracker.prototype.setMaxDimension = function(t) {
|
|
this.maxDimension = t
|
|
}, tracking.ColorTracker.prototype.setMinGroupSize = function(t) {
|
|
this.minGroupSize = t
|
|
}, tracking.ColorTracker.prototype.track = function(t, r, n) {
|
|
var e = this, i = this.getColors()
|
|
if (!i) throw new Error('Colors not specified, try `new tracking.ColorTracker("magenta")`.')
|
|
var a = []
|
|
i.forEach(function(i) {
|
|
a = a.concat(e.trackColor_(t, r, n, i))
|
|
}), this.emit('track', { data: a })
|
|
}, tracking.ColorTracker.prototype.trackColor_ = function(n, e, i, a) {
|
|
var o, c, s, g, h, k = tracking.ColorTracker.knownColors_[a], u = new Int32Array(n.length >> 2),
|
|
f = new Int8Array(n.length), l = this.getMinGroupSize(), p = this.getNeighboursForWidth_(e),
|
|
v = new Int32Array(n.length), m = [], y = -4
|
|
if (!k) return m
|
|
for (var d = 0; i > d; d++) {
|
|
for (var w = 0; e > w; w++) {
|
|
if (y += 4, !f[y]) {
|
|
for (o = 0, h = -1, v[++h] = y, v[++h] = d, v[++h] = w, f[y] = 1; h >= 0;) {
|
|
if (s = v[h--], c = v[h--], g = v[h--], k(n[g], n[g + 1], n[g + 2], n[g + 3], g, c, s)) {
|
|
u[o++] = s, u[o++] = c
|
|
for (var T = 0; T < p.length; T++) {
|
|
var C = g + p[T], _ = c + t[T], E = s + r[T]
|
|
!f[C] && _ >= 0 && i > _ && E >= 0 && e > E && (v[++h] = C, v[++h] = _, v[++h] = E, f[C] = 1)
|
|
}
|
|
}
|
|
}
|
|
if (o >= l) {
|
|
var M = this.calculateDimensions_(u, o)
|
|
M && (M.color = a, m.push(M))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return this.mergeRectangles_(m)
|
|
}, tracking.ColorTracker.registerColor('cyan', function(t, r, n) {
|
|
var e = 50, i = 70, a = t - 0, o = r - 255, c = n - 255
|
|
return r - t >= e && n - t >= i ? !0 : 6400 > a * a + o * o + c * c
|
|
}), tracking.ColorTracker.registerColor('magenta', function(t, r, n) {
|
|
var e = 50, i = t - 255, a = r - 0, o = n - 255
|
|
return t - r >= e && n - r >= e ? !0 : 19600 > i * i + a * a + o * o
|
|
}), tracking.ColorTracker.registerColor('yellow', function(t, r, n) {
|
|
var e = 50, i = t - 255, a = r - 255, o = n - 0
|
|
return t - n >= e && r - n >= e ? !0 : 1e4 > i * i + a * a + o * o
|
|
})
|
|
var t = new Int32Array([-1, -1, 0, 1, 1, 1, 0, -1]), r = new Int32Array([0, 1, 1, 1, 0, -1, -1, -1])
|
|
}(), function() {
|
|
tracking.ObjectTracker = function(t) {
|
|
tracking.ObjectTracker.base(this, 'constructor'), t && (Array.isArray(t) || (t = [t]), Array.isArray(t) && t.forEach(function(r, n) {
|
|
if ('string' == typeof r && (t[n] = tracking.ViolaJones.classifiers[r]), !t[n]) throw new Error('Object classifier not valid, try `new tracking.ObjectTracker("face")`.')
|
|
})), this.setClassifiers(t)
|
|
}, tracking.inherits(tracking.ObjectTracker, tracking.Tracker), tracking.ObjectTracker.prototype.edgesDensity = .2, tracking.ObjectTracker.prototype.initialScale = 1, tracking.ObjectTracker.prototype.scaleFactor = 1.25, tracking.ObjectTracker.prototype.stepSize = 1.5, tracking.ObjectTracker.prototype.getClassifiers = function() {
|
|
return this.classifiers
|
|
}, tracking.ObjectTracker.prototype.getEdgesDensity = function() {
|
|
return this.edgesDensity
|
|
}, tracking.ObjectTracker.prototype.getInitialScale = function() {
|
|
return this.initialScale
|
|
}, tracking.ObjectTracker.prototype.getScaleFactor = function() {
|
|
return this.scaleFactor
|
|
}, tracking.ObjectTracker.prototype.getStepSize = function() {
|
|
return this.stepSize
|
|
}, tracking.ObjectTracker.prototype.track = function(t, r, n) {
|
|
var e = this, i = this.getClassifiers()
|
|
if (!i) throw new Error('Object classifier not specified, try `new tracking.ObjectTracker("face")`.')
|
|
var a = []
|
|
i.forEach(function(i) {
|
|
a = a.concat(tracking.ViolaJones.detect(t, r, n, e.getInitialScale(), e.getScaleFactor(), e.getStepSize(), e.getEdgesDensity(), i))
|
|
}), this.emit('track', { data: a })
|
|
}, tracking.ObjectTracker.prototype.setClassifiers = function(t) {
|
|
this.classifiers = t
|
|
}, tracking.ObjectTracker.prototype.setEdgesDensity = function(t) {
|
|
this.edgesDensity = t
|
|
}, tracking.ObjectTracker.prototype.setInitialScale = function(t) {
|
|
this.initialScale = t
|
|
}, tracking.ObjectTracker.prototype.setScaleFactor = function(t) {
|
|
this.scaleFactor = t
|
|
}, tracking.ObjectTracker.prototype.setStepSize = function(t) {
|
|
this.stepSize = t
|
|
}
|
|
}();
|