BVB Source Codes

jsfeat Show jsfeat_yape.js Source code

Return Download jsfeat: download jsfeat_yape.js Source code - Download jsfeat Source code - Type:.js
  1. /**
  2.  * @author Eugene Zatepyakin / http://inspirit.ru/
  3.  *
  4.  * Copyright 2007 Computer Vision Lab,
  5.  * Ecole Polytechnique Federale de Lausanne (EPFL), Switzerland.
  6.  */
  7.  
  8. (function(global) {
  9.     "use strict";
  10.     //
  11.  
  12.     var yape = (function() {
  13.  
  14.         var precompute_directions = function(step, dirs, R) {
  15.             var i = 0;
  16.             var x, y;
  17.  
  18.             x = R;
  19.             for(y = 0; y < x; y++, i++)
  20.             {
  21.                 x = (Math.sqrt((R * R - y * y)) + 0.5)|0;
  22.                 dirs[i] = (x + step * y);
  23.             }
  24.             for(x-- ; x < y && x >= 0; x--, i++)
  25.             {
  26.                 y = (Math.sqrt((R * R - x * x)) + 0.5)|0;
  27.                 dirs[i] = (x + step * y);
  28.             }
  29.             for( ; -x < y; x--, i++)
  30.             {
  31.                 y = (Math.sqrt((R * R - x * x)) + 0.5)|0;
  32.                 dirs[i] = (x + step * y);
  33.             }
  34.             for(y-- ; y >= 0; y--, i++)
  35.             {
  36.                 x = (-Math.sqrt((R * R - y * y)) - 0.5)|0;
  37.                 dirs[i] = (x + step * y);
  38.             }
  39.             for(; y > x; y--, i++)
  40.             {
  41.                 x = (-Math.sqrt((R * R - y * y)) - 0.5)|0;
  42.                 dirs[i] = (x + step * y);
  43.             }
  44.             for(x++ ; x <= 0; x++, i++)
  45.             {
  46.                 y = (-Math.sqrt((R * R - x * x)) - 0.5)|0;
  47.                 dirs[i] = (x + step * y);
  48.             }
  49.             for( ; x < -y; x++, i++)
  50.             {
  51.                 y = (-Math.sqrt((R * R - x * x)) - 0.5)|0;
  52.                 dirs[i] = (x + step * y);
  53.             }
  54.             for(y++ ; y < 0; y++, i++)
  55.             {
  56.                 x = (Math.sqrt((R * R - y * y)) + 0.5)|0;
  57.                 dirs[i] = (x + step * y);
  58.             }
  59.  
  60.             dirs[i] = dirs[0];
  61.             dirs[i + 1] = dirs[1];
  62.             return i;
  63.         }
  64.  
  65.         var third_check = function (Sb, off, step) {
  66.             var n = 0;
  67.             if(Sb[off+1]   != 0) n++;
  68.             if(Sb[off-1]   != 0) n++;
  69.             if(Sb[off+step]   != 0) n++;
  70.             if(Sb[off+step+1] != 0) n++;
  71.             if(Sb[off+step-1] != 0) n++;
  72.             if(Sb[off-step]   != 0) n++;
  73.             if(Sb[off-step+1] != 0) n++;
  74.             if(Sb[off-step-1] != 0) n++;
  75.  
  76.             return n;
  77.         }
  78.  
  79.         var is_local_maxima = function(p, off, v, step, neighborhood) {
  80.             var x, y;
  81.  
  82.             if (v > 0) {
  83.                 off -= step*neighborhood;
  84.                 for (y= -neighborhood; y<=neighborhood; ++y) {
  85.                     for (x= -neighborhood; x<=neighborhood; ++x) {
  86.                         if (p[off+x] > v) return false;
  87.                     }
  88.                     off += step;
  89.                 }
  90.             } else {
  91.                 off -= step*neighborhood;
  92.                 for (y= -neighborhood; y<=neighborhood; ++y) {
  93.                     for (x= -neighborhood; x<=neighborhood; ++x) {
  94.                         if (p[off+x] < v) return false;
  95.                     }
  96.                     off += step;
  97.                 }
  98.             }
  99.             return true;
  100.         }
  101.  
  102.         var perform_one_point = function(I, x, Scores, Im, Ip, dirs, opposite, dirs_nb) {
  103.           var score = 0;
  104.           var a = 0, b = (opposite - 1)|0;
  105.           var A=0, B0=0, B1=0, B2=0;
  106.           var state=0;
  107.  
  108.           // WE KNOW THAT NOT(A ~ I0 & B1 ~ I0):
  109.           A = I[x+dirs[a]];
  110.           if ((A <= Ip)) {
  111.             if ((A >= Im)) { // A ~ I0
  112.               B0 = I[x+dirs[b]];
  113.               if ((B0 <= Ip)) {
  114.                 if ((B0 >= Im)) { Scores[x] = 0; return; }
  115.                 else {
  116.                   b++; B1 = I[x+dirs[b]];
  117.                   if ((B1 > Ip)) {
  118.                     b++; B2 = I[x+dirs[b]];
  119.                     if ((B2 > Ip)) state = 3;
  120.                     else if ((B2 < Im)) state = 6;
  121.                     else { Scores[x] = 0; return; } // A ~ I0, B2 ~ I0
  122.                   }
  123.                   else/* if ((B1 < Im))*/ {
  124.                     b++; B2 = I[x+dirs[b]];
  125.                     if ((B2 > Ip)) state = 7;
  126.                     else if ((B2 < Im)) state = 2;
  127.                     else { Scores[x] = 0; return; } // A ~ I0, B2 ~ I0
  128.                   }
  129.                   //else { Scores[x] = 0; return; } // A ~ I0, B1 ~ I0
  130.                 }
  131.               }
  132.               else { // B0 < I0
  133.                 b++; B1 = I[x+dirs[b]];
  134.                 if ((B1 > Ip)) {
  135.                   b++; B2 = I[x+dirs[b]];
  136.                   if ((B2 > Ip)) state = 3;
  137.                   else if ((B2 < Im)) state = 6;
  138.                   else { Scores[x] = 0; return; } // A ~ I0, B2 ~ I0
  139.                 }
  140.                 else if ((B1 < Im)) {
  141.                   b++; B2 = I[x+dirs[b]];
  142.                   if ((B2 > Ip)) state = 7;
  143.                   else if ((B2 < Im)) state = 2;
  144.                   else { Scores[x] = 0; return; } // A ~ I0, B2 ~ I0
  145.                 }
  146.                 else { Scores[x] = 0; return; } // A ~ I0, B1 ~ I0
  147.               }
  148.             }
  149.             else { // A > I0
  150.               B0 = I[x+dirs[b]];
  151.               if ((B0 > Ip)) { Scores[x] = 0; return; }
  152.                 b++; B1 = I[x+dirs[b]];
  153.               if ((B1 > Ip)) { Scores[x] = 0; return; }
  154.                 b++; B2 = I[x+dirs[b]];
  155.               if ((B2 > Ip)) { Scores[x] = 0; return; }
  156.                 state = 1;
  157.             }
  158.           }
  159.           else // A < I0
  160.           {
  161.             B0 = I[x+dirs[b]];
  162.             if ((B0 < Im)) { Scores[x] = 0; return; }
  163.               b++; B1 = I[x+dirs[b]];
  164.             if ((B1 < Im)) { Scores[x] = 0; return; }
  165.               b++; B2 = I[x+dirs[b]];
  166.             if ((B2 < Im)) { Scores[x] = 0; return; }
  167.               state = 0;
  168.           }
  169.  
  170.           for(a = 1; a <= opposite; a++)
  171.           {
  172.             A = I[x+dirs[a]];
  173.  
  174.             switch(state)
  175.             {
  176.             case 0:
  177.               if ((A > Ip)) {
  178.                 B1 = B2; b++; B2 = I[x+dirs[b]];
  179.                 if ((B2 < Im)) { Scores[x] = 0; return; }
  180.                   { score -= A + B1; state = 0; break; };
  181.               }
  182.               if ((A < Im)) {
  183.                 if ((B1 > Ip)) { Scores[x] = 0; return; }
  184.                   if ((B2 > Ip)) { Scores[x] = 0; return; }
  185.                     B1 = B2; b++; B2 = I[x+dirs[b]];
  186.                 if ((B2 > Ip)) { Scores[x] = 0; return; }
  187.                   { score -= A + B1; state = 8; break; };
  188.               }
  189.               // A ~ I0
  190.               if ((B1 <= Ip)) { Scores[x] = 0; return; }
  191.                 if ((B2 <= Ip)) { Scores[x] = 0; return; }
  192.                   B1 = B2; b++; B2 = I[x+dirs[b]];
  193.               if ((B2 > Ip)) { score -= A + B1; state = 3; break; };
  194.               if ((B2 < Im)) { score -= A + B1; state = 6; break; };
  195.               { Scores[x] = 0; return; }
  196.  
  197.             case 1:
  198.               if ((A < Im)) {
  199.                 B1 = B2; b++; B2 = I[x+dirs[b]];
  200.                 if ((B2 > Ip)) { Scores[x] = 0; return; }
  201.                   { score -= A + B1; state = 1; break; };
  202.               }
  203.               if ((A > Ip)) {
  204.                 if ((B1 < Im)) { Scores[x] = 0; return; }
  205.                   if ((B2 < Im)) { Scores[x] = 0; return; }
  206.                     B1 = B2; b++; B2 = I[x+dirs[b]];
  207.                 if ((B2 < Im)) { Scores[x] = 0; return; }
  208.                   { score -= A + B1; state = 9; break; };
  209.               }
  210.               // A ~ I0
  211.               if ((B1 >= Im)) { Scores[x] = 0; return; }
  212.                 if ((B2 >= Im)) { Scores[x] = 0; return; }
  213.                   B1 = B2; b++; B2 = I[x+dirs[b]];
  214.               if ((B2 < Im)) { score -= A + B1; state = 2; break; };
  215.               if ((B2 > Ip)) { score -= A + B1; state = 7; break; };
  216.               { Scores[x] = 0; return; }
  217.  
  218.             case 2:
  219.               if ((A > Ip)) { Scores[x] = 0; return; }
  220.                 B1 = B2; b++; B2 = I[x+dirs[b]];
  221.               if ((A < Im))
  222.               {
  223.                 if ((B2 > Ip)) { Scores[x] = 0; return; }
  224.                   { score -= A + B1; state = 4; break; };
  225.               }
  226.               // A ~ I0
  227.               if ((B2 > Ip)) { score -= A + B1; state = 7; break; };
  228.               if ((B2 < Im)) { score -= A + B1; state = 2; break; };
  229.               { Scores[x] = 0; return; } // A ~ I0, B2 ~ I0
  230.  
  231.             case 3:
  232.               if ((A < Im)) { Scores[x] = 0; return; }
  233.                 B1 = B2; b++; B2 = I[x+dirs[b]];
  234.               if ((A > Ip)) {
  235.                 if ((B2 < Im)) { Scores[x] = 0; return; }
  236.                   { score -= A + B1; state = 5; break; };
  237.               }
  238.               // A ~ I0
  239.               if ((B2 > Ip)) { score -= A + B1; state = 3; break; };
  240.               if ((B2 < Im)) { score -= A + B1; state = 6; break; };
  241.               { Scores[x] = 0; return; }
  242.  
  243.             case 4:
  244.               if ((A > Ip)) { Scores[x] = 0; return; }
  245.                 if ((A < Im)) {
  246.                   B1 = B2; b++; B2 = I[x+dirs[b]];
  247.                   if ((B2 > Ip)) { Scores[x] = 0; return; }
  248.                     { score -= A + B1; state = 1; break; };
  249.                 }
  250.                 if ((B2 >= Im)) { Scores[x] = 0; return; }
  251.                   B1 = B2; b++; B2 = I[x+dirs[b]];
  252.                 if ((B2 < Im)) { score -= A + B1; state = 2; break; };
  253.                 if ((B2 > Ip)) { score -= A + B1; state = 7; break; };
  254.                 { Scores[x] = 0; return; }
  255.  
  256.             case 5:
  257.               if ((A < Im)) { Scores[x] = 0; return; }
  258.                 if ((A > Ip)) {
  259.                   B1 = B2; b++; B2 = I[x+dirs[b]];
  260.                   if ((B2 < Im)) { Scores[x] = 0; return; }
  261.                     { score -= A + B1; state = 0; break; };
  262.                 }
  263.                 // A ~ I0
  264.                 if ((B2 <= Ip)) { Scores[x] = 0; return; }
  265.                   B1 = B2; b++; B2 = I[x+dirs[b]];
  266.                 if ((B2 > Ip)) { score -= A + B1; state = 3; break; };
  267.                 if ((B2 < Im)) { score -= A + B1; state = 6; break; };
  268.                 { Scores[x] = 0; return; }
  269.  
  270.             case 7:
  271.               if ((A > Ip)) { Scores[x] = 0; return; }
  272.                 if ((A < Im)) { Scores[x] = 0; return; }
  273.                   B1 = B2; b++; B2 = I[x+dirs[b]];
  274.               // A ~ I0
  275.               if ((B2 > Ip)) { score -= A + B1; state = 3; break; };
  276.               if ((B2 < Im)) { score -= A + B1; state = 6; break; };
  277.               { Scores[x] = 0; return; } // A ~ I0, B2 ~ I0
  278.  
  279.             case 6:
  280.               if ((A > Ip)) { Scores[x] = 0; return; }
  281.                 if ((A < Im)) { Scores[x] = 0; return; }
  282.                   B1 = B2; b++; B2 = I[x+dirs[b]];
  283.               // A ~ I0
  284.               if ((B2 < Im)) { score -= A + B1; state = 2; break; };
  285.               if ((B2 > Ip)) { score -= A + B1; state = 7; break; };
  286.               { Scores[x] = 0; return; } // A ~ I0, B2 ~ I0
  287.  
  288.             case 8:
  289.               if ((A > Ip)) {
  290.                 if ((B2 < Im)) { Scores[x] = 0; return; }
  291.                   B1 = B2; b++; B2 = I[x+dirs[b]];
  292.                 if ((B2 < Im)) { Scores[x] = 0; return; }
  293.                   { score -= A + B1; state = 9; break; };
  294.               }
  295.               if ((A < Im)) {
  296.                 B1 = B2; b++; B2 = I[x+dirs[b]];
  297.                 if ((B2 > Ip)) { Scores[x] = 0; return; }
  298.                   { score -= A + B1; state = 1; break; };
  299.               }
  300.               { Scores[x] = 0; return; }
  301.  
  302.             case 9:
  303.               if ((A < Im)) {
  304.                 if ((B2 > Ip)) { Scores[x] = 0; return; }
  305.                   B1 = B2; b++; B2 = I[x+dirs[b]];
  306.                 if ((B2 > Ip)) { Scores[x] = 0; return; }
  307.                   { score -= A + B1; state = 8; break; };
  308.               }
  309.               if ((A > Ip)) {
  310.                 B1 = B2; b++; B2 = I[x+dirs[b]];
  311.                 if ((B2 < Im)) { Scores[x] = 0; return; }
  312.                   { score -= A + B1; state = 0; break; };
  313.               }
  314.               { Scores[x] = 0; return; }
  315.  
  316.             default:
  317.               //"PB default";
  318.               break;
  319.             } // switch(state)
  320.           } // for(a...)
  321.  
  322.           Scores[x] = (score + dirs_nb * I[x]);
  323.         }
  324.  
  325.         var lev_table_t = (function () {
  326.             function lev_table_t(w, h, r) {
  327.                 this.dirs = new Int32Array(1024);
  328.                 this.dirs_count = precompute_directions(w, this.dirs, r)|0;
  329.                 this.scores = new Int32Array(w*h);
  330.                 this.radius = r|0;
  331.             }
  332.             return lev_table_t;
  333.         })();
  334.        
  335.         return {
  336.  
  337.             level_tables: [],
  338.             tau: 7,
  339.  
  340.             init: function(width, height, radius, pyramid_levels) {
  341.                 if (typeof pyramid_levels === "undefined") { pyramid_levels = 1; }
  342.                 var i;
  343.                 radius = Math.min(radius, 7);
  344.                 radius = Math.max(radius, 3);
  345.                 for(i = 0; i < pyramid_levels; ++i) {
  346.                     this.level_tables[i] = new lev_table_t(width>>i, height>>i, radius);
  347.                 }
  348.             },
  349.  
  350.             detect: function(src, points, border) {
  351.                 if (typeof border === "undefined") { border = 4; }
  352.                 var t = this.level_tables[0];
  353.                 var R = t.radius|0, Rm1 = (R-1)|0;
  354.                 var dirs = t.dirs;
  355.                 var dirs_count = t.dirs_count|0;
  356.                 var opposite = dirs_count >> 1;
  357.                 var img = src.data, w=src.cols|0, h=src.rows|0,hw=w>>1;
  358.                 var scores = t.scores;
  359.                 var x=0,y=0,row=0,rowx=0,ip=0,im=0,abs_score=0, score=0;
  360.                 var tau = this.tau|0;
  361.                 var number_of_points = 0, pt;
  362.  
  363.                 var sx = Math.max(R+1, border)|0;
  364.                 var sy = Math.max(R+1, border)|0;
  365.                 var ex = Math.min(w-R-2, w-border)|0;
  366.                 var ey = Math.min(h-R-2, h-border)|0;
  367.  
  368.                 row = (sy*w+sx)|0;
  369.                 for(y = sy; y < ey; ++y, row+=w) {
  370.                     for(x = sx, rowx = row; x < ex; ++x, ++rowx) {
  371.                         ip = img[rowx] + tau, im = img[rowx] - tau;
  372.  
  373.                         if (im<img[rowx+R] && img[rowx+R]<ip && im<img[rowx-R] && img[rowx-R]<ip) {
  374.                             scores[rowx] = 0;
  375.                         } else {
  376.                             perform_one_point(img, rowx, scores, im, ip, dirs, opposite, dirs_count);
  377.                         }
  378.                     }
  379.                 }
  380.  
  381.                 // local maxima
  382.                 row = (sy*w+sx)|0;
  383.                 for(y = sy; y < ey; ++y, row+=w) {
  384.                     for(x = sx, rowx = row; x < ex; ++x, ++rowx) {
  385.                         score = scores[rowx];
  386.                         abs_score = Math.abs(score);
  387.                         if(abs_score < 5) {
  388.                             // if this pixel is 0, the next one will not be good enough. Skip it.
  389.                             ++x, ++rowx;
  390.                         } else {
  391.                             if(third_check(scores, rowx, w) >= 3 && is_local_maxima(scores, rowx, score, hw, R)) {
  392.                                 pt = points[number_of_points];
  393.                                 pt.x = x, pt.y = y, pt.score = abs_score;
  394.                                 ++number_of_points;
  395.  
  396.                                 x += Rm1, rowx += Rm1;
  397.                             }
  398.                         }
  399.                     }
  400.                 }
  401.  
  402.                 return number_of_points;
  403.             }
  404.         };
  405.  
  406.     })();
  407.  
  408.     global.yape = yape;
  409.  
  410. })(jsfeat);
downloadjsfeat_yape.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