BVB Source Codes

jsfeat Show jsfeat_fast_corners.js Source code

Return Download jsfeat: download jsfeat_fast_corners.js Source code - Download jsfeat Source code - Type:.js
  1. /**
  2.  * @author Eugene Zatepyakin / http://inspirit.ru/
  3.  *
  4.  * This is FAST corner detector, contributed to OpenCV by the author, Edward Rosten.
  5.  */
  6.  
  7. /*
  8. The references are:
  9.  * Machine learning for high-speed corner detection,
  10.    E. Rosten and T. Drummond, ECCV 2006
  11.  * Faster and better: A machine learning approach to corner detection
  12.    E. Rosten, R. Porter and T. Drummond, PAMI, 2009  
  13. */
  14.  
  15. (function(global) {
  16.     "use strict";
  17.     //
  18.     var fast_corners = (function() {
  19.  
  20.         var offsets16 = new Int32Array([0, 3, 1, 3, 2, 2, 3, 1, 3, 0, 3, -1, 2, -2, 1, -3, 0, -3, -1, -3, -2, -2, -3, -1, -3, 0, -3, 1, -2, 2, -1, 3]);
  21.  
  22.         var threshold_tab = new Uint8Array(512);
  23.         var pixel_off = new Int32Array(25);
  24.         var score_diff = new Int32Array(25);
  25.  
  26.         // private functions
  27.         var _cmp_offsets = function(pixel, step, pattern_size) {
  28.             var k = 0;
  29.             var offsets = offsets16;
  30.             for( ; k < pattern_size; ++k ) {
  31.                 pixel[k] = offsets[k<<1] + offsets[(k<<1)+1] * step;
  32.             }
  33.             for( ; k < 25; ++k ) {
  34.                 pixel[k] = pixel[k - pattern_size];
  35.             }
  36.         },
  37.  
  38.         _cmp_score_16 = function(src, off, pixel, d, threshold) {
  39.             var N = 25, k = 0, v = src[off];
  40.             var a0 = threshold,a=0,b0=0,b=0;
  41.  
  42.             for( ; k < N; ++k ) {
  43.                 d[k] = v - src[off+pixel[k]];
  44.             }
  45.  
  46.             for( k = 0; k < 16; k += 2 ) {
  47.                 a = Math.min(d[k+1], d[k+2]);
  48.                 a = Math.min(a, d[k+3]);
  49.  
  50.                 if( a <= a0 ) continue;
  51.  
  52.                 a = Math.min(a, d[k+4]);
  53.                 a = Math.min(a, d[k+5]);
  54.                 a = Math.min(a, d[k+6]);
  55.                 a = Math.min(a, d[k+7]);
  56.                 a = Math.min(a, d[k+8]);
  57.                 a0 = Math.max(a0, Math.min(a, d[k]));
  58.                 a0 = Math.max(a0, Math.min(a, d[k+9]));
  59.             }
  60.  
  61.             b0 = -a0;
  62.             for( k = 0; k < 16; k += 2 ) {
  63.                 b = Math.max(d[k+1], d[k+2]);
  64.                 b = Math.max(b, d[k+3]);
  65.                 b = Math.max(b, d[k+4]);
  66.                 b = Math.max(b, d[k+5]);
  67.  
  68.                 if( b >= b0 ) continue;
  69.                 b = Math.max(b, d[k+6]);
  70.                 b = Math.max(b, d[k+7]);
  71.                 b = Math.max(b, d[k+8]);
  72.                 b0 = Math.min(b0, Math.max(b, d[k]));
  73.                 b0 = Math.min(b0, Math.max(b, d[k+9]));
  74.             }
  75.  
  76.             return -b0-1;
  77.         };
  78.  
  79.         var _threshold = 20;
  80.  
  81.         return {
  82.             set_threshold: function(threshold) {
  83.                 _threshold = Math.min(Math.max(threshold, 0), 255);
  84.                 for (var i = -255; i <= 255; ++i) {
  85.                     threshold_tab[(i + 255)] = (i < -_threshold ? 1 : (i > _threshold ? 2 : 0));
  86.                 }
  87.                 return _threshold;
  88.             },
  89.            
  90.             detect: function(src, corners, border) {
  91.                 if (typeof border === "undefined") { border = 3; }
  92.  
  93.                 var K = 8, N = 25;
  94.                 var img = src.data, w = src.cols, h = src.rows;
  95.                 var i=0, j=0, k=0, vt=0, x=0, m3=0;
  96.                 var buf_node = jsfeat.cache.get_buffer(3 * w);
  97.                 var cpbuf_node = jsfeat.cache.get_buffer(((w+1)*3)<<2);
  98.                 var buf = buf_node.u8;
  99.                 var cpbuf = cpbuf_node.i32;
  100.                 var pixel = pixel_off;
  101.                 var sd = score_diff;
  102.                 var sy = Math.max(3, border);
  103.                 var ey = Math.min((h-2), (h-border));
  104.                 var sx = Math.max(3, border);
  105.                 var ex = Math.min((w - 3), (w - border));
  106.                 var _count = 0, corners_cnt = 0, pt;
  107.                 var score_func = _cmp_score_16;
  108.                 var thresh_tab = threshold_tab;
  109.                 var threshold = _threshold;
  110.  
  111.                 var v=0,tab=0,d=0,ncorners=0,cornerpos=0,curr=0,ptr=0,prev=0,pprev=0;
  112.                 var jp1=0,jm1=0,score=0;
  113.  
  114.                 _cmp_offsets(pixel, w, 16);
  115.  
  116.                 // local vars are faster?
  117.                 var pixel0 = pixel[0];
  118.                 var pixel1 = pixel[1];
  119.                 var pixel2 = pixel[2];
  120.                 var pixel3 = pixel[3];
  121.                 var pixel4 = pixel[4];
  122.                 var pixel5 = pixel[5];
  123.                 var pixel6 = pixel[6];
  124.                 var pixel7 = pixel[7];
  125.                 var pixel8 = pixel[8];
  126.                 var pixel9 = pixel[9];
  127.                 var pixel10 = pixel[10];
  128.                 var pixel11 = pixel[11];
  129.                 var pixel12 = pixel[12];
  130.                 var pixel13 = pixel[13];
  131.                 var pixel14 = pixel[14];
  132.                 var pixel15 = pixel[15];
  133.  
  134.                 for(i = 0; i < w*3; ++i) {
  135.                     buf[i] = 0;
  136.                 }
  137.  
  138.                 for(i = sy; i < ey; ++i) {
  139.                     ptr = ((i * w) + sx)|0;
  140.                     m3 = (i - 3)%3;
  141.                     curr = (m3*w)|0;
  142.                     cornerpos = (m3*(w+1))|0;
  143.                     for (j = 0; j < w; ++j) buf[curr+j] = 0;
  144.                     ncorners = 0;
  145.                    
  146.                     if( i < (ey - 1) ) {
  147.                         j = sx;
  148.                        
  149.                         for( ; j < ex; ++j, ++ptr ) {
  150.                             v = img[ptr];
  151.                             tab = ( - v + 255 );
  152.                             d = ( thresh_tab[tab+img[ptr+pixel0]] | thresh_tab[tab+img[ptr+pixel8]] );
  153.                            
  154.                             if( d == 0 ) {
  155.                                 continue;
  156.                             }
  157.                            
  158.                             d &= ( thresh_tab[tab+img[ptr+pixel2]] | thresh_tab[tab+img[ptr+pixel10]] );
  159.                             d &= ( thresh_tab[tab+img[ptr+pixel4]] | thresh_tab[tab+img[ptr+pixel12]] );
  160.                             d &= ( thresh_tab[tab+img[ptr+pixel6]] | thresh_tab[tab+img[ptr+pixel14]] );
  161.                            
  162.                             if( d == 0 ) {
  163.                                 continue;
  164.                             }
  165.                            
  166.                             d &= ( thresh_tab[tab+img[ptr+pixel1]] | thresh_tab[tab+img[ptr+pixel9]] );
  167.                             d &= ( thresh_tab[tab+img[ptr+pixel3]] | thresh_tab[tab+img[ptr+pixel11]] );
  168.                             d &= ( thresh_tab[tab+img[ptr+pixel5]] | thresh_tab[tab+img[ptr+pixel13]] );
  169.                             d &= ( thresh_tab[tab+img[ptr+pixel7]] | thresh_tab[tab+img[ptr+pixel15]] );
  170.                            
  171.                             if( d & 1 ) {
  172.                                 vt = (v - threshold);
  173.                                 _count = 0;
  174.                                
  175.                                 for( k = 0; k < N; ++k ) {
  176.                                     x = img[(ptr+pixel[k])];
  177.                                     if(x < vt) {
  178.                                         ++_count;
  179.                                         if( _count > K ) {
  180.                                             ++ncorners;
  181.                                             cpbuf[cornerpos+ncorners] = j;
  182.                                             buf[curr+j] = score_func(img, ptr, pixel, sd, threshold);
  183.                                             break;
  184.                                         }
  185.                                     }
  186.                                     else {
  187.                                         _count = 0;
  188.                                     }
  189.                                 }
  190.                             }
  191.                            
  192.                             if( d & 2 ) {
  193.                                 vt = (v + threshold);
  194.                                 _count = 0;
  195.                                
  196.                                 for( k = 0; k < N; ++k ) {
  197.                                     x = img[(ptr+pixel[k])];
  198.                                     if(x > vt) {
  199.                                         ++_count;
  200.                                         if( _count > K ) {
  201.                                             ++ncorners;
  202.                                             cpbuf[cornerpos+ncorners] = j;
  203.                                             buf[curr+j] = score_func(img, ptr, pixel, sd, threshold);
  204.                                             break;
  205.                                         }
  206.                                     }
  207.                                     else {
  208.                                         _count = 0;
  209.                                     }
  210.                                 }
  211.                             }
  212.                         }
  213.                     }
  214.                    
  215.                     cpbuf[cornerpos+w] = ncorners;
  216.            
  217.                     if ( i == sy ) {
  218.                         continue;
  219.                     }
  220.                    
  221.                     m3 = (i - 4 + 3)%3;
  222.                     prev = (m3*w)|0;
  223.                     cornerpos = (m3*(w+1))|0;
  224.                     m3 = (i - 5 + 3)%3;
  225.                     pprev = (m3*w)|0;
  226.  
  227.                     ncorners = cpbuf[cornerpos+w];
  228.                    
  229.                     for( k = 0; k < ncorners; ++k ) {
  230.                         j = cpbuf[cornerpos+k];
  231.                         jp1 = (j+1)|0;
  232.                         jm1 = (j-1)|0;
  233.                         score = buf[prev+j];
  234.                         if( (score > buf[prev+jp1] && score > buf[prev+jm1] &&
  235.                             score > buf[pprev+jm1] && score > buf[pprev+j] && score > buf[pprev+jp1] &&
  236.                             score > buf[curr+jm1] && score > buf[curr+j] && score > buf[curr+jp1]) ) {
  237.                             // save corner
  238.                             pt = corners[corners_cnt];
  239.                             pt.x = j, pt.y = (i-1), pt.score = score;
  240.                             corners_cnt++;
  241.                         }
  242.                     }
  243.                 } // y loop
  244.                 jsfeat.cache.put_buffer(buf_node);
  245.                 jsfeat.cache.put_buffer(cpbuf_node);
  246.                 return corners_cnt;
  247.             }
  248.         };
  249.     })();
  250.  
  251.     global.fast_corners = fast_corners;
  252.     fast_corners.set_threshold(20); // set default
  253.  
  254. })(jsfeat);
  255.  
downloadjsfeat_fast_corners.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