| if (parallable === undefined) { |
| var parallable = function (file, funct) { |
| parallable.core[funct.toString()] = funct().core; |
| return function () { |
| var i; |
| var async, worker_num, params; |
| if (arguments.length > 1) { |
| async = arguments[arguments.length - 2]; |
| worker_num = arguments[arguments.length - 1]; |
| params = new Array(arguments.length - 2); |
| for (i = 0; i < arguments.length - 2; i++) |
| params[i] = arguments[i]; |
| } else { |
| async = arguments[0].async; |
| worker_num = arguments[0].worker; |
| params = arguments[0]; |
| delete params["async"]; |
| delete params["worker"]; |
| params = [params]; |
| } |
| var scope = { "shared" : {} }; |
| var ctrl = funct.apply(scope, params); |
| if (async) { |
| return function (complete, error) { |
| var executed = 0; |
| var outputs = new Array(worker_num); |
| var inputs = ctrl.pre.apply(scope, [worker_num]); |
| /* sanitize scope shared because for Chrome/WebKit, worker only support JSONable data */ |
| for (i in scope.shared) |
| /* delete function, if any */ |
| if (typeof scope.shared[i] == "function") |
| delete scope.shared[i]; |
| /* delete DOM object, if any */ |
| else if (scope.shared[i].tagName !== undefined) |
| delete scope.shared[i]; |
| for (i = 0; i < worker_num; i++) { |
| var worker = new Worker(file); |
| worker.onmessage = (function (i) { |
| return function (event) { |
| outputs[i] = (typeof event.data == "string") ? JSON.parse(event.data) : event.data; |
| executed++; |
| if (executed == worker_num) |
| complete(ctrl.post.apply(scope, [outputs])); |
| } |
| })(i); |
| var msg = { "input" : inputs[i], |
| "name" : funct.toString(), |
| "shared" : scope.shared, |
| "id" : i, |
| "worker" : params.worker_num }; |
| try { |
| worker.postMessage(msg); |
| } catch (e) { |
| worker.postMessage(JSON.stringify(msg)); |
| } |
| } |
| } |
| } else { |
| return ctrl.post.apply(scope, [[ctrl.core.apply(scope, [ctrl.pre.apply(scope, [1])[0], 0, 1])]]); |
| } |
| } |
| }; |
| parallable.core = {}; |
| } |
| |
| function get_named_arguments(params, names) { |
| if (params.length > 1) { |
| var new_params = {}; |
| for (var i = 0; i < names.length; i++) |
| new_params[names[i]] = params[i]; |
| return new_params; |
| } else if (params.length == 1) { |
| return params[0]; |
| } else { |
| return {}; |
| } |
| } |
| |
| var ccv = { |
| pre : function (image) { |
| if (image.tagName.toLowerCase() == "img") { |
| var canvas = document.createElement("canvas"); |
| document.body.appendChild(image); |
| canvas.width = image.offsetWidth; |
| canvas.style.width = image.offsetWidth.toString() + "px"; |
| canvas.height = image.offsetHeight; |
| canvas.style.height = image.offsetHeight.toString() + "px"; |
| document.body.removeChild(image); |
| var ctx = canvas.getContext("2d"); |
| ctx.drawImage(image, 0, 0); |
| return canvas; |
| } |
| return image; |
| }, |
| |
| grayscale : function (canvas) { |
| var ctx = canvas.getContext("2d"); |
| var imageData = ctx.getImageData(0, 0, canvas.width, canvas.height); |
| var data = imageData.data; |
| var pix1, pix2, pix = canvas.width * canvas.height * 4; |
| while (pix > 0) |
| data[pix -= 4] = data[pix1 = pix + 1] = data[pix2 = pix + 2] = (data[pix] * 0.3 + data[pix1] * 0.59 + data[pix2] * 0.11); |
| ctx.putImageData(imageData, 0, 0); |
| return canvas; |
| }, |
| |
| array_group : function (seq, gfunc) { |
| var i, j; |
| var node = new Array(seq.length); |
| for (i = 0; i < seq.length; i++) |
| node[i] = {"parent" : -1, |
| "element" : seq[i], |
| "rank" : 0}; |
| for (i = 0; i < seq.length; i++) { |
| if (!node[i].element) |
| continue; |
| var root = i; |
| while (node[root].parent != -1) |
| root = node[root].parent; |
| for (j = 0; j < seq.length; j++) { |
| if( i != j && node[j].element && gfunc(node[i].element, node[j].element)) { |
| var root2 = j; |
| |
| while (node[root2].parent != -1) |
| root2 = node[root2].parent; |
| |
| if(root2 != root) { |
| if(node[root].rank > node[root2].rank) |
| node[root2].parent = root; |
| else { |
| node[root].parent = root2; |
| if (node[root].rank == node[root2].rank) |
| node[root2].rank++; |
| root = root2; |
| } |
| |
| /* compress path from node2 to the root: */ |
| var temp, node2 = j; |
| while (node[node2].parent != -1) { |
| temp = node2; |
| node2 = node[node2].parent; |
| node[temp].parent = root; |
| } |
| |
| /* compress path from node to the root: */ |
| node2 = i; |
| while (node[node2].parent != -1) { |
| temp = node2; |
| node2 = node[node2].parent; |
| node[temp].parent = root; |
| } |
| } |
| } |
| } |
| } |
| var idx = new Array(seq.length); |
| var class_idx = 0; |
| for(i = 0; i < seq.length; i++) { |
| j = -1; |
| var node1 = i; |
| if(node[node1].element) { |
| while (node[node1].parent != -1) |
| node1 = node[node1].parent; |
| if(node[node1].rank >= 0) |
| node[node1].rank = ~class_idx++; |
| j = ~node[node1].rank; |
| } |
| idx[i] = j; |
| } |
| return {"index" : idx, "cat" : class_idx}; |
| }, |
| |
| detect_objects : parallable("ccv.js", function (canvas, cascade, interval, min_neighbors) { |
| if (this.shared !== undefined) { |
| var params = get_named_arguments(arguments, ["canvas", "cascade", "interval", "min_neighbors"]); |
| this.shared.canvas = params.canvas; |
| this.shared.interval = params.interval; |
| this.shared.min_neighbors = params.min_neighbors; |
| this.shared.cascade = params.cascade; |
| this.shared.scale = Math.pow(2, 1 / (params.interval + 1)); |
| this.shared.next = params.interval + 1; |
| this.shared.scale_upto = Math.floor(Math.log(Math.min(params.canvas.width / params.cascade.width, params.canvas.height / params.cascade.height)) / Math.log(this.shared.scale)); |
| var i; |
| for (i = 0; i < this.shared.cascade.stage_classifier.length; i++) |
| this.shared.cascade.stage_classifier[i].orig_feature = this.shared.cascade.stage_classifier[i].feature; |
| } |
| function pre(worker_num) { |
| var canvas = this.shared.canvas; |
| var interval = this.shared.interval; |
| var scale = this.shared.scale; |
| var next = this.shared.next; |
| var scale_upto = this.shared.scale_upto; |
| var pyr = new Array((scale_upto + next * 2) * 4); |
| var ret = new Array((scale_upto + next * 2) * 4); |
| pyr[0] = canvas; |
| ret[0] = { "width" : pyr[0].width, |
| "height" : pyr[0].height, |
| "data" : pyr[0].getContext("2d").getImageData(0, 0, pyr[0].width, pyr[0].height).data }; |
| var i; |
| for (i = 1; i <= interval; i++) { |
| pyr[i * 4] = document.createElement("canvas"); |
| pyr[i * 4].width = Math.floor(pyr[0].width / Math.pow(scale, i)); |
| pyr[i * 4].height = Math.floor(pyr[0].height / Math.pow(scale, i)); |
| pyr[i * 4].getContext("2d").drawImage(pyr[0], 0, 0, pyr[0].width, pyr[0].height, 0, 0, pyr[i * 4].width, pyr[i * 4].height); |
| ret[i * 4] = { "width" : pyr[i * 4].width, |
| "height" : pyr[i * 4].height, |
| "data" : pyr[i * 4].getContext("2d").getImageData(0, 0, pyr[i * 4].width, pyr[i * 4].height).data }; |
| } |
| for (i = next; i < scale_upto + next * 2; i++) { |
| pyr[i * 4] = document.createElement("canvas"); |
| pyr[i * 4].width = Math.floor(pyr[i * 4 - next * 4].width / 2); |
| pyr[i * 4].height = Math.floor(pyr[i * 4 - next * 4].height / 2); |
| pyr[i * 4].getContext("2d").drawImage(pyr[i * 4 - next * 4], 0, 0, pyr[i * 4 - next * 4].width, pyr[i * 4 - next * 4].height, 0, 0, pyr[i * 4].width, pyr[i * 4].height); |
| ret[i * 4] = { "width" : pyr[i * 4].width, |
| "height" : pyr[i * 4].height, |
| "data" : pyr[i * 4].getContext("2d").getImageData(0, 0, pyr[i * 4].width, pyr[i * 4].height).data }; |
| } |
| for (i = next * 2; i < scale_upto + next * 2; i++) { |
| pyr[i * 4 + 1] = document.createElement("canvas"); |
| pyr[i * 4 + 1].width = Math.floor(pyr[i * 4 - next * 4].width / 2); |
| pyr[i * 4 + 1].height = Math.floor(pyr[i * 4 - next * 4].height / 2); |
| pyr[i * 4 + 1].getContext("2d").drawImage(pyr[i * 4 - next * 4], 1, 0, pyr[i * 4 - next * 4].width - 1, pyr[i * 4 - next * 4].height, 0, 0, pyr[i * 4 + 1].width - 2, pyr[i * 4 + 1].height); |
| ret[i * 4 + 1] = { "width" : pyr[i * 4 + 1].width, |
| "height" : pyr[i * 4 + 1].height, |
| "data" : pyr[i * 4 + 1].getContext("2d").getImageData(0, 0, pyr[i * 4 + 1].width, pyr[i * 4 + 1].height).data }; |
| pyr[i * 4 + 2] = document.createElement("canvas"); |
| pyr[i * 4 + 2].width = Math.floor(pyr[i * 4 - next * 4].width / 2); |
| pyr[i * 4 + 2].height = Math.floor(pyr[i * 4 - next * 4].height / 2); |
| pyr[i * 4 + 2].getContext("2d").drawImage(pyr[i * 4 - next * 4], 0, 1, pyr[i * 4 - next * 4].width, pyr[i * 4 - next * 4].height - 1, 0, 0, pyr[i * 4 + 2].width, pyr[i * 4 + 2].height - 2); |
| ret[i * 4 + 2] = { "width" : pyr[i * 4 + 2].width, |
| "height" : pyr[i * 4 + 2].height, |
| "data" : pyr[i * 4 + 2].getContext("2d").getImageData(0, 0, pyr[i * 4 + 2].width, pyr[i * 4 + 2].height).data }; |
| pyr[i * 4 + 3] = document.createElement("canvas"); |
| pyr[i * 4 + 3].width = Math.floor(pyr[i * 4 - next * 4].width / 2); |
| pyr[i * 4 + 3].height = Math.floor(pyr[i * 4 - next * 4].height / 2); |
| pyr[i * 4 + 3].getContext("2d").drawImage(pyr[i * 4 - next * 4], 1, 1, pyr[i * 4 - next * 4].width - 1, pyr[i * 4 - next * 4].height - 1, 0, 0, pyr[i * 4 + 3].width - 2, pyr[i * 4 + 3].height - 2); |
| ret[i * 4 + 3] = { "width" : pyr[i * 4 + 3].width, |
| "height" : pyr[i * 4 + 3].height, |
| "data" : pyr[i * 4 + 3].getContext("2d").getImageData(0, 0, pyr[i * 4 + 3].width, pyr[i * 4 + 3].height).data }; |
| } |
| return [ret]; |
| }; |
| |
| function core(pyr, id, worker_num) { |
| var cascade = this.shared.cascade; |
| var interval = this.shared.interval; |
| var scale = this.shared.scale; |
| var next = this.shared.next; |
| var scale_upto = this.shared.scale_upto; |
| var i, j, k, x, y, q; |
| var scale_x = 1, scale_y = 1; |
| var dx = [0, 1, 0, 1]; |
| var dy = [0, 0, 1, 1]; |
| var seq = []; |
| for (i = 0; i < scale_upto; i++) { |
| var qw = pyr[i * 4 + next * 8].width - Math.floor(cascade.width / 4); |
| var qh = pyr[i * 4 + next * 8].height - Math.floor(cascade.height / 4); |
| var step = [pyr[i * 4].width * 4, pyr[i * 4 + next * 4].width * 4, pyr[i * 4 + next * 8].width * 4]; |
| var paddings = [pyr[i * 4].width * 16 - qw * 16, |
| pyr[i * 4 + next * 4].width * 8 - qw * 8, |
| pyr[i * 4 + next * 8].width * 4 - qw * 4]; |
| for (j = 0; j < cascade.stage_classifier.length; j++) { |
| var orig_feature = cascade.stage_classifier[j].orig_feature; |
| var feature = cascade.stage_classifier[j].feature = new Array(cascade.stage_classifier[j].count); |
| for (k = 0; k < cascade.stage_classifier[j].count; k++) { |
| feature[k] = {"size" : orig_feature[k].size, |
| "px" : new Array(orig_feature[k].size), |
| "pz" : new Array(orig_feature[k].size), |
| "nx" : new Array(orig_feature[k].size), |
| "nz" : new Array(orig_feature[k].size)}; |
| for (q = 0; q < orig_feature[k].size; q++) { |
| feature[k].px[q] = orig_feature[k].px[q] * 4 + orig_feature[k].py[q] * step[orig_feature[k].pz[q]]; |
| feature[k].pz[q] = orig_feature[k].pz[q]; |
| feature[k].nx[q] = orig_feature[k].nx[q] * 4 + orig_feature[k].ny[q] * step[orig_feature[k].nz[q]]; |
| feature[k].nz[q] = orig_feature[k].nz[q]; |
| } |
| } |
| } |
| for (q = 0; q < 4; q++) { |
| var u8 = [pyr[i * 4].data, pyr[i * 4 + next * 4].data, pyr[i * 4 + next * 8 + q].data]; |
| var u8o = [dx[q] * 8 + dy[q] * pyr[i * 4].width * 8, dx[q] * 4 + dy[q] * pyr[i * 4 + next * 4].width * 4, 0]; |
| for (y = 0; y < qh; y++) { |
| for (x = 0; x < qw; x++) { |
| var sum = 0; |
| var flag = true; |
| for (j = 0; j < cascade.stage_classifier.length; j++) { |
| sum = 0; |
| var alpha = cascade.stage_classifier[j].alpha; |
| var feature = cascade.stage_classifier[j].feature; |
| for (k = 0; k < cascade.stage_classifier[j].count; k++) { |
| var feature_k = feature[k]; |
| var p, pmin = u8[feature_k.pz[0]][u8o[feature_k.pz[0]] + feature_k.px[0]]; |
| var n, nmax = u8[feature_k.nz[0]][u8o[feature_k.nz[0]] + feature_k.nx[0]]; |
| if (pmin <= nmax) { |
| sum += alpha[k * 2]; |
| } else { |
| var f, shortcut = true; |
| for (f = 0; f < feature_k.size; f++) { |
| if (feature_k.pz[f] >= 0) { |
| p = u8[feature_k.pz[f]][u8o[feature_k.pz[f]] + feature_k.px[f]]; |
| if (p < pmin) { |
| if (p <= nmax) { |
| shortcut = false; |
| break; |
| } |
| pmin = p; |
| } |
| } |
| if (feature_k.nz[f] >= 0) { |
| n = u8[feature_k.nz[f]][u8o[feature_k.nz[f]] + feature_k.nx[f]]; |
| if (n > nmax) { |
| if (pmin <= n) { |
| shortcut = false; |
| break; |
| } |
| nmax = n; |
| } |
| } |
| } |
| sum += (shortcut) ? alpha[k * 2 + 1] : alpha[k * 2]; |
| } |
| } |
| if (sum < cascade.stage_classifier[j].threshold) { |
| flag = false; |
| break; |
| } |
| } |
| if (flag) { |
| seq.push({"x" : (x * 4 + dx[q] * 2) * scale_x, |
| "y" : (y * 4 + dy[q] * 2) * scale_y, |
| "width" : cascade.width * scale_x, |
| "height" : cascade.height * scale_y, |
| "neighbor" : 1, |
| "confidence" : sum}); |
| } |
| u8o[0] += 16; |
| u8o[1] += 8; |
| u8o[2] += 4; |
| } |
| u8o[0] += paddings[0]; |
| u8o[1] += paddings[1]; |
| u8o[2] += paddings[2]; |
| } |
| } |
| scale_x *= scale; |
| scale_y *= scale; |
| } |
| return seq; |
| }; |
| |
| function post(seq) { |
| var min_neighbors = this.shared.min_neighbors; |
| var cascade = this.shared.cascade; |
| var interval = this.shared.interval; |
| var scale = this.shared.scale; |
| var next = this.shared.next; |
| var scale_upto = this.shared.scale_upto; |
| var i, j; |
| for (i = 0; i < cascade.stage_classifier.length; i++) |
| cascade.stage_classifier[i].feature = cascade.stage_classifier[i].orig_feature; |
| seq = seq[0]; |
| if (!(min_neighbors > 0)) |
| return seq; |
| else { |
| var result = ccv.array_group(seq, function (r1, r2) { |
| var distance = Math.floor(r1.width * 0.25 + 0.5); |
| |
| return r2.x <= r1.x + distance && |
| r2.x >= r1.x - distance && |
| r2.y <= r1.y + distance && |
| r2.y >= r1.y - distance && |
| r2.width <= Math.floor(r1.width * 1.5 + 0.5) && |
| Math.floor(r2.width * 1.5 + 0.5) >= r1.width; |
| }); |
| var ncomp = result.cat; |
| var idx_seq = result.index; |
| var comps = new Array(ncomp + 1); |
| for (i = 0; i < comps.length; i++) |
| comps[i] = {"neighbors" : 0, |
| "x" : 0, |
| "y" : 0, |
| "width" : 0, |
| "height" : 0, |
| "confidence" : 0}; |
| |
| // count number of neighbors |
| for(i = 0; i < seq.length; i++) |
| { |
| var r1 = seq[i]; |
| var idx = idx_seq[i]; |
| |
| if (comps[idx].neighbors == 0) |
| comps[idx].confidence = r1.confidence; |
| |
| ++comps[idx].neighbors; |
| |
| comps[idx].x += r1.x; |
| comps[idx].y += r1.y; |
| comps[idx].width += r1.width; |
| comps[idx].height += r1.height; |
| comps[idx].confidence = Math.max(comps[idx].confidence, r1.confidence); |
| } |
| |
| var seq2 = []; |
| // calculate average bounding box |
| for(i = 0; i < ncomp; i++) |
| { |
| var n = comps[i].neighbors; |
| if (n >= min_neighbors) |
| seq2.push({"x" : (comps[i].x * 2 + n) / (2 * n), |
| "y" : (comps[i].y * 2 + n) / (2 * n), |
| "width" : (comps[i].width * 2 + n) / (2 * n), |
| "height" : (comps[i].height * 2 + n) / (2 * n), |
| "neighbors" : comps[i].neighbors, |
| "confidence" : comps[i].confidence}); |
| } |
| |
| var result_seq = []; |
| // filter out small face rectangles inside large face rectangles |
| for(i = 0; i < seq2.length; i++) |
| { |
| var r1 = seq2[i]; |
| var flag = true; |
| for(j = 0; j < seq2.length; j++) |
| { |
| var r2 = seq2[j]; |
| var distance = Math.floor(r2.width * 0.25 + 0.5); |
| |
| if(i != j && |
| r1.x >= r2.x - distance && |
| r1.y >= r2.y - distance && |
| r1.x + r1.width <= r2.x + r2.width + distance && |
| r1.y + r1.height <= r2.y + r2.height + distance && |
| (r2.neighbors > Math.max(3, r1.neighbors) || r1.neighbors < 3)) |
| { |
| flag = false; |
| break; |
| } |
| } |
| |
| if(flag) |
| result_seq.push(r1); |
| } |
| return result_seq; |
| } |
| }; |
| return { "pre" : pre, "core" : core, "post" : post }; |
| }) |
| } |
| |
| onmessage = function (event) { |
| var data = (typeof event.data == "string") ? JSON.parse(event.data) : event.data; |
| var scope = { "shared" : data.shared }; |
| var result = parallable.core[data.name].apply(scope, [data.input, data.id, data.worker]); |
| try { |
| postMessage(result); |
| } catch (e) { |
| postMessage(JSON.stringify(result)); |
| } |
| } |
