BVB Source Codes

jsfeat Show jsfeat_math.js Source code

Return Download jsfeat: download jsfeat_math.js Source code - Download jsfeat Source code - Type:.js
  1. /**
  2.  * @author Eugene Zatepyakin / http://inspirit.ru/
  3.  */
  4.  
  5. (function(global) {
  6.     "use strict";
  7.     //
  8.  
  9.     var math = (function() {
  10.  
  11.         var qsort_stack = new Int32Array(48*2);
  12.  
  13.         return {
  14.             get_gaussian_kernel: function(size, sigma, kernel, data_type) {
  15.                 var i=0,x=0.0,t=0.0,sigma_x=0.0,scale_2x=0.0;
  16.                 var sum = 0.0;
  17.                 var kern_node = jsfeat.cache.get_buffer(size<<2);
  18.                 var _kernel = kern_node.f32;//new Float32Array(size);
  19.  
  20.                 if((size&1) == 1 && size <= 7 && sigma <= 0) {
  21.                     switch(size>>1) {
  22.                         case 0:
  23.                         _kernel[0] = 1.0;
  24.                         sum = 1.0;
  25.                         break;
  26.                         case 1:
  27.                         _kernel[0] = 0.25, _kernel[1] = 0.5, _kernel[2] = 0.25;
  28.                         sum = 0.25+0.5+0.25;
  29.                         break;
  30.                         case 2:
  31.                         _kernel[0] = 0.0625, _kernel[1] = 0.25, _kernel[2] = 0.375,
  32.                         _kernel[3] = 0.25, _kernel[4] = 0.0625;
  33.                         sum = 0.0625+0.25+0.375+0.25+0.0625;
  34.                         break;
  35.                         case 3:
  36.                         _kernel[0] = 0.03125, _kernel[1] = 0.109375, _kernel[2] = 0.21875,
  37.                         _kernel[3] = 0.28125, _kernel[4] = 0.21875, _kernel[5] = 0.109375, _kernel[6] = 0.03125;
  38.                         sum = 0.03125+0.109375+0.21875+0.28125+0.21875+0.109375+0.03125;
  39.                         break;
  40.                     }
  41.                 } else {
  42.                     sigma_x = sigma > 0 ? sigma : ((size-1)*0.5 - 1.0)*0.3 + 0.8;
  43.                     scale_2x = -0.5/(sigma_x*sigma_x);
  44.  
  45.                     for( ; i < size; ++i )
  46.                     {
  47.                         x = i - (size-1)*0.5;
  48.                         t = Math.exp(scale_2x*x*x);
  49.  
  50.                         _kernel[i] = t;
  51.                         sum += t;
  52.                     }
  53.                 }
  54.  
  55.                 if(data_type & jsfeat.U8_t) {
  56.                     // int based kernel
  57.                     sum = 256.0/sum;
  58.                     for (i = 0; i < size; ++i) {
  59.                         kernel[i] = (_kernel[i] * sum + 0.5)|0;
  60.                     }
  61.                 } else {
  62.                     // classic kernel
  63.                     sum = 1.0/sum;
  64.                     for (i = 0; i < size; ++i) {
  65.                         kernel[i] = _kernel[i] * sum;
  66.                     }
  67.                 }
  68.  
  69.                 jsfeat.cache.put_buffer(kern_node);
  70.             },
  71.  
  72.             // model is 3x3 matrix_t
  73.             perspective_4point_transform: function(model, src_x0, src_y0, dst_x0, dst_y0,
  74.                                                         src_x1, src_y1, dst_x1, dst_y1,
  75.                                                         src_x2, src_y2, dst_x2, dst_y2,
  76.                                                         src_x3, src_y3, dst_x3, dst_y3) {
  77.                 var t1 = src_x0;
  78.                 var t2 = src_x2;
  79.                 var t4 = src_y1;
  80.                 var t5 = t1 * t2 * t4;
  81.                 var t6 = src_y3;
  82.                 var t7 = t1 * t6;
  83.                 var t8 = t2 * t7;
  84.                 var t9 = src_y2;
  85.                 var t10 = t1 * t9;
  86.                 var t11 = src_x1;
  87.                 var t14 = src_y0;
  88.                 var t15 = src_x3;
  89.                 var t16 = t14 * t15;
  90.                 var t18 = t16 * t11;
  91.                 var t20 = t15 * t11 * t9;
  92.                 var t21 = t15 * t4;
  93.                 var t24 = t15 * t9;
  94.                 var t25 = t2 * t4;
  95.                 var t26 = t6 * t2;
  96.                 var t27 = t6 * t11;
  97.                 var t28 = t9 * t11;
  98.                 var t30 = 1.0 / (t21-t24 - t25 + t26 - t27 + t28);
  99.                 var t32 = t1 * t15;
  100.                 var t35 = t14 * t11;
  101.                 var t41 = t4 * t1;
  102.                 var t42 = t6 * t41;
  103.                 var t43 = t14 * t2;
  104.                 var t46 = t16 * t9;
  105.                 var t48 = t14 * t9 * t11;
  106.                 var t51 = t4 * t6 * t2;
  107.                 var t55 = t6 * t14;
  108.                 var Hr0 = -(t8-t5 + t10 * t11 - t11 * t7 - t16 * t2 + t18 - t20 + t21 * t2) * t30;
  109.                 var Hr1 = (t5 - t8 - t32 * t4 + t32 * t9 + t18 - t2 * t35 + t27 * t2 - t20) * t30;
  110.                 var Hr2 = t1;
  111.                 var Hr3 = (-t9 * t7 + t42 + t43 * t4 - t16 * t4 + t46 - t48 + t27 * t9 - t51) * t30;
  112.                 var Hr4 = (-t42 + t41 * t9 - t55 * t2 + t46 - t48 + t55 * t11 + t51 - t21 * t9) * t30;
  113.                 var Hr5 = t14;
  114.                 var Hr6 = (-t10 + t41 + t43 - t35 + t24 - t21 - t26 + t27) * t30;
  115.                 var Hr7 = (-t7 + t10 + t16 - t43 + t27 - t28 - t21 + t25) * t30;
  116.                
  117.                 t1 = dst_x0;
  118.                 t2 = dst_x2;
  119.                 t4 = dst_y1;
  120.                 t5 = t1 * t2 * t4;
  121.                 t6 = dst_y3;
  122.                 t7 = t1 * t6;
  123.                 t8 = t2 * t7;
  124.                 t9 = dst_y2;
  125.                 t10 = t1 * t9;
  126.                 t11 = dst_x1;
  127.                 t14 = dst_y0;
  128.                 t15 = dst_x3;
  129.                 t16 = t14 * t15;
  130.                 t18 = t16 * t11;
  131.                 t20 = t15 * t11 * t9;
  132.                 t21 = t15 * t4;
  133.                 t24 = t15 * t9;
  134.                 t25 = t2 * t4;
  135.                 t26 = t6 * t2;
  136.                 t27 = t6 * t11;
  137.                 t28 = t9 * t11;
  138.                 t30 = 1.0 / (t21-t24 - t25 + t26 - t27 + t28);
  139.                 t32 = t1 * t15;
  140.                 t35 = t14 * t11;
  141.                 t41 = t4 * t1;
  142.                 t42 = t6 * t41;
  143.                 t43 = t14 * t2;
  144.                 t46 = t16 * t9;
  145.                 t48 = t14 * t9 * t11;
  146.                 t51 = t4 * t6 * t2;
  147.                 t55 = t6 * t14;
  148.                 var Hl0 = -(t8-t5 + t10 * t11 - t11 * t7 - t16 * t2 + t18 - t20 + t21 * t2) * t30;
  149.                 var Hl1 = (t5 - t8 - t32 * t4 + t32 * t9 + t18 - t2 * t35 + t27 * t2 - t20) * t30;
  150.                 var Hl2 = t1;
  151.                 var Hl3 = (-t9 * t7 + t42 + t43 * t4 - t16 * t4 + t46 - t48 + t27 * t9 - t51) * t30;
  152.                 var Hl4 = (-t42 + t41 * t9 - t55 * t2 + t46 - t48 + t55 * t11 + t51 - t21 * t9) * t30;
  153.                 var Hl5 = t14;
  154.                 var Hl6 = (-t10 + t41 + t43 - t35 + t24 - t21 - t26 + t27) * t30;
  155.                 var Hl7 = (-t7 + t10 + t16 - t43 + t27 - t28 - t21 + t25) * t30;
  156.  
  157.                 // the following code computes R = Hl * inverse Hr
  158.                 t2 = Hr4-Hr7*Hr5;
  159.                 t4 = Hr0*Hr4;
  160.                 t5 = Hr0*Hr5;
  161.                 t7 = Hr3*Hr1;
  162.                 t8 = Hr2*Hr3;
  163.                 t10 = Hr1*Hr6;
  164.                 var t12 = Hr2*Hr6;
  165.                 t15 = 1.0 / (t4-t5*Hr7-t7+t8*Hr7+t10*Hr5-t12*Hr4);
  166.                 t18 = -Hr3+Hr5*Hr6;
  167.                 var t23 = -Hr3*Hr7+Hr4*Hr6;
  168.                 t28 = -Hr1+Hr2*Hr7;
  169.                 var t31 = Hr0-t12;
  170.                 t35 = Hr0*Hr7-t10;
  171.                 t41 = -Hr1*Hr5+Hr2*Hr4;
  172.                 var t44 = t5-t8;
  173.                 var t47 = t4-t7;
  174.                 t48 = t2*t15;
  175.                 var t49 = t28*t15;
  176.                 var t50 = t41*t15;
  177.                 var mat = model.data;
  178.                 mat[0] = Hl0*t48+Hl1*(t18*t15)-Hl2*(t23*t15);
  179.                 mat[1] = Hl0*t49+Hl1*(t31*t15)-Hl2*(t35*t15);
  180.                 mat[2] = -Hl0*t50-Hl1*(t44*t15)+Hl2*(t47*t15);
  181.                 mat[3] = Hl3*t48+Hl4*(t18*t15)-Hl5*(t23*t15);
  182.                 mat[4] = Hl3*t49+Hl4*(t31*t15)-Hl5*(t35*t15);
  183.                 mat[5] = -Hl3*t50-Hl4*(t44*t15)+Hl5*(t47*t15);
  184.                 mat[6] = Hl6*t48+Hl7*(t18*t15)-t23*t15;
  185.                 mat[7] = Hl6*t49+Hl7*(t31*t15)-t35*t15;
  186.                 mat[8] = -Hl6*t50-Hl7*(t44*t15)+t47*t15;
  187.             },
  188.  
  189.             // The current implementation was derived from *BSD system qsort():
  190.             // Copyright (c) 1992, 1993
  191.             // The Regents of the University of California.  All rights reserved.
  192.             qsort: function(array, low, high, cmp) {
  193.                 var isort_thresh = 7;
  194.                 var t,ta,tb,tc;
  195.                 var sp = 0,left=0,right=0,i=0,n=0,m=0,ptr=0,ptr2=0,d=0;
  196.                 var left0=0,left1=0,right0=0,right1=0,pivot=0,a=0,b=0,c=0,swap_cnt=0;
  197.  
  198.                 var stack = qsort_stack;
  199.  
  200.                 if( (high-low+1) <= 1 ) return;
  201.  
  202.                 stack[0] = low;
  203.                 stack[1] = high;
  204.  
  205.                 while( sp >= 0 ) {
  206.                
  207.                     left = stack[sp<<1];
  208.                     right = stack[(sp<<1)+1];
  209.                     sp--;
  210.  
  211.                     for(;;) {
  212.                         n = (right - left) + 1;
  213.  
  214.                         if( n <= isort_thresh ) {
  215.                         //insert_sort:
  216.                             for( ptr = left + 1; ptr <= right; ptr++ ) {
  217.                                 for( ptr2 = ptr; ptr2 > left && cmp(array[ptr2],array[ptr2-1]); ptr2--) {
  218.                                     t = array[ptr2];
  219.                                     array[ptr2] = array[ptr2-1];
  220.                                     array[ptr2-1] = t;
  221.                                 }
  222.                             }
  223.                             break;
  224.                         } else {
  225.                             swap_cnt = 0;
  226.  
  227.                             left0 = left;
  228.                             right0 = right;
  229.                             pivot = left + (n>>1);
  230.  
  231.                             if( n > 40 ) {
  232.                                 d = n >> 3;
  233.                                 a = left, b = left + d, c = left + (d<<1);
  234.                                 ta = array[a],tb = array[b],tc = array[c];
  235.                                 left = cmp(ta, tb) ? (cmp(tb, tc) ? b : (cmp(ta, tc) ? c : a))
  236.                                                   : (cmp(tc, tb) ? b : (cmp(ta, tc) ? a : c));
  237.  
  238.                                 a = pivot - d, b = pivot, c = pivot + d;
  239.                                 ta = array[a],tb = array[b],tc = array[c];
  240.                                 pivot = cmp(ta, tb) ? (cmp(tb, tc) ? b : (cmp(ta, tc) ? c : a))
  241.                                                   : (cmp(tc, tb) ? b : (cmp(ta, tc) ? a : c));
  242.  
  243.                                 a = right - (d<<1), b = right - d, c = right;
  244.                                 ta = array[a],tb = array[b],tc = array[c];
  245.                                 right = cmp(ta, tb) ? (cmp(tb, tc) ? b : (cmp(ta, tc) ? c : a))
  246.                                                   : (cmp(tc, tb) ? b : (cmp(ta, tc) ? a : c));
  247.                             }
  248.  
  249.                             a = left, b = pivot, c = right;
  250.                             ta = array[a],tb = array[b],tc = array[c];
  251.                             pivot = cmp(ta, tb) ? (cmp(tb, tc) ? b : (cmp(ta, tc) ? c : a))  
  252.                                                : (cmp(tc, tb) ? b : (cmp(ta, tc) ? a : c));
  253.                             if( pivot != left0 ) {
  254.                                 t = array[pivot];
  255.                                 array[pivot] = array[left0];
  256.                                 array[left0] = t;
  257.                                 pivot = left0;
  258.                             }
  259.                             left = left1 = left0 + 1;
  260.                             right = right1 = right0;
  261.  
  262.                             ta = array[pivot];
  263.                             for(;;) {
  264.                                 while( left <= right && !cmp(ta, array[left]) ) {
  265.                                     if( !cmp(array[left], ta) ) {
  266.                                         if( left > left1 ) {
  267.                                             t = array[left1];
  268.                                             array[left1] = array[left];
  269.                                             array[left] = t;
  270.                                         }
  271.                                         swap_cnt = 1;
  272.                                         left1++;
  273.                                     }
  274.                                     left++;
  275.                                 }
  276.  
  277.                                 while( left <= right && !cmp(array[right], ta) ) {
  278.                                     if( !cmp(ta, array[right]) ) {
  279.                                         if( right < right1 ) {
  280.                                             t = array[right1];
  281.                                             array[right1] = array[right];
  282.                                             array[right] = t;
  283.                                         }
  284.                                         swap_cnt = 1;
  285.                                         right1--;
  286.                                     }
  287.                                     right--;
  288.                                 }
  289.  
  290.                                 if( left > right ) break;
  291.                                
  292.                                 t = array[left];
  293.                                 array[left] = array[right];
  294.                                 array[right] = t;
  295.                                 swap_cnt = 1;
  296.                                 left++;
  297.                                 right--;
  298.                             }
  299.  
  300.                             if( swap_cnt == 0 ) {
  301.                                 left = left0, right = right0;
  302.                                 //goto insert_sort;
  303.                                 for( ptr = left + 1; ptr <= right; ptr++ ) {
  304.                                     for( ptr2 = ptr; ptr2 > left && cmp(array[ptr2],array[ptr2-1]); ptr2--) {
  305.                                         t = array[ptr2];
  306.                                         array[ptr2] = array[ptr2-1];
  307.                                         array[ptr2-1] = t;
  308.                                     }
  309.                                 }
  310.                                 break;
  311.                             }
  312.  
  313.                             n = Math.min( (left1 - left0), (left - left1) );
  314.                             m = (left-n)|0;
  315.                             for( i = 0; i < n; ++i,++m ) {
  316.                                 t = array[left0+i];
  317.                                 array[left0+i] = array[m];
  318.                                 array[m] = t;
  319.                             }
  320.  
  321.                             n = Math.min( (right0 - right1), (right1 - right) );
  322.                             m = (right0-n+1)|0;
  323.                             for( i = 0; i < n; ++i,++m ) {
  324.                                 t = array[left+i];
  325.                                 array[left+i] = array[m];
  326.                                 array[m] = t;
  327.                             }
  328.                             n = (left - left1);
  329.                             m = (right1 - right);
  330.                             if( n > 1 ) {
  331.                                 if( m > 1 ) {
  332.                                     if( n > m ) {
  333.                                         ++sp;
  334.                                         stack[sp<<1] = left0;
  335.                                         stack[(sp<<1)+1] = left0 + n - 1;
  336.                                         left = right0 - m + 1, right = right0;
  337.                                     } else {
  338.                                         ++sp;
  339.                                         stack[sp<<1] = right0 - m + 1;
  340.                                         stack[(sp<<1)+1] = right0;
  341.                                         left = left0, right = left0 + n - 1;
  342.                                     }
  343.                                 } else {
  344.                                     left = left0, right = left0 + n - 1;
  345.                                 }
  346.                             }
  347.                             else if( m > 1 )
  348.                                 left = right0 - m + 1, right = right0;
  349.                             else
  350.                                 break;
  351.                         }
  352.                     }
  353.                 }
  354.             },
  355.  
  356.             median: function(array, low, high) {
  357.                 var w;
  358.                 var middle=0,ll=0,hh=0,median=(low+high)>>1;
  359.                 for (;;) {
  360.                     if (high <= low) return array[median];
  361.                     if (high == (low + 1)) {
  362.                         if (array[low] > array[high]) {
  363.                             w = array[low];
  364.                             array[low] = array[high];
  365.                             array[high] = w;
  366.                         }
  367.                         return array[median];
  368.                     }
  369.                     middle = ((low + high) >> 1);
  370.                     if (array[middle] > array[high]) {
  371.                         w = array[middle];
  372.                         array[middle] = array[high];
  373.                         array[high] = w;
  374.                     }
  375.                     if (array[low] > array[high]) {
  376.                         w = array[low];
  377.                         array[low] = array[high];
  378.                         array[high] = w;
  379.                     }
  380.                     if (array[middle] > array[low]) {
  381.                         w = array[middle];
  382.                         array[middle] = array[low];
  383.                         array[low] = w;
  384.                     }
  385.                     ll = (low + 1);
  386.                     w = array[middle];
  387.                     array[middle] = array[ll];
  388.                     array[ll] = w;
  389.                     hh = high;
  390.                     for (;;) {
  391.                         do ++ll; while (array[low] > array[ll]);
  392.                         do --hh; while (array[hh] > array[low]);
  393.                         if (hh < ll) break;
  394.                         w = array[ll];
  395.                         array[ll] = array[hh];
  396.                         array[hh] = w;
  397.                     }
  398.                     w = array[low];
  399.                     array[low] = array[hh];
  400.                     array[hh] = w;
  401.                     if (hh <= median)
  402.                         low = ll;
  403.                     else if (hh >= median)
  404.                         high = (hh - 1);
  405.                 }
  406.                 return 0;
  407.             }
  408.         };
  409.  
  410.     })();
  411.  
  412.     global.math = math;
  413.  
  414. })(jsfeat);
  415.  
downloadjsfeat_math.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