BVB Source Codes

jsfeat Show jsfeat_optical_flow_lk.js Source code

Return Download jsfeat: download jsfeat_optical_flow_lk.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 OpenCV's Lucas-Kanade optical flow implementation
  5.  */
  6.  
  7. (function(global) {
  8.     "use strict";
  9.     //
  10.     var optical_flow_lk = (function() {
  11.  
  12.         // short link to shar deriv
  13.         var scharr_deriv = jsfeat.imgproc.scharr_derivatives;
  14.  
  15.         return {
  16.             track: function(prev_pyr, curr_pyr, prev_xy, curr_xy, count, win_size, max_iter, status, eps, min_eigen_threshold) {
  17.                 if (typeof max_iter === "undefined") { max_iter = 30; }
  18.                 if (typeof status === "undefined") { status = new Uint8Array(count); }
  19.                 if (typeof eps === "undefined") { eps = 0.01; }
  20.                 if (typeof min_eigen_threshold === "undefined") { min_eigen_threshold = 0.0001; }
  21.  
  22.                 var half_win = (win_size-1)*0.5;
  23.                 var win_area = (win_size*win_size)|0;
  24.                 var win_area2 = win_area << 1;
  25.                 var prev_imgs = prev_pyr.data, next_imgs = curr_pyr.data;
  26.                 var img_prev=prev_imgs[0].data,img_next=next_imgs[0].data;
  27.                 var w0 = prev_imgs[0].cols, h0 = prev_imgs[0].rows,lw=0,lh=0;
  28.  
  29.                 var iwin_node = jsfeat.cache.get_buffer(win_area<<2);
  30.                 var deriv_iwin_node = jsfeat.cache.get_buffer(win_area2<<2);
  31.                 var deriv_lev_node = jsfeat.cache.get_buffer((h0*(w0<<1))<<2);
  32.  
  33.                 var deriv_m = new jsfeat.matrix_t(w0, h0, jsfeat.S32C2_t, deriv_lev_node.data);
  34.  
  35.                 var iwin_buf = iwin_node.i32;
  36.                 var deriv_iwin = deriv_iwin_node.i32;
  37.                 var deriv_lev = deriv_lev_node.i32;
  38.  
  39.                 var dstep=0,src=0,dsrc=0,iptr=0,diptr=0,jptr=0;
  40.                 var lev_sc=0.0,prev_x=0.0,prev_y=0.0,next_x=0.0,next_y=0.0;
  41.                 var prev_delta_x=0.0,prev_delta_y=0.0,delta_x=0.0,delta_y=0.0;
  42.                 var iprev_x=0,iprev_y=0,inext_x=0,inext_y=0;
  43.                 var i=0,j=0,x=0,y=0,level=0,ptid=0,iter=0;
  44.                 var brd_tl=0,brd_r=0,brd_b=0;
  45.                 var a=0.0,b=0.0,b1=0.0,b2=0.0;
  46.  
  47.                 // fixed point math
  48.                 var W_BITS14 = 14;
  49.                 var W_BITS4 = 14;
  50.                 var W_BITS1m5 = W_BITS4 - 5;
  51.                 var W_BITS1m51 = (1 << ((W_BITS1m5) - 1));
  52.                 var W_BITS14_ = (1 << W_BITS14);
  53.                 var W_BITS41 = (1 << ((W_BITS4) - 1));
  54.                 var FLT_SCALE = 1.0/(1 << 20);
  55.                 var iw00=0,iw01=0,iw10=0,iw11=0,ival=0,ixval=0,iyval=0;
  56.                 var A11=0.0,A12=0.0,A22=0.0,D=0.0,min_eig=0.0;
  57.  
  58.                 var FLT_EPSILON = 0.00000011920929;
  59.                 eps *= eps;
  60.  
  61.                 // reset status
  62.                 for(; i < count; ++i) {
  63.                     status[i] = 1;
  64.                 }
  65.  
  66.                 var max_level = (prev_pyr.levels - 1)|0;
  67.                 level = max_level;
  68.  
  69.                 for(; level >= 0; --level) {
  70.                     lev_sc = (1.0/(1 << level));
  71.                     lw = w0 >> level;
  72.                     lh = h0 >> level;
  73.                     dstep = lw << 1;
  74.                     img_prev = prev_imgs[level].data;
  75.                     img_next = next_imgs[level].data;
  76.                    
  77.                     brd_r = (lw - win_size)|0;
  78.                     brd_b = (lh - win_size)|0;
  79.  
  80.                     // calculate level derivatives
  81.                     scharr_deriv(prev_imgs[level], deriv_m);
  82.  
  83.                     // iterate through points
  84.                     for(ptid = 0; ptid < count; ++ptid) {
  85.                         i = ptid << 1;
  86.                         j = i + 1;
  87.                         prev_x = prev_xy[i]*lev_sc;
  88.                         prev_y = prev_xy[j]*lev_sc;
  89.  
  90.                         if( level == max_level ) {
  91.                             next_x = prev_x;
  92.                             next_y = prev_y;
  93.                         } else {
  94.                             next_x = curr_xy[i]*2.0;
  95.                             next_y = curr_xy[j]*2.0;
  96.                         }
  97.                         curr_xy[i] = next_x;
  98.                         curr_xy[j] = next_y;
  99.  
  100.                         prev_x -= half_win;
  101.                         prev_y -= half_win;
  102.                         iprev_x = prev_x|0;
  103.                         iprev_y = prev_y|0;
  104.  
  105.                         // border check
  106.                         x = (iprev_x <= brd_tl)|(iprev_x >= brd_r)|(iprev_y <= brd_tl)|(iprev_y >= brd_b);
  107.                         if( x != 0 ) {
  108.                             if( level == 0 ) {
  109.                                 status[ptid] = 0;
  110.                             }
  111.                             continue;
  112.                         }
  113.  
  114.                         a = prev_x - iprev_x;
  115.                         b = prev_y - iprev_y;
  116.                         iw00 = (((1.0 - a)*(1.0 - b)*W_BITS14_) + 0.5)|0;
  117.                         iw01 = ((a*(1.0 - b)*W_BITS14_) + 0.5)|0;
  118.                         iw10 = (((1.0 - a)*b*W_BITS14_) + 0.5)|0;
  119.                         iw11 = (W_BITS14_ - iw00 - iw01 - iw10);
  120.  
  121.                         A11 = 0.0, A12 = 0.0, A22 = 0.0;
  122.  
  123.                         // extract the patch from the first image, compute covariation matrix of derivatives
  124.                         for( y = 0; y < win_size; ++y ) {
  125.                             src = ( (y + iprev_y)*lw + iprev_x )|0;
  126.                             dsrc = src << 1;
  127.  
  128.                             iptr = (y*win_size)|0;
  129.                             diptr = iptr << 1;
  130.                             for(x = 0 ; x < win_size; ++x, ++src, ++iptr, dsrc += 2) {
  131.                                 ival = ( (img_prev[src])*iw00 + (img_prev[src+1])*iw01 +
  132.                                         (img_prev[src+lw])*iw10 + (img_prev[src+lw+1])*iw11 );
  133.                                 ival = (((ival) + W_BITS1m51) >> (W_BITS1m5));
  134.  
  135.                                 ixval = ( deriv_lev[dsrc]*iw00 + deriv_lev[dsrc+2]*iw01 +
  136.                                         deriv_lev[dsrc+dstep]*iw10 + deriv_lev[dsrc+dstep+2]*iw11 );
  137.                                 ixval = (((ixval) + W_BITS41) >> (W_BITS4));
  138.  
  139.                                 iyval = ( deriv_lev[dsrc+1]*iw00 + deriv_lev[dsrc+3]*iw01 + deriv_lev[dsrc+dstep+1]*iw10 +
  140.                                         deriv_lev[dsrc+dstep+3]*iw11 );
  141.                                 iyval = (((iyval) + W_BITS41) >> (W_BITS4));
  142.  
  143.                                 iwin_buf[iptr] = ival;
  144.                                 deriv_iwin[diptr++] = ixval;
  145.                                 deriv_iwin[diptr++] = iyval;
  146.  
  147.                                 A11 += ixval*ixval;
  148.                                 A12 += ixval*iyval;
  149.                                 A22 += iyval*iyval;
  150.                             }
  151.                         }
  152.  
  153.                         A11 *= FLT_SCALE; A12 *= FLT_SCALE; A22 *= FLT_SCALE;
  154.  
  155.                         D = A11*A22 - A12*A12;
  156.                         min_eig = (A22 + A11 - Math.sqrt((A11-A22)*(A11-A22) + 4.0*A12*A12)) / win_area2;
  157.  
  158.                         if( min_eig < min_eigen_threshold || D < FLT_EPSILON )
  159.                         {
  160.                             if( level == 0 ) {
  161.                                 status[ptid] = 0;
  162.                             }
  163.                             continue;
  164.                         }
  165.  
  166.                         D = 1.0/D;
  167.  
  168.                         next_x -= half_win;
  169.                         next_y -= half_win;
  170.                         prev_delta_x = 0.0;
  171.                         prev_delta_y = 0.0;
  172.  
  173.                         for( iter = 0; iter < max_iter; ++iter ) {
  174.                             inext_x = next_x|0;
  175.                             inext_y = next_y|0;
  176.  
  177.                             x = (inext_x <= brd_tl)|(inext_x >= brd_r)|(inext_y <= brd_tl)|(inext_y >= brd_b);
  178.                             if( x != 0 ) {
  179.                                 if( level == 0 ) {
  180.                                     status[ptid] = 0;
  181.                                 }
  182.                                 break;
  183.                             }
  184.  
  185.                             a = next_x - inext_x;
  186.                             b = next_y - inext_y;
  187.                             iw00 = (((1.0 - a)*(1.0 - b)*W_BITS14_) + 0.5)|0;
  188.                             iw01 = ((a*(1.0 - b)*W_BITS14_) + 0.5)|0;
  189.                             iw10 = (((1.0 - a)*b*W_BITS14_) + 0.5)|0;
  190.                             iw11 = (W_BITS14_ - iw00 - iw01 - iw10);
  191.                             b1 = 0.0, b2 = 0.0;
  192.  
  193.                             for( y = 0; y < win_size; ++y ) {
  194.                                 jptr = ( (y + inext_y)*lw + inext_x )|0;
  195.  
  196.                                 iptr = (y*win_size)|0;
  197.                                 diptr = iptr << 1;
  198.                                 for( x = 0 ; x < win_size; ++x, ++jptr, ++iptr ) {
  199.                                     ival = ( (img_next[jptr])*iw00 + (img_next[jptr+1])*iw01 +
  200.                                             (img_next[jptr+lw])*iw10 + (img_next[jptr+lw+1])*iw11 );
  201.                                     ival = (((ival) + W_BITS1m51) >> (W_BITS1m5));
  202.                                     ival = (ival - iwin_buf[iptr]);
  203.  
  204.                                     b1 += ival * deriv_iwin[diptr++];
  205.                                     b2 += ival * deriv_iwin[diptr++];
  206.                                 }
  207.                             }
  208.  
  209.                             b1 *= FLT_SCALE;
  210.                             b2 *= FLT_SCALE;
  211.  
  212.                             delta_x = ((A12*b2 - A22*b1) * D);
  213.                             delta_y = ((A12*b1 - A11*b2) * D);
  214.  
  215.                             next_x += delta_x;
  216.                             next_y += delta_y;
  217.                             curr_xy[i] = next_x + half_win;
  218.                             curr_xy[j] = next_y + half_win;
  219.  
  220.                             if( delta_x*delta_x + delta_y*delta_y <= eps ) {
  221.                                 break;
  222.                             }
  223.  
  224.                             if( iter > 0 && Math.abs(delta_x + prev_delta_x) < 0.01 &&
  225.                                             Math.abs(delta_y + prev_delta_y) < 0.01 ) {
  226.                                 curr_xy[i] -= delta_x*0.5;
  227.                                 curr_xy[j] -= delta_y*0.5;
  228.                                 break;
  229.                             }
  230.  
  231.                             prev_delta_x = delta_x;
  232.                             prev_delta_y = delta_y;
  233.                         }
  234.                     } // points loop
  235.                 } // levels loop
  236.  
  237.                 jsfeat.cache.put_buffer(iwin_node);
  238.                 jsfeat.cache.put_buffer(deriv_iwin_node);
  239.                 jsfeat.cache.put_buffer(deriv_lev_node);
  240.             }
  241.         };
  242.     })();
  243.  
  244.     global.optical_flow_lk = optical_flow_lk;
  245.  
  246. })(jsfeat);
  247.  
downloadjsfeat_optical_flow_lk.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