BVB Source Codes

jsfeat Show jsfeat_haar.js Source code

Return Download jsfeat: download jsfeat_haar.js Source code - Download jsfeat Source code - Type:.js
  1. /**
  2.  * @author Eugene Zatepyakin / http://inspirit.ru/
  3.  *
  4.  * this code is a rewrite from https://github.com/mtschirs/js-objectdetect implementation
  5.  * @author Martin Tschirsich / http://www.tu-darmstadt.de/~m_t
  6.  */
  7.  
  8. (function(global) {
  9.     "use strict";
  10.     //
  11.     var haar = (function() {
  12.  
  13.         var _group_func = function(r1, r2) {
  14.             var distance = (r1.width * 0.25 + 0.5)|0;
  15.  
  16.             return r2.x <= r1.x + distance &&
  17.                    r2.x >= r1.x - distance &&
  18.                    r2.y <= r1.y + distance &&
  19.                    r2.y >= r1.y - distance &&
  20.                    r2.width <= (r1.width * 1.5 + 0.5)|0 &&
  21.                    (r2.width * 1.5 + 0.5)|0 >= r1.width;
  22.         }
  23.        
  24.         return {
  25.  
  26.             edges_density: 0.07,
  27.  
  28.             detect_single_scale: function(int_sum, int_sqsum, int_tilted, int_canny_sum, width, height, scale, classifier) {
  29.                 var win_w = (classifier.size[0] * scale)|0,
  30.                     win_h = (classifier.size[1] * scale)|0,
  31.                     step_x = (0.5 * scale + 1.5)|0,
  32.                     step_y = step_x;
  33.                 var i,j,k,x,y,ex=(width-win_w)|0,ey=(height-win_h)|0;
  34.                 var w1=(width+1)|0,edge_dens,mean,variance,std;
  35.                 var inv_area = 1.0 / (win_w * win_h);
  36.                 var stages,stage,trees,tree,sn,tn,fn,found=true,stage_thresh,stage_sum,tree_sum,feature,features;
  37.                 var fi_a,fi_b,fi_c,fi_d,fw,fh;
  38.  
  39.                 var ii_a=0,ii_b=win_w,ii_c=win_h*w1,ii_d=ii_c+win_w;
  40.                 var edges_thresh = ((win_w*win_h) * 0xff * this.edges_density)|0;
  41.                 // if too much gradient we also can skip
  42.                 //var edges_thresh_high = ((win_w*win_h) * 0xff * 0.3)|0;
  43.  
  44.                 var rects = [];
  45.                 for(y = 0; y < ey; y += step_y) {
  46.                     ii_a = y * w1;
  47.                     for(x = 0; x < ex; x += step_x, ii_a += step_x) {
  48.  
  49.                         mean =    int_sum[ii_a]
  50.                                 - int_sum[ii_a+ii_b]
  51.                                 - int_sum[ii_a+ii_c]
  52.                                 + int_sum[ii_a+ii_d];
  53.  
  54.                         // canny prune
  55.                         if(int_canny_sum) {
  56.                             edge_dens = (int_canny_sum[ii_a]
  57.                                         - int_canny_sum[ii_a+ii_b]
  58.                                         - int_canny_sum[ii_a+ii_c]
  59.                                         + int_canny_sum[ii_a+ii_d]);
  60.                             if(edge_dens < edges_thresh || mean < 20) {
  61.                                 x += step_x, ii_a += step_x;
  62.                                 continue;
  63.                             }
  64.                         }
  65.  
  66.                         mean *= inv_area;
  67.                         variance = (int_sqsum[ii_a]
  68.                                     - int_sqsum[ii_a+ii_b]
  69.                                     - int_sqsum[ii_a+ii_c]
  70.                                     + int_sqsum[ii_a+ii_d]) * inv_area - mean * mean;
  71.  
  72.                         std = variance > 0. ? Math.sqrt(variance) : 1;
  73.  
  74.                         stages = classifier.complexClassifiers;
  75.                         sn = stages.length;
  76.                         found =  true;
  77.                         for(i = 0; i < sn; ++i) {
  78.                             stage = stages[i];
  79.                             stage_thresh = stage.threshold;
  80.                             trees = stage.simpleClassifiers;
  81.                             tn = trees.length;
  82.                             stage_sum = 0;
  83.                             for(j = 0; j < tn; ++j) {
  84.                                 tree = trees[j];
  85.                                 tree_sum = 0;
  86.                                 features = tree.features;
  87.                                 fn = features.length;
  88.                                 if(tree.tilted === 1) {
  89.                                     for(k=0; k < fn; ++k) {
  90.                                         feature = features[k];
  91.                                         fi_a = ~~(x + feature[0] * scale) + ~~(y + feature[1] * scale) * w1;
  92.                                         fw = ~~(feature[2] * scale);
  93.                                         fh = ~~(feature[3] * scale);
  94.                                         fi_b = fw * w1;
  95.                                         fi_c =  fh * w1;
  96.  
  97.                                         tree_sum += (int_tilted[fi_a]
  98.                                                     - int_tilted[fi_a + fw + fi_b]
  99.                                                     - int_tilted[fi_a - fh + fi_c]
  100.                                                     + int_tilted[fi_a + fw - fh + fi_b + fi_c]) * feature[4];
  101.                                     }
  102.                                 } else {
  103.                                     for(k=0; k < fn; ++k) {
  104.                                         feature = features[k];
  105.                                         fi_a = ~~(x + feature[0] * scale) + ~~(y + feature[1] * scale) * w1;
  106.                                         fw = ~~(feature[2] * scale);
  107.                                         fh = ~~(feature[3] * scale);
  108.                                         fi_c = fh * w1;
  109.  
  110.                                         tree_sum += (int_sum[fi_a]
  111.                                                     - int_sum[fi_a+fw]
  112.                                                     - int_sum[fi_a+fi_c]
  113.                                                     + int_sum[fi_a+fi_c+fw]) * feature[4];
  114.                                     }
  115.                                 }
  116.                                 stage_sum += (tree_sum * inv_area < tree.threshold * std) ? tree.left_val : tree.right_val;
  117.                             }
  118.                             if (stage_sum < stage_thresh) {
  119.                                 found = false;
  120.                                 break;
  121.                             }
  122.                         }
  123.                        
  124.                         if(found) {
  125.                             rects.push({"x" : x,
  126.                                         "y" : y,
  127.                                         "width" : win_w,
  128.                                         "height" : win_h,
  129.                                         "neighbor" : 1,
  130.                                         "confidence" : stage_sum});
  131.                             x += step_x, ii_a += step_x;
  132.                         }
  133.                     }
  134.                 }
  135.                 return rects;
  136.             },
  137.  
  138.             detect_multi_scale: function(int_sum, int_sqsum, int_tilted, int_canny_sum, width, height, classifier, scale_factor, scale_min) {
  139.                 if (typeof scale_factor === "undefined") { scale_factor = 1.2; }
  140.                 if (typeof scale_min === "undefined") { scale_min = 1.0; }
  141.                 var win_w = classifier.size[0];
  142.                 var win_h = classifier.size[1];
  143.                 var rects = [];
  144.                 while (scale_min * win_w < width && scale_min * win_h < height) {
  145.                     rects = rects.concat(this.detect_single_scale(int_sum, int_sqsum, int_tilted, int_canny_sum, width, height, scale_min, classifier));
  146.                     scale_min *= scale_factor;
  147.                 }
  148.                 return rects;
  149.             },
  150.  
  151.             // OpenCV method to group detected rectangles
  152.             group_rectangles: function(rects, min_neighbors) {
  153.                 if (typeof min_neighbors === "undefined") { min_neighbors = 1; }
  154.                 var i, j, n = rects.length;
  155.                 var node = [];
  156.                 for (i = 0; i < n; ++i) {
  157.                     node[i] = {"parent" : -1,
  158.                                "element" : rects[i],
  159.                                "rank" : 0};
  160.                 }
  161.                 for (i = 0; i < n; ++i) {
  162.                     if (!node[i].element)
  163.                         continue;
  164.                     var root = i;
  165.                     while (node[root].parent != -1)
  166.                         root = node[root].parent;
  167.                     for (j = 0; j < n; ++j) {
  168.                         if( i != j && node[j].element && _group_func(node[i].element, node[j].element)) {
  169.                             var root2 = j;
  170.  
  171.                             while (node[root2].parent != -1)
  172.                                 root2 = node[root2].parent;
  173.  
  174.                             if(root2 != root) {
  175.                                 if(node[root].rank > node[root2].rank)
  176.                                     node[root2].parent = root;
  177.                                 else {
  178.                                     node[root].parent = root2;
  179.                                     if (node[root].rank == node[root2].rank)
  180.                                     node[root2].rank++;
  181.                                     root = root2;
  182.                                 }
  183.  
  184.                                 /* compress path from node2 to the root: */
  185.                                 var temp, node2 = j;
  186.                                 while (node[node2].parent != -1) {
  187.                                     temp = node2;
  188.                                     node2 = node[node2].parent;
  189.                                     node[temp].parent = root;
  190.                                 }
  191.  
  192.                                 /* compress path from node to the root: */
  193.                                 node2 = i;
  194.                                 while (node[node2].parent != -1) {
  195.                                     temp = node2;
  196.                                     node2 = node[node2].parent;
  197.                                     node[temp].parent = root;
  198.                                 }
  199.                             }
  200.                         }
  201.                     }
  202.                 }
  203.                 var idx_seq = [];
  204.                 var class_idx = 0;
  205.                 for(i = 0; i < n; i++) {
  206.                     j = -1;
  207.                     var node1 = i;
  208.                     if(node[node1].element) {
  209.                         while (node[node1].parent != -1)
  210.                             node1 = node[node1].parent;
  211.                         if(node[node1].rank >= 0)
  212.                             node[node1].rank = ~class_idx++;
  213.                         j = ~node[node1].rank;
  214.                     }
  215.                     idx_seq[i] = j;
  216.                 }
  217.                
  218.                 var comps = [];
  219.                 for (i = 0; i < class_idx+1; ++i) {
  220.                     comps[i] = {"neighbors" : 0,
  221.                                 "x" : 0,
  222.                                 "y" : 0,
  223.                                 "width" : 0,
  224.                                 "height" : 0,
  225.                                 "confidence" : 0};
  226.                 }
  227.  
  228.                 // count number of neighbors
  229.                 for(i = 0; i < n; ++i) {
  230.                     var r1 = rects[i];
  231.                     var idx = idx_seq[i];
  232.  
  233.                     if (comps[idx].neighbors == 0)
  234.                         comps[idx].confidence = r1.confidence;
  235.  
  236.                     ++comps[idx].neighbors;
  237.  
  238.                     comps[idx].x += r1.x;
  239.                     comps[idx].y += r1.y;
  240.                     comps[idx].width += r1.width;
  241.                     comps[idx].height += r1.height;
  242.                     comps[idx].confidence = Math.max(comps[idx].confidence, r1.confidence);
  243.                 }
  244.  
  245.                 var seq2 = [];
  246.                 // calculate average bounding box
  247.                 for(i = 0; i < class_idx; ++i) {
  248.                     n = comps[i].neighbors;
  249.                     if (n >= min_neighbors)
  250.                         seq2.push({"x" : (comps[i].x * 2 + n) / (2 * n),
  251.                                    "y" : (comps[i].y * 2 + n) / (2 * n),
  252.                                    "width" : (comps[i].width * 2 + n) / (2 * n),
  253.                                    "height" : (comps[i].height * 2 + n) / (2 * n),
  254.                                    "neighbors" : comps[i].neighbors,
  255.                                    "confidence" : comps[i].confidence});
  256.                 }
  257.  
  258.                 var result_seq = [];
  259.                 n = seq2.length;
  260.                 // filter out small face rectangles inside large face rectangles
  261.                 for(i = 0; i < n; ++i) {
  262.                     var r1 = seq2[i];
  263.                     var flag = true;
  264.                     for(j = 0; j < n; ++j) {
  265.                         var r2 = seq2[j];
  266.                         var distance = (r2.width * 0.25 + 0.5)|0;
  267.  
  268.                         if(i != j &&
  269.                            r1.x >= r2.x - distance &&
  270.                            r1.y >= r2.y - distance &&
  271.                            r1.x + r1.width <= r2.x + r2.width + distance &&
  272.                            r1.y + r1.height <= r2.y + r2.height + distance &&
  273.                            (r2.neighbors > Math.max(3, r1.neighbors) || r1.neighbors < 3)) {
  274.                             flag = false;
  275.                             break;
  276.                         }
  277.                     }
  278.  
  279.                     if(flag)
  280.                         result_seq.push(r1);
  281.                 }
  282.                 return result_seq;
  283.             }
  284.         };
  285.  
  286.     })();
  287.  
  288.     global.haar = haar;
  289.  
  290. })(jsfeat);
  291.  
downloadjsfeat_haar.js Source code - Download jsfeat Source code
Related Source Codes/Software:
flakes - Flakes is an Admin Template Framework. A combinati... 2017-04-15
capstone - Capstone disassembly/disassembler framework: Core ... 2017-04-15
nginx-resources - A collection of resources covering Nginx, Nginx + ... 2017-04-15
utron - A lightweight MVC framework for Go(Golang) 2017-04-15
cfssl - CFSSL: Cloudflare's PKI and TLS toolkit ... 2017-04-15
MLeaksFinder - Find memory leaks in your iOS app at develop time. 2017-04-16
qt - Qt binding for Go (Golang) which supports Windows ... 2017-04-16
rainloop-webmail - Simple, modern & fast web-based email client ... 2017-04-16
pencil - Multiplatform GUI Prototyping/Wireframing 2017-04-16
x64dbg - An open-source x64/x32 debugger for windows. ... 2017-04-16
Toucan - Fabulous Image Processing in Swift 2017-04-23
CoffeeScriptRedux - 2017-04-23
breakpoint - Really simple media queries in Sa 2017-04-23
libsvm - 2017-04-22
grr - GRR Rapid Response: remote live forensics for inci... 2017-04-22
grit - **Grit is no longer maintained. Check out libgit2/... 2017-04-22
guard-livereload - Guard::LiveReload automatically reload your browse... 2017-04-22
Begin-Latex-in-minutes - Brief Intro to LaTeX for beginners that helps you ... 2017-04-22
wicked - Use wicked to turn your controller into a wizard ... 2017-04-22
flexboxfroggy - A game for learning CSS flexbox ... 2017-04-22

 Back to top