jsfeat - npm Package Compare versions

Comparing version 0.0.4 to 0.0.8

package.json

 {
     "name" : "jsfeat",
-    "version" : "0.0.4",
+    "version" : "0.0.8",
     "description" : "JavaScript Computer Vision library",
@@ -5,0 +5,0 @@ "author" : "Eugene Zatepyakin (http://www.inspirit.ru/)",

README.md

@@ -19,2 +19,4 @@ jsfeat
  * canny edges ([Demo](http://inspirit.github.com/jsfeat/sample_canny_edge.html))
+ * sobel deriv ([Demo](http://inspirit.github.com/jsfeat/sample_sobel.html))
+ * scharr deriv ([Demo](http://inspirit.github.com/jsfeat/sample_scharr.html))
  * find more at Examples and Documentation page
@@ -26,2 +28,7 @@ * Linear Algebra module
  * Eigen Vectors and Values
+* Multiview module  ([Demo](http://inspirit.github.com/jsfeat/sample_videostab.html))
+ * Affine2D motion kernel
+ * Homography2D motion kernel
+ * RANSAC motion estimator
+ * LMEDS motion estimator
 * Matrix Math module for various matrix operation such as traspose, multiply etc.
@@ -32,4 +39,5 @@ * Features 2D
  * YAPE feature detector ([Demo](http://inspirit.github.com/jsfeat/sample_yape.html))
+ * ORB feature descriptor ([Demo](http://inspirit.github.com/jsfeat/sample_orb.html))
 * Lucas-Kanade optical flow ([Demo](http://inspirit.github.com/jsfeat/sample_oflow_lk.html) - click to add points)
 * HAAR object detector ([Demo](http://inspirit.github.com/jsfeat/sample_haar_face.html))
 * BBF object detector ([Demo](http://inspirit.github.com/jsfeat/sample_bbf_face.html))

src/jsfeat_bbf.js

@@ -196,3 +196,3 @@ /**
                                             q_cnt = feature_k.size;
-                                            for (f = 0; f < q_cnt; f++) {
+                                            for (f = 1; f < q_cnt; f++) {
                                                 if (feature_k.pz[f] >= 0) {
@@ -199,0 +199,0 @@ p = u8[feature_k.pz[f]][u8o[feature_k.pz[f]] + feature_k.px[f]];

src/jsfeat_fast_corners.js

@@ -22,6 +22,2 @@ /**
 
-        // decided to switch it off since other pattern sizes return quite poor points
-        //var offsets12 = new Int32Array([0, 2, 1, 2, 2, 1, 2, 0, 2, -1, 1, -2, 0, -2, -1, -2, -2, -1, -2, 0, -2, 1, -1, 2]);
-        //var offsets8 = new Int32Array([0, 1, 1, 1, 1, 0, 1, -1, 0, -1, -1, -1, -1, 0, -1, 1]);
-
         var threshold_tab = new Uint8Array(512);
@@ -34,3 +30,2 @@ var pixel_off = new Int32Array(25);
             var k = 0;
-            //var offsets = pattern_size == 16 ? offsets16 : (pattern_size == 12 ? offsets12 : offsets8);
             var offsets = offsets16;
@@ -44,75 +39,3 @@ for( ; k < pattern_size; ++k ) {
         },
-/*
-        _cmp_score_8 = function(src, off, pixel, d, threshold) {
-            var N = 13, k = 0, v = src[off];
-            var a0 = threshold,a=0,b0=0,b=0;
 
-            for( ; k < N; ++k ) {
-                d[k] = v - src[off+pixel[k]];
-            }
-
-            for( k = 0; k < 8; k += 2 ) {
-                a = Math.min(d[k+1], d[k+2]);
-
-                if( a <= a0 ) continue;
-
-                a = Math.min(a, d[k+3]);
-                a = Math.min(a, d[k+4]);
-                a0 = Math.max(a0, Math.min(a, d[k]));
-                a0 = Math.max(a0, Math.min(a, d[k+5]));
-            }
-
-            b0 = -a0;
-            for( k = 0; k < 8; k += 2 ) {
-                b = Math.max(d[k+1], d[k+2]);
-                b = Math.max(b, d[k+3]);
-
-                if( b >= b0 ) continue;
-
-                b = Math.max(b, d[k+4]);
-                b0 = Math.min(b0, Math.max(b, d[k]));
-                b0 = Math.min(b0, Math.max(b, d[k+5]));
-            }
-
-            return -b0-1;
-        },
-
-        _cmp_score_12 = function(src, off, pixel, d, threshold) {
-            var N = 19, k = 0, v = src[off];
-            var a0 = threshold,a=0,b0=0,b=0;
-
-            for( ; k < N; ++k ) {
-                d[k] = v - src[off+pixel[k]];
-            }
-
-            for( k = 0; k < 12; k += 2 ) {
-                a = Math.min(d[k+1], d[k+2]);
-
-                if( a <= a0 ) continue;
-
-                a = Math.min(a, d[k+3]);
-                a = Math.min(a, d[k+4]);
-                a = Math.min(a, d[k+5]);
-                a = Math.min(a, d[k+6]);
-                a0 = Math.max(a0, Math.min(a, d[k]));
-                a0 = Math.max(a0, Math.min(a, d[k+7]));
-            }
-
-            b0 = -a0;
-            for( k = 0; k < 12; k += 2 ) {
-                b = Math.max(d[k+1], d[k+2]);
-                b = Math.max(b, d[k+3]);
-                b = Math.max(b, d[k+4]);
-
-                if( b >= b0 ) continue;
-
-                b = Math.max(b, d[k+5]);
-                b = Math.max(b, d[k+6]);
-                b0 = Math.min(b0, Math.max(b, d[k]));
-                b0 = Math.min(b0, Math.max(b, d[k+7]));
-            }
-
-            return -b0-1;
-        },
-*/
         _cmp_score_16 = function(src, off, pixel, d, threshold) {
@@ -171,9 +94,2 @@ var N = 25, k = 0, v = src[off];
             detect: function(src, corners, border) {
-                /*
-                if (typeof pattern_size === "undefined") { 
-                    pattern_size = 16; 
-                } else if(pattern_size != 16 && pattern_size!=12 && pattern_size!=8) {
-                    pattern_size = 16;
-                }
-                */
                 if (typeof border === "undefined") { border = 3; }
@@ -195,3 +111,2 @@
                 var _count = 0, corners_cnt = 0, pt;
-                //var score_func = pattern_size == 16 ? _cmp_score_16 : (pattern_size == 12 ? _cmp_score_12 : _cmp_score_8);
                 var score_func = _cmp_score_16;
@@ -198,0 +113,0 @@ var thresh_tab = threshold_tab;

src/jsfeat_imgproc.js

@@ -12,3 +12,3 @@ /**
         var _resample_u8 = function(src, dst, nw, nh) {
-            var xofs = [],xofs_count=0;
+            var xofs_count=0;
             var ch=src.channel,w=src.cols,h=src.rows;
@@ -23,5 +23,7 @@ var src_d=src.data,dst_d=dst.data;
             var sum_node = jsfeat.cache.get_buffer((nw*ch)<<2);
+            var xofs_node = jsfeat.cache.get_buffer((w*2*3)<<2);
 
             var buf = buf_node.i32;
             var sum = sum_node.i32;
+            var xofs = xofs_node.i32;
 
@@ -35,15 +37,18 @@ for (; dx < nw; dx++) {
                 if(sx1 > fsx1) {
-                    xofs[xofs_count++] = {"si": ((sx1 - 1)*ch)|0, 
-                                          "di": (dx * ch)|0, 
-                                          "alpha": ((sx1 - fsx1) * 0x100)|0};
+                    xofs[k++] = (dx * ch)|0;
+                    xofs[k++] = ((sx1 - 1)*ch)|0; 
+                    xofs[k++] = ((sx1 - fsx1) * 0x100)|0;
+                    xofs_count++;
                 }
                 for(sx = sx1; sx < sx2; sx++){
-                    xofs[xofs_count++] = {"si": (sx * ch)|0, 
-                                          "di": (dx * ch)|0, 
-                                          "alpha": 256};
+                    xofs_count++;
+                    xofs[k++] = (dx * ch)|0;
+                    xofs[k++] = (sx * ch)|0;
+                    xofs[k++] = 256;
                 }
                 if(fsx2 - sx2 > 1e-3) {
-                    xofs[xofs_count++] = {"si": (sx2 * ch)|0, 
-                                          "di": (dx * ch)|0, 
-                                          "alpha": ((fsx2 - sx2) * 256)|0};
+                    xofs_count++;
+                    xofs[k++] = (dx * ch)|0;
+                    xofs[k++] = (sx2 * ch)|0;
+                    xofs[k++] = ((fsx2 - sx2) * 256)|0;
                 }
@@ -59,5 +64,5 @@ }
                 for (k = 0; k < xofs_count; k++) {
-                    dxn = xofs[k].di;
-                    alpha = xofs[k].alpha;
-                    sx1 = xofs[k].si;
+                    dxn = xofs[k*3];
+                    sx1 = xofs[k*3+1];
+                    alpha = xofs[k*3+2];
                     for (i = 0; i < ch; i++) {
@@ -94,6 +99,7 @@ buf[dxn + i] += src_d[a+sx1+i] * alpha;
             jsfeat.cache.put_buffer(buf_node);
+            jsfeat.cache.put_buffer(xofs_node);
         }
 
         var _resample = function(src, dst, nw, nh) {
-            var xofs = [],xofs_count=0;
+            var xofs_count=0;
             var ch=src.channel,w=src.cols,h=src.rows;
@@ -108,5 +114,7 @@ var src_d=src.data,dst_d=dst.data;
             var sum_node = jsfeat.cache.get_buffer((nw*ch)<<2);
+            var xofs_node = jsfeat.cache.get_buffer((w*2*3)<<2);
 
             var buf = buf_node.f32;
             var sum = sum_node.f32;
+            var xofs = xofs_node.f32;
 
@@ -120,15 +128,18 @@ for (; dx < nw; dx++) {
                 if(sx1 > fsx1) {
-                    xofs[xofs_count++] = {"si": ((sx1 - 1)*ch)|0, 
-                                          "di": (dx * ch)|0, 
-                                          "alpha": (sx1 - fsx1) * scale};
+                    xofs_count++;
+                    xofs[k++] = ((sx1 - 1)*ch)|0;
+                    xofs[k++] = (dx * ch)|0;
+                    xofs[k++] = (sx1 - fsx1) * scale;
                 }
                 for(sx = sx1; sx < sx2; sx++){
-                    xofs[xofs_count++] = {"si": (sx * ch)|0, 
-                                          "di": (dx * ch)|0, 
-                                          "alpha": scale};
+                    xofs_count++;
+                    xofs[k++] = (sx * ch)|0;
+                    xofs[k++] = (dx * ch)|0; 
+                    xofs[k++] = scale;
                 }
                 if(fsx2 - sx2 > 1e-3) {
-                    xofs[xofs_count++] = {"si": (sx2 * ch)|0, 
-                                          "di": (dx * ch)|0, 
-                                          "alpha": (fsx2 - sx2) * scale};
+                    xofs_count++;
+                    xofs[k++] = (sx2 * ch)|0;
+                    xofs[k++] = (dx * ch)|0;
+                    xofs[k++] = (fsx2 - sx2) * scale;
                 }
@@ -144,5 +155,5 @@ }
                 for (k = 0; k < xofs_count; k++) {
-                    dxn = xofs[k].di;
-                    alpha = xofs[k].alpha;
-                    sx1 = xofs[k].si;
+                    sx1 = xofs[k*3]|0;
+                    dxn = xofs[k*3+1]|0;
+                    alpha = xofs[k*3+2];
                     for (i = 0; i < ch; i++) {
@@ -178,2 +189,3 @@ buf[dxn + i] += src_d[a+sx1+i] * alpha;
             jsfeat.cache.put_buffer(buf_node);
+            jsfeat.cache.put_buffer(xofs_node);
         }
@@ -213,6 +225,6 @@
                     }
-                    dst_d[dp+j] = sum >> 8;
-                    dst_d[dp+j+1] = sum1 >> 8;
-                    dst_d[dp+j+2] = sum2 >> 8;
-                    dst_d[dp+j+3] = sum3 >> 8;
+                    dst_d[dp+j] = Math.min(sum >> 8, 255);
+                    dst_d[dp+j+1] = Math.min(sum1 >> 8, 255);
+                    dst_d[dp+j+2] = Math.min(sum2 >> 8, 255);
+                    dst_d[dp+j+3] = Math.min(sum3 >> 8, 255);
                 }
@@ -224,3 +236,3 @@ for (; j < w; ++j) {
                     }
-                    dst_d[dp+j] = sum >> 8;
+                    dst_d[dp+j] = Math.min(sum >> 8, 255);
                 }
@@ -262,6 +274,6 @@ sp += w;
                     }
-                    dst_d[dp] = sum >> 8;
-                    dst_d[dp+w] = sum1 >> 8;
-                    dst_d[dp+w2] = sum2 >> 8;
-                    dst_d[dp+w3] = sum3 >> 8;
+                    dst_d[dp] = Math.min(sum >> 8, 255);
+                    dst_d[dp+w] = Math.min(sum1 >> 8, 255);
+                    dst_d[dp+w2] = Math.min(sum2 >> 8, 255);
+                    dst_d[dp+w3] = Math.min(sum3 >> 8, 255);
                 }
@@ -273,3 +285,3 @@ for (; j < h; ++j, dp+=w) {
                     }
-                    dst_d[dp] = sum >> 8;
+                    dst_d[dp] = Math.min(sum >> 8, 255);
                 }
@@ -376,16 +388,31 @@ }
             // for raw arrays
-            grayscale: function(src, dst) {
-                var srcLength = src.length|0, srcLength_16 = (srcLength - 16)|0;
-                var j = 0;
-                var coeff_r = 4899, coeff_g = 9617, coeff_b = 1868;
+            grayscale: function(src, w, h, dst, code) {
+                // this is default image data representation in browser
+                if (typeof code === "undefined") { code = jsfeat.COLOR_RGBA2GRAY; }
+                var x=0, y=0, i=0, j=0, ir=0,jr=0;
+                var coeff_r = 4899, coeff_g = 9617, coeff_b = 1868, cn = 4;
 
-                for (var i = 0; i <= srcLength_16; i += 16, j += 4) {
-                    dst[j]     = (src[i] * coeff_r + src[i+1] * coeff_g + src[i+2] * coeff_b + 8192) >> 14;
-                    dst[j + 1] = (src[i+4] * coeff_r + src[i+5] * coeff_g + src[i+6] * coeff_b + 8192) >> 14;
-                    dst[j + 2] = (src[i+8] * coeff_r + src[i+9] * coeff_g + src[i+10] * coeff_b + 8192) >> 14;
-                    dst[j + 3] = (src[i+12] * coeff_r + src[i+13] * coeff_g + src[i+14] * coeff_b + 8192) >> 14;
+                if(code == jsfeat.COLOR_BGRA2GRAY || code == jsfeat.COLOR_BGR2GRAY) {
+                    coeff_r = 1868;
+                    coeff_b = 4899;
                 }
-                for (; i < srcLength; i += 4, ++j) {
-                    dst[j] = (src[i] * coeff_r + src[i+1] * coeff_g + src[i+2] * coeff_b + 8192) >> 14;
+                if(code == jsfeat.COLOR_RGB2GRAY || code == jsfeat.COLOR_BGR2GRAY) {
+                    cn = 3;
                 }
+                var cn2 = cn<<1, cn3 = (cn*3)|0;
+
+                dst.resize(w, h, 1);
+                var dst_u8 = dst.data;
+
+                for(y = 0; y < h; ++y, j+=w, i+=w*cn) {
+                    for(x = 0, ir = i, jr = j; x <= w-4; x+=4, ir+=cn<<2, jr+=4) {
+                        dst_u8[jr]     = (src[ir] * coeff_r + src[ir+1] * coeff_g + src[ir+2] * coeff_b + 8192) >> 14;
+                        dst_u8[jr + 1] = (src[ir+cn] * coeff_r + src[ir+cn+1] * coeff_g + src[ir+cn+2] * coeff_b + 8192) >> 14;
+                        dst_u8[jr + 2] = (src[ir+cn2] * coeff_r + src[ir+cn2+1] * coeff_g + src[ir+cn2+2] * coeff_b + 8192) >> 14;
+                        dst_u8[jr + 3] = (src[ir+cn3] * coeff_r + src[ir+cn3+1] * coeff_g + src[ir+cn3+2] * coeff_b + 8192) >> 14;
+                    }
+                    for (; x < w; ++x, ++jr, ir+=cn) {
+                        dst_u8[jr] = (src[ir] * coeff_r + src[ir+1] * coeff_g + src[ir+2] * coeff_b + 8192) >> 14;
+                    }
+                }
             },
@@ -396,2 +423,3 @@ // derived from CCV library
                 if (h > nh && w > nw) {
+                    dst.resize(nw, nh, src.channel);
                     // using the fast alternative (fix point scale, 0x100 to avoid overflow)
@@ -412,4 +440,3 @@ if (src.type&jsfeat.U8_t && dst.type&jsfeat.U8_t && h * w / (nh * nw) < 0x100) {
                 var radiusPlusOne = (radius + 1)|0, radiusPlus2 = (radiusPlusOne+1)|0;
-                var offset = 8192;
-                var scale = options&jsfeat.BOX_BLUR_NOSCALE ? 1 : (16384 / (windowSize*windowSize) + 0.5)|0;
+                var scale = options&jsfeat.BOX_BLUR_NOSCALE ? 1 : (1.0 / (windowSize*windowSize));
 
@@ -423,2 +450,4 @@ var tmp_buff = jsfeat.cache.get_buffer((w*h)<<2);
 
+                dst.resize(w, h, src.channel);
+
                 // first pass
@@ -538,3 +567,3 @@ // no need to scale
                         for(x = 0; x < radius; ++x, dstIndex += w) {
-                            data_u8[dstIndex] = (sum*scale+offset)>>14;
+                            data_u8[dstIndex] = sum*scale;
                             sum += data_i32[nextPixelIndex]- hold;
@@ -544,6 +573,6 @@ nextPixelIndex ++;
                         for(; x < h-radiusPlus2; x+=2, dstIndex += w2) {
-                            data_u8[dstIndex] = (sum*scale+offset)>>14;
+                            data_u8[dstIndex] = sum*scale;
                             sum += data_i32[nextPixelIndex]- data_i32[previousPixelIndex];
 
-                            data_u8[dstIndex+w] = (sum*scale+offset)>>14;
+                            data_u8[dstIndex+w] = sum*scale;
                             sum += data_i32[nextPixelIndex+1]- data_i32[previousPixelIndex+1];
@@ -555,3 +584,3 @@
                         for(; x < h-radiusPlusOne; ++x, dstIndex += w) {
-                            data_u8[dstIndex] = (sum*scale+offset)>>14;
+                            data_u8[dstIndex] = sum*scale;
 
@@ -564,3 +593,3 @@ sum += data_i32[nextPixelIndex]- data_i32[previousPixelIndex];
                         for(; x < h; ++x, dstIndex += w) {
-                            data_u8[dstIndex] = (sum*scale+offset)>>14;
+                            data_u8[dstIndex] = sum*scale;
 
@@ -585,2 +614,5 @@ sum += hold- data_i32[previousPixelIndex];
                 var data_type = src.type, is_u8 = data_type&jsfeat.U8_t;
+
+                dst.resize(w, h, src.channel);
+
                 var src_d = src.data, dst_d = dst.data;
@@ -593,3 +625,3 @@ var buf,filter,buf_sz=(kernel_size + Math.max(h, w))|0;
                 if(is_u8) {
-                    buf = buf_node.u8;
+                    buf = buf_node.i32;
                     filter = filt_node.i32;
@@ -615,2 +647,75 @@ } else if(data_type&jsfeat.S32_t) {
             },
+            hough_transform: function( img, rho_res, theta_res, threshold ) {
+                var image = img.data;
+
+                var width = img.cols;
+                var height = img.rows;
+                var step = width;
+
+                min_theta = 0.0;
+                max_theta = Math.PI;
+
+                numangle = Math.round((max_theta - min_theta) / theta_res);
+                numrho = Math.round(((width + height) * 2 + 1) / rho_res);
+                irho = 1.0 / rho_res;
+
+                var accum = new Int32Array((numangle+2) * (numrho+2)); //typed arrays are initialized to 0
+                var tabSin = new Float32Array(numangle);
+                var tabCos = new Float32Array(numangle);
+
+                var n=0;
+                var ang = min_theta;
+                for(; n < numangle; n++ ) {
+                    tabSin[n] = Math.sin(ang) * irho;
+                    tabCos[n] = Math.cos(ang) * irho;
+                    ang += theta_res
+                }
+
+                // stage 1. fill accumulator
+                for( var i = 0; i < height; i++ ) {
+                    for( var j = 0; j < width; j++ ) {
+                        if( image[i * step + j] != 0 ) {
+                            //console.log(r, (n+1) * (numrho+2) + r+1, tabCos[n], tabSin[n]);
+                            for(var n = 0; n < numangle; n++ ) {
+                                var r = Math.round( j * tabCos[n] + i * tabSin[n] );
+                                r += (numrho - 1) / 2;
+                                accum[(n+1) * (numrho+2) + r+1] += 1;
+                            }
+                        }
+                    }
+                }
+
+                // stage 2. find local maximums
+                //TODO: Consider making a vector class that uses typed arrays
+                _sort_buf = new Array();
+                for(var r = 0; r < numrho; r++ ) {
+                    for(var n = 0; n < numangle; n++ ) {
+                        var base = (n+1) * (numrho+2) + r+1;
+                        if( accum[base] > threshold &&
+                            accum[base] > accum[base - 1] && accum[base] >= accum[base + 1] &&
+                            accum[base] > accum[base - numrho - 2] && accum[base] >= accum[base + numrho + 2] ) {
+                            _sort_buf.push(base);
+                        }
+                    }
+                }
+
+                // stage 3. sort the detected lines by accumulator value
+                _sort_buf.sort(function(l1, l2) {
+                    return accum[l1] > accum[l2] || (accum[l1] == accum[l2] && l1 < l2);
+                });
+
+                // stage 4. store the first min(total,linesMax) lines to the output buffer
+                linesMax = Math.min(numangle*numrho, _sort_buf.length);
+                scale = 1.0 / (numrho+2);
+                lines = new Array();
+                for( var i = 0; i < linesMax; i++ ) {
+                    var idx = _sort_buf[i];
+                    var n = Math.floor(idx*scale) - 1;
+                    var r = idx - (n+1)*(numrho+2) - 1;
+                    var lrho = (r - (numrho - 1)*0.5) * rho_res;
+                    var langle = n * theta_res;
+                    lines.push([lrho, langle]);
+                }
+                return lines;
+            },
             // assume we always need it for u8 image
@@ -626,2 +731,5 @@ pyrdown: function(src, dst, sx, sy) {
                 var x=0,y=0,sptr=sx+sy*w,sline=0,dptr=0,dline=0;
+
+                dst.resize(w2, h2, src.channel);
+
                 var src_d = src.data, dst_d = dst.data;
@@ -653,4 +761,7 @@
                 var trow0,trow1;
-                var img = src.data;
 
+                dst.resize(w, h, 2); // 2 channel output gx, gy
+
+                var img = src.data, gxgy=dst.data;
+
                 var buf0_node = jsfeat.cache.get_buffer((w+2)<<2);
@@ -694,15 +805,15 @@ var buf1_node = jsfeat.cache.get_buffer((w+2)<<2);
                         e = trow0[x+2], f = trow0[x+3];
-                        dst[drow++] = ( e - trow0[x] );
-                        dst[drow++] = ( (a + trow1[x])*3 + b*10 );
-                        dst[drow++] = ( f - trow0[x+1] );
-                        dst[drow++] = ( (c + b)*3 + a*10 );
+                        gxgy[drow++] = ( e - trow0[x] );
+                        gxgy[drow++] = ( (a + trow1[x])*3 + b*10 );
+                        gxgy[drow++] = ( f - trow0[x+1] );
+                        gxgy[drow++] = ( (c + b)*3 + a*10 );
 
-                        dst[drow++] = ( (trow0[x+4] - e) );
-                        dst[drow++] = ( ((d + a)*3 + c*10) );
-                        dst[drow++] = ( (trow0[x+5] - f) );
-                        dst[drow++] = ( ((trow1[x+5] + c)*3 + d*10) );
+                        gxgy[drow++] = ( (trow0[x+4] - e) );
+                        gxgy[drow++] = ( ((d + a)*3 + c*10) );
+                        gxgy[drow++] = ( (trow0[x+5] - f) );
+                        gxgy[drow++] = ( ((trow1[x+5] + c)*3 + d*10) );
                     }
                     for(; x < w; ++x) {
-                        dst[drow++] = ( (trow0[x+2] - trow0[x]) );
-                        dst[drow++] = ( ((trow1[x+2] + trow1[x])*3 + trow1[x+1]*10) );
+                        gxgy[drow++] = ( (trow0[x+2] - trow0[x]) );
+                        gxgy[drow++] = ( ((trow1[x+2] + trow1[x])*3 + trow1[x+1]*10) );
                     }
@@ -721,4 +832,7 @@ }
                 var trow0,trow1;
-                var img = src.data;
 
+                dst.resize(w, h, 2); // 2 channel output gx, gy
+
+                var img = src.data, gxgy=dst.data;
+
                 var buf0_node = jsfeat.cache.get_buffer((w+2)<<2);
@@ -762,15 +876,15 @@ var buf1_node = jsfeat.cache.get_buffer((w+2)<<2);
                         e = trow0[x+2], f = trow0[x+3];
-                        dst[drow++] = ( e - trow0[x] );
-                        dst[drow++] = ( a + trow1[x] + b*2 );
-                        dst[drow++] = ( f - trow0[x+1] );
-                        dst[drow++] = ( c + b + a*2 );
+                        gxgy[drow++] = ( e - trow0[x] );
+                        gxgy[drow++] = ( a + trow1[x] + b*2 );
+                        gxgy[drow++] = ( f - trow0[x+1] );
+                        gxgy[drow++] = ( c + b + a*2 );
 
-                        dst[drow++] = ( trow0[x+4] - e );
-                        dst[drow++] = ( d + a + c*2 );
-                        dst[drow++] = ( trow0[x+5] - f );
-                        dst[drow++] = ( trow1[x+5] + c + d*2 );
+                        gxgy[drow++] = ( trow0[x+4] - e );
+                        gxgy[drow++] = ( d + a + c*2 );
+                        gxgy[drow++] = ( trow0[x+5] - f );
+                        gxgy[drow++] = ( trow1[x+5] + c + d*2 );
                     }
                     for(; x < w; ++x) {
-                        dst[drow++] = ( trow0[x+2] - trow0[x] );
-                        dst[drow++] = ( trow1[x+2] + trow1[x] + trow1[x+1]*2 );
+                        gxgy[drow++] = ( trow0[x+2] - trow0[x] );
+                        gxgy[drow++] = ( trow1[x+2] + trow1[x] + trow1[x+1]*2 );
                     }
@@ -889,3 +1003,7 @@ }
             equalize_histogram: function(src, dst) {
-                var w=src.cols,h=src.rows,src_d=src.data,dst_d=dst.data,size=w*h;
+                var w=src.cols,h=src.rows,src_d=src.data;
+
+                dst.resize(w, h, src.channel);
+
+                var dst_d=dst.data,size=w*h;
                 var i=0,prev=0,hist0,norm;
@@ -913,3 +1031,7 @@
             canny: function(src, dst, low_thresh, high_thresh) {
-                var w=src.cols,h=src.rows,src_d=src.data,dst_d=dst.data;
+                var w=src.cols,h=src.rows,src_d=src.data;
+
+                dst.resize(w, h, src.channel);
+                
+                var dst_d=dst.data;
                 var i=0,j=0,grad=0,w2=w<<1,_grad=0,suppress=0,f=0,x=0,y=0,s=0;
@@ -929,5 +1051,6 @@ var tg22x=0,tg67x=0;
                 var dxdy = dxdy_node.i32;
+                var dxdy_m = new jsfeat.matrix_t(w, h, jsfeat.S32C2_t, dxdy_node.data);
                 var row0=1,row1=(w+2+1)|0,row2=(2*(w+2)+1)|0,map_w=(w+2)|0,map_i=(map_w+1)|0,stack_i=0;
 
-                this.sobel_derivatives(src, dxdy);
+                this.sobel_derivatives(src, dxdy_m);
 
@@ -1073,11 +1196,12 @@ if(low_thresh > high_thresh) {
             },
-
+            // transform is 3x3 matrix_t
             warp_perspective: function(src, dst, transform, fill_value) {
                 if (typeof fill_value === "undefined") { fill_value = 0; }
-                var src_width=src.cols, src_height=src.rows, dst_width=dst.cols, dst_height=dst.rows;
+                var src_width=src.cols|0, src_height=src.rows|0, dst_width=dst.cols|0, dst_height=dst.rows|0;
                 var src_d=src.data, dst_d=dst.data;
                 var x=0,y=0,off=0,ixs=0,iys=0,xs=0.0,ys=0.0,xs0=0.0,ys0=0.0,ws=0.0,sc=0.0,a=0.0,b=0.0,p0=0.0,p1=0.0;
-                var m00=transform[0],m01=transform[1],m02=transform[2],
-                    m10=transform[3],m11=transform[4],m12=transform[5],
-                    m20=transform[6],m21=transform[7],m22=transform[8];
+                var td=transform.data;
+                var m00=td[0],m01=td[1],m02=td[2],
+                    m10=td[3],m11=td[4],m12=td[5],
+                    m20=td[6],m21=td[7],m22=td[8];
 
@@ -1096,3 +1220,3 @@ for(var dptr = 0; y < dst_height; ++y) {
                             b = Math.max(ys - iys, 0.0);
-                            off = src_width*iys + ixs;
+                            off = (src_width*iys + ixs)|0;
 
@@ -1108,3 +1232,3 @@ p0 = src_d[off] +  a * (src_d[off+1] - src_d[off]);
             },
-
+            // transform is 3x3 or 2x3 matrix_t only first 6 values referenced
             warp_affine: function(src, dst, transform, fill_value) {
@@ -1115,4 +1239,5 @@ if (typeof fill_value === "undefined") { fill_value = 0; }
                 var x=0,y=0,off=0,ixs=0,iys=0,xs=0.0,ys=0.0,a=0.0,b=0.0,p0=0.0,p1=0.0;
-                var m00=transform[0],m01=transform[1],m02=transform[2],
-                    m10=transform[3],m11=transform[4],m12=transform[5];
+                var td=transform.data;
+                var m00=td[0],m01=td[1],m02=td[2],
+                    m10=td[3],m11=td[4],m12=td[5];
 
@@ -1125,5 +1250,5 @@ for(var dptr = 0; y < dst_height; ++y) {
 
-                        if(xs > 0 && ys > 0 && ixs < (src_width - 1) && iys < (src_height - 1)) {
-                            a = Math.max(xs - ixs, 0.0);
-                            b = Math.max(ys - iys, 0.0);
+                        if(ixs >= 0 && iys >= 0 && ixs < (src_width - 1) && iys < (src_height - 1)) {
+                            a = xs - ixs;
+                            b = ys - iys;
                             off = src_width*iys + ixs;
@@ -1139,2 +1264,23 @@
                 }
+            },
+            
+            // Basic RGB Skin detection filter
+            // from http://popscan.blogspot.fr/2012/08/skin-detection-in-digital-images.html
+            skindetector: function(src,dst) {
+                var r,g,b,j;
+                var i = src.width*src.height;
+                while(i--){
+                    j = i*4;
+                    r = src.data[j];
+                    g = src.data[j+1];
+                    b = src.data[j+2];
+                    if((r>95)&&(g>40)&&(b>20)
+                     &&(r>g)&&(r>b)
+                     &&(r-Math.min(g,b)>15)
+                     &&(Math.abs(r-g)>15)){
+                         dst[i] = 255;
+                    } else {
+                        dst[i] = 0;
+                    }
+                }                
             }
@@ -1141,0 +1287,0 @@ };

src/jsfeat_linalg.js

@@ -186,3 +186,3 @@ /**
         var JacobiSVDImpl = function(At, astep, _W, Vt, vstep, m, n, n1) {
-            var eps = jsfeat.EPSILON * 10.0;
+            var eps = jsfeat.EPSILON * 2.0;
             var minval = jsfeat.FLT_MIN;
@@ -222,6 +222,5 @@ var i=0,j=0,k=0,iter=0,max_iter=Math.max(m, 30);
                         
-                        k = 3;
+                        k = 2;
                         p += At[Ai]*At[Aj];
                         p += At[Ai+1]*At[Aj+1];
-                        p += At[Ai+2]*At[Aj+2];
 
@@ -235,3 +234,3 @@ for(; k < m; k++)
                         beta = a - b, gamma = hypot(p, beta);
-                        if(beta < 0) {
+                        if( beta < 0 ) {
                             delta = (gamma - beta)*0.5;
@@ -243,56 +242,28 @@ s = Math.sqrt(delta/gamma);
                             s = (p/(gamma*c*2.0));
-                            delta = p*p*0.5/(gamma + beta);
                         }
                         
-                        W[i] += delta;
-                        W[j] -= delta;
+                        a=0.0, b=0.0;
                         
-                        if( (iter & 1) && W[i] > 0 && W[j] > 0 ) {
-                            k = 3;//unroll 3x3
-                            t0 = c*At[Ai] + s*At[Aj];
-                            t1 = -s*At[Ai] + c*At[Aj];
-                            At[Ai] = t0; At[Aj] = t1;
+                        k = 2; // unroll
+                        t0 = c*At[Ai] + s*At[Aj];
+                        t1 = -s*At[Ai] + c*At[Aj];
+                        At[Ai] = t0; At[Aj] = t1;
+                        a += t0*t0; b += t1*t1;
 
-                            t0 = c*At[Ai+1] + s*At[Aj+1];
-                            t1 = -s*At[Ai+1] + c*At[Aj+1];
-                            At[Ai+1] = t0; At[Aj+1] = t1;
+                        t0 = c*At[Ai+1] + s*At[Aj+1];
+                        t1 = -s*At[Ai+1] + c*At[Aj+1];
+                        At[Ai+1] = t0; At[Aj+1] = t1;
+                        a += t0*t0; b += t1*t1;
 
-                            t0 = c*At[Ai+2] + s*At[Aj+2];
-                            t1 = -s*At[Ai+2] + c*At[Aj+2];
-                            At[Ai+2] = t0; At[Aj+2] = t1;
-
-                            for(; k < m; k++) {
-                                t0 = c*At[Ai+k] + s*At[Aj+k];
-                                t1 = -s*At[Ai+k] + c*At[Aj+k];
-                                At[Ai+k] = t0; At[Aj+k] = t1;
-                            }
-                        } else {
-                            a = b = 0;
-                            k = 3; // unroll
-                            t0 = c*At[Ai] + s*At[Aj];
-                            t1 = -s*At[Ai] + c*At[Aj];
-                            At[Ai] = t0; At[Aj] = t1;
+                        for( ; k < m; k++ )
+                        {
+                            t0 = c*At[Ai+k] + s*At[Aj+k];
+                            t1 = -s*At[Ai+k] + c*At[Aj+k];
+                            At[Ai+k] = t0; At[Aj+k] = t1;
+                            
                             a += t0*t0; b += t1*t1;
-
-                            t0 = c*At[Ai+1] + s*At[Aj+1];
-                            t1 = -s*At[Ai+1] + c*At[Aj+1];
-                            At[Ai+1] = t0; At[Aj+1] = t1;
-                            a += t0*t0; b += t1*t1;
-
-                            t0 = c*At[Ai+2] + s*At[Aj+2];
-                            t1 = -s*At[Ai+2] + c*At[Aj+2];
-                            At[Ai+2] = t0; At[Aj+2] = t1;
-                            a += t0*t0; b += t1*t1;
-
-                            for( ; k < m; k++ )
-                            {
-                                t0 = c*At[Ai+k] + s*At[Aj+k];
-                                t1 = -s*At[Ai+k] + c*At[Aj+k];
-                                At[Ai+k] = t0; At[Aj+k] = t1;
-                                
-                                a += t0*t0; b += t1*t1;
-                            }
-                            W[i] = a; W[j] = b;
                         }
                         
+                        W[i] = a; W[j] = b;
+                        
                         changed = 1;
@@ -303,3 +274,3 @@
 
-                            k = 3;
+                            k = 2;
                             t0 = c*Vt[Vi] + s*Vt[Vj];
@@ -313,6 +284,2 @@ t1 = -s*Vt[Vi] + c*Vt[Vj];
 
-                            t0 = c*Vt[Vi+2] + s*Vt[Vj+2];
-                            t1 = -s*Vt[Vi+2] + c*Vt[Vj+2];
-                            Vt[Vi+2] = t0; Vt[Vj+2] = t1;
-
                             for(; k < n; k++) {
@@ -319,0 +286,0 @@ t0 = c*Vt[Vi+k] + s*Vt[Vj+k];

src/jsfeat_mat_math.js

@@ -13,2 +13,17 @@ /**
         return {
+            identity: function(M, value) {
+                if (typeof value === "undefined") { value=1; }
+                var src=M.data;
+                var rows=M.rows, cols=M.cols, cols_1=(cols+1)|0;
+                var len = rows * cols;
+                var k = len;
+                while(--len >= 0) src[len] = 0.0;
+                len = k;
+                k = 0;
+                while(k < len)  {
+                    src[k] = value;
+                    k = k + cols_1;
+                }
+            },
+
             transpose: function(At, A) {
@@ -134,2 +149,80 @@ var i=0,j=0,nrows=A.rows,ncols=A.cols;
                 }
+            },
+
+            // various small matrix operations
+            identity_3x3: function(M, value) {
+                if (typeof value === "undefined") { value=1; }
+                var dt=M.data;
+                dt[0] = dt[4] = dt[8] = value;
+                dt[1] = dt[2] = dt[3] = 0;
+                dt[5] = dt[6] = dt[7] = 0;
+            },
+
+            invert_3x3: function(from, to) {
+                var A = from.data, invA = to.data;
+                var t1 = A[4];
+                var t2 = A[8];
+                var t4 = A[5];
+                var t5 = A[7];
+                var t8 = A[0];
+
+                var t9 = t8*t1;
+                var t11 = t8*t4;
+                var t13 = A[3];
+                var t14 = A[1];
+                var t15 = t13*t14;
+                var t17 = A[2];
+                var t18 = t13*t17;
+                var t20 = A[6];
+                var t21 = t20*t14;
+                var t23 = t20*t17;
+                var t26 = 1.0/(t9*t2-t11*t5-t15*t2+t18*t5+t21*t4-t23*t1);
+                invA[0] = (t1*t2-t4*t5)*t26;
+                invA[1] = -(t14*t2-t17*t5)*t26;
+                invA[2] = -(-t14*t4+t17*t1)*t26;
+                invA[3] = -(t13*t2-t4*t20)*t26;
+                invA[4] = (t8*t2-t23)*t26;
+                invA[5] = -(t11-t18)*t26;
+                invA[6] = -(-t13*t5+t1*t20)*t26;
+                invA[7] = -(t8*t5-t21)*t26;
+                invA[8] = (t9-t15)*t26;
+            },
+            // C = A * B
+            multiply_3x3: function(C, A, B) {
+                var Cd=C.data, Ad=A.data, Bd=B.data;
+                var m1_0 = Ad[0], m1_1 = Ad[1], m1_2 = Ad[2];
+                var m1_3 = Ad[3], m1_4 = Ad[4], m1_5 = Ad[5];
+                var m1_6 = Ad[6], m1_7 = Ad[7], m1_8 = Ad[8];
+
+                var m2_0 = Bd[0], m2_1 = Bd[1], m2_2 = Bd[2];
+                var m2_3 = Bd[3], m2_4 = Bd[4], m2_5 = Bd[5];
+                var m2_6 = Bd[6], m2_7 = Bd[7], m2_8 = Bd[8];
+
+                Cd[0] = m1_0 * m2_0 + m1_1 * m2_3 + m1_2 * m2_6;
+                Cd[1] = m1_0 * m2_1 + m1_1 * m2_4 + m1_2 * m2_7;
+                Cd[2] = m1_0 * m2_2 + m1_1 * m2_5 + m1_2 * m2_8;
+                Cd[3] = m1_3 * m2_0 + m1_4 * m2_3 + m1_5 * m2_6;
+                Cd[4] = m1_3 * m2_1 + m1_4 * m2_4 + m1_5 * m2_7;
+                Cd[5] = m1_3 * m2_2 + m1_4 * m2_5 + m1_5 * m2_8;
+                Cd[6] = m1_6 * m2_0 + m1_7 * m2_3 + m1_8 * m2_6;
+                Cd[7] = m1_6 * m2_1 + m1_7 * m2_4 + m1_8 * m2_7;
+                Cd[8] = m1_6 * m2_2 + m1_7 * m2_5 + m1_8 * m2_8;
+            },
+
+            mat3x3_determinant: function(M) {
+                var md=M.data;
+                return  md[0] * md[4] * md[8] -
+                        md[0] * md[5] * md[7] -
+                        md[3] * md[1] * md[8] +
+                        md[3] * md[2] * md[7] +
+                        md[6] * md[1] * md[5] -
+                        md[6] * md[2] * md[4];
+            },
+
+            determinant_3x3: function(M11, M12, M13, 
+                                      M21, M22, M23, 
+                                      M31, M32, M33) {
+                return  M11 * M22 * M33 - M11 * M23 * M32 -
+                          M21 * M12 * M33 + M21 * M13 * M32 +
+                          M31 * M12 * M23 - M31 * M13 * M22;
             }
@@ -136,0 +229,0 @@ };

src/jsfeat_math.js

@@ -72,2 +72,119 @@ /**
 
+            // model is 3x3 matrix_t
+            perspective_4point_transform: function(model, src_x0, src_y0, dst_x0, dst_y0,
+                                                        src_x1, src_y1, dst_x1, dst_y1,
+                                                        src_x2, src_y2, dst_x2, dst_y2,
+                                                        src_x3, src_y3, dst_x3, dst_y3) {
+                var t1 = src_x0;
+                var t2 = src_x2;
+                var t4 = src_y1;
+                var t5 = t1 * t2 * t4;
+                var t6 = src_y3;
+                var t7 = t1 * t6;
+                var t8 = t2 * t7;
+                var t9 = src_y2;
+                var t10 = t1 * t9;
+                var t11 = src_x1;
+                var t14 = src_y0;
+                var t15 = src_x3;
+                var t16 = t14 * t15;
+                var t18 = t16 * t11;
+                var t20 = t15 * t11 * t9;
+                var t21 = t15 * t4;
+                var t24 = t15 * t9;
+                var t25 = t2 * t4;
+                var t26 = t6 * t2;
+                var t27 = t6 * t11;
+                var t28 = t9 * t11;
+                var t30 = 1.0 / (t21-t24 - t25 + t26 - t27 + t28);
+                var t32 = t1 * t15;
+                var t35 = t14 * t11;
+                var t41 = t4 * t1;
+                var t42 = t6 * t41;
+                var t43 = t14 * t2;
+                var t46 = t16 * t9;
+                var t48 = t14 * t9 * t11;
+                var t51 = t4 * t6 * t2;
+                var t55 = t6 * t14;
+                var Hr0 = -(t8-t5 + t10 * t11 - t11 * t7 - t16 * t2 + t18 - t20 + t21 * t2) * t30;
+                var Hr1 = (t5 - t8 - t32 * t4 + t32 * t9 + t18 - t2 * t35 + t27 * t2 - t20) * t30;
+                var Hr2 = t1;
+                var Hr3 = (-t9 * t7 + t42 + t43 * t4 - t16 * t4 + t46 - t48 + t27 * t9 - t51) * t30;
+                var Hr4 = (-t42 + t41 * t9 - t55 * t2 + t46 - t48 + t55 * t11 + t51 - t21 * t9) * t30;
+                var Hr5 = t14;
+                var Hr6 = (-t10 + t41 + t43 - t35 + t24 - t21 - t26 + t27) * t30;
+                var Hr7 = (-t7 + t10 + t16 - t43 + t27 - t28 - t21 + t25) * t30;
+                
+                t1 = dst_x0;
+                t2 = dst_x2;
+                t4 = dst_y1;
+                t5 = t1 * t2 * t4;
+                t6 = dst_y3;
+                t7 = t1 * t6;
+                t8 = t2 * t7;
+                t9 = dst_y2;
+                t10 = t1 * t9;
+                t11 = dst_x1;
+                t14 = dst_y0;
+                t15 = dst_x3;
+                t16 = t14 * t15;
+                t18 = t16 * t11;
+                t20 = t15 * t11 * t9;
+                t21 = t15 * t4;
+                t24 = t15 * t9;
+                t25 = t2 * t4;
+                t26 = t6 * t2;
+                t27 = t6 * t11;
+                t28 = t9 * t11;
+                t30 = 1.0 / (t21-t24 - t25 + t26 - t27 + t28);
+                t32 = t1 * t15;
+                t35 = t14 * t11;
+                t41 = t4 * t1;
+                t42 = t6 * t41;
+                t43 = t14 * t2;
+                t46 = t16 * t9;
+                t48 = t14 * t9 * t11;
+                t51 = t4 * t6 * t2;
+                t55 = t6 * t14;
+                var Hl0 = -(t8-t5 + t10 * t11 - t11 * t7 - t16 * t2 + t18 - t20 + t21 * t2) * t30;
+                var Hl1 = (t5 - t8 - t32 * t4 + t32 * t9 + t18 - t2 * t35 + t27 * t2 - t20) * t30;
+                var Hl2 = t1;
+                var Hl3 = (-t9 * t7 + t42 + t43 * t4 - t16 * t4 + t46 - t48 + t27 * t9 - t51) * t30;
+                var Hl4 = (-t42 + t41 * t9 - t55 * t2 + t46 - t48 + t55 * t11 + t51 - t21 * t9) * t30;
+                var Hl5 = t14;
+                var Hl6 = (-t10 + t41 + t43 - t35 + t24 - t21 - t26 + t27) * t30;
+                var Hl7 = (-t7 + t10 + t16 - t43 + t27 - t28 - t21 + t25) * t30;
+
+                // the following code computes R = Hl * inverse Hr
+                t2 = Hr4-Hr7*Hr5;
+                t4 = Hr0*Hr4;
+                t5 = Hr0*Hr5;
+                t7 = Hr3*Hr1;
+                t8 = Hr2*Hr3;
+                t10 = Hr1*Hr6;
+                var t12 = Hr2*Hr6;
+                t15 = 1.0 / (t4-t5*Hr7-t7+t8*Hr7+t10*Hr5-t12*Hr4);
+                t18 = -Hr3+Hr5*Hr6;
+                var t23 = -Hr3*Hr7+Hr4*Hr6;
+                t28 = -Hr1+Hr2*Hr7;
+                var t31 = Hr0-t12;
+                t35 = Hr0*Hr7-t10;
+                t41 = -Hr1*Hr5+Hr2*Hr4;
+                var t44 = t5-t8;
+                var t47 = t4-t7;
+                t48 = t2*t15;
+                var t49 = t28*t15;
+                var t50 = t41*t15;
+                var mat = model.data;
+                mat[0] = Hl0*t48+Hl1*(t18*t15)-Hl2*(t23*t15);
+                mat[1] = Hl0*t49+Hl1*(t31*t15)-Hl2*(t35*t15);
+                mat[2] = -Hl0*t50-Hl1*(t44*t15)+Hl2*(t47*t15);
+                mat[3] = Hl3*t48+Hl4*(t18*t15)-Hl5*(t23*t15);
+                mat[4] = Hl3*t49+Hl4*(t31*t15)-Hl5*(t35*t15);
+                mat[5] = -Hl3*t50-Hl4*(t44*t15)+Hl5*(t47*t15);
+                mat[6] = Hl6*t48+Hl7*(t18*t15)-t23*t15;
+                mat[7] = Hl6*t49+Hl7*(t31*t15)-t35*t15;
+                mat[8] = -Hl6*t50-Hl7*(t44*t15)+t47*t15;
+            },
+
             // The current implementation was derived from *BSD system qsort():
@@ -74,0 +191,0 @@ // Copyright (c) 1992, 1993

src/jsfeat_optical_flow_lk.js

@@ -33,6 +33,8 @@ /**
 
-                var iwin_buf = iwin_node.i32;//new Int32Array(win_area);
-                var deriv_iwin = deriv_iwin_node.i32;//new Int32Array(win_area2);
-                var deriv_lev = deriv_lev_node.i32;//deriv_m.data;
+                var deriv_m = new jsfeat.matrix_t(w0, h0, jsfeat.S32C2_t, deriv_lev_node.data);
 
+                var iwin_buf = iwin_node.i32;
+                var deriv_iwin = deriv_iwin_node.i32;
+                var deriv_lev = deriv_lev_node.i32;
+
                 var dstep=0,src=0,dsrc=0,iptr=0,diptr=0,jptr=0;
@@ -80,3 +82,3 @@ var lev_sc=0.0,prev_x=0.0,prev_y=0.0,next_x=0.0,next_y=0.0;
                     // calculate level derivatives
-                    scharr_deriv(prev_imgs[level], deriv_lev);
+                    scharr_deriv(prev_imgs[level], deriv_m);
 
@@ -83,0 +85,0 @@ // iterate through points

src/jsfeat_struct.js

@@ -46,2 +46,8 @@ /**
 
+    // color conversion
+    var COLOR_RGBA2GRAY = 0;
+    var COLOR_RGB2GRAY = 1;
+    var COLOR_BGRA2GRAY = 2;
+    var COLOR_BGR2GRAY = 3;
+
     // box blur option
@@ -79,12 +85,10 @@ var BOX_BLUR_NOSCALE = 0x01;
             if (typeof data_buffer === "undefined") { 
-                this.buffer = new data_t((c * get_data_type_size(data_type) * get_channel(data_type)) * r);
+                this.allocate();
             } else {
                 this.buffer = data_buffer;
+                // data user asked for
+                this.data = this.type&U8_t ? this.buffer.u8 : (this.type&S32_t ? this.buffer.i32 : (this.type&F32_t ? this.buffer.f32 : this.buffer.f64));
             }
-            // data user asked for
-            this.data = this.type&U8_t ? this.buffer.u8 : (this.type&S32_t ? this.buffer.i32 : (this.type&F32_t ? this.buffer.f32 : this.buffer.f64));
         }
-        matrix_t.prototype.set_data_type = function(data_type) {
-            this.type = get_data_type(data_type)|0;
-            this.channel = get_channel(data_type)|0;
+        matrix_t.prototype.allocate = function() {
             // clear references
@@ -94,11 +98,34 @@ delete this.data;
             //
-            this.buffer = new data_t((this.cols * get_data_type_size(data_type) * get_channel(data_type)) * this.rows);
+            this.buffer = new data_t((this.cols * get_data_type_size(this.type) * this.channel) * this.rows);
             this.data = this.type&U8_t ? this.buffer.u8 : (this.type&S32_t ? this.buffer.i32 : (this.type&F32_t ? this.buffer.f32 : this.buffer.f64));
         }
-        matrix_t.prototype.set_data = function(array) {
-            var i = array.length;
-            while(--i >= 0) {
-                this.data[i] = array[i];
+        matrix_t.prototype.copy_to = function(other) {
+            var od = other.data, td = this.data;
+            var i = 0, n = (this.cols*this.rows*this.channel)|0;
+            for(; i < n-4; i+=4) {
+                od[i] = td[i];
+                od[i+1] = td[i+1];
+                od[i+2] = td[i+2];
+                od[i+3] = td[i+3];
             }
+            for(; i < n; ++i) {
+                od[i] = td[i];
+            }
         }
+        matrix_t.prototype.resize = function(c, r, ch) {
+            if (typeof ch === "undefined") { ch = this.channel; }
+            // relocate buffer only if new size doesnt fit
+            var new_size = (c * get_data_type_size(this.type) * ch) * r;
+            if(new_size > this.buffer.size) {
+                this.cols = c;
+                this.rows = r;
+                this.channel = ch;
+                this.allocate();
+            } else {
+                this.cols = c;
+                this.rows = r;
+                this.channel = ch;
+            }
+        }
+
         return matrix_t;
@@ -144,4 +171,4 @@ })();
 
-    var point2d_t = (function () {
-        function point2d_t(x,y,score,level) {
+    var keypoint_t = (function () {
+        function keypoint_t(x,y,score,level,angle) {
             if (typeof x === "undefined") { x=0; }
@@ -151,2 +178,3 @@ if (typeof y === "undefined") { y=0; }
             if (typeof level === "undefined") { level=0; }
+            if (typeof angle === "undefined") { angle=-1.0; }
 
@@ -157,4 +185,5 @@ this.x = x;
             this.level = level;
+            this.angle = angle;
         }
-        return point2d_t;
+        return keypoint_t;
     })();
@@ -175,2 +204,12 @@
 
+    // popular formats
+    global.U8C1_t = U8_t | C1_t;
+    global.U8C3_t = U8_t | C3_t;
+    global.U8C4_t = U8_t | C4_t;
+
+    global.F32C1_t = F32_t | C1_t;
+    global.F32C2_t = F32_t | C2_t;
+    global.S32C1_t = S32_t | C1_t;
+    global.S32C2_t = S32_t | C2_t;
+
     // constants
@@ -180,2 +219,8 @@ global.EPSILON = EPSILON;
 
+    // color convert
+    global.COLOR_RGBA2GRAY = COLOR_RGBA2GRAY;
+    global.COLOR_RGB2GRAY = COLOR_RGB2GRAY;
+    global.COLOR_BGRA2GRAY = COLOR_BGRA2GRAY;
+    global.COLOR_BGR2GRAY = COLOR_BGR2GRAY;
+
     // options
@@ -193,4 +238,4 @@ global.BOX_BLUR_NOSCALE = BOX_BLUR_NOSCALE;
     global.pyramid_t = pyramid_t;
-    global.point2d_t = point2d_t;
+    global.keypoint_t = keypoint_t;
 
 })(jsfeat);

src/jsfeat_yape06.js

@@ -15,9 +15,8 @@ /**
         
-        var compute_laplacian = function(src, dst, w, h, Dxx, Dyy) {
-            var y=0,x=0,yrow=(Dxx*w)|0,row=yrow;
+        var compute_laplacian = function(src, dst, w, h, Dxx, Dyy, sx,sy, ex,ey) {
+            var y=0,x=0,yrow=(sy*w+sx)|0,row=yrow;
 
-            for(y = Dxx; y < h - Dxx; ++y, yrow+=w, row = yrow) {
-                for(x = w - Dxx; x >= Dxx; --x) {
+            for(y = sy; y < ey; ++y, yrow+=w, row = yrow) {
+                for(x = sx; x < ex; ++x, ++row) {
                     dst[row] = -4 * src[row] + src[row+Dxx] + src[row-Dxx] + src[row+Dyy] + src[row-Dyy];
-                    ++row;
                 }
@@ -41,3 +40,4 @@ }
 
-            detect: function(src, points) {
+            detect: function(src, points, border) {
+                if (typeof border === "undefined") { border = 5; }
                 var x=0,y=0;
@@ -54,9 +54,14 @@ var w=src.cols, h=src.rows, srd_d=src.data;
 
+                var sx = Math.max(5, border)|0;
+                var sy = Math.max(3, border)|0;
+                var ex = Math.min(w-5, w-border)|0;
+                var ey = Math.min(h-3, h-border)|0;
+
                 x = w*h;
                 while(--x>=0) {laplacian[x]=0;}
-                compute_laplacian(srd_d, laplacian, w, h, Dxx, Dyy);
+                compute_laplacian(srd_d, laplacian, w, h, Dxx, Dyy, sx,sy, ex,ey);
 
-                row = (w+1)|0;
-                for(y = 1; y < h-1; ++y, row += w) {
-                    for(x = 1, rowx=row; x < w-1; ++x, ++rowx) {
+                row = (sy*w+sx)|0;
+                for(y = sy; y < ey; ++y, row += w) {
+                    for(x = sx, rowx=row; x < ex; ++x, ++rowx) {
 
@@ -82,3 +87,3 @@ lv = laplacian[rowx];
                                 ++number_of_points;
-                                ++x, ++rowx;
+                                ++x, ++rowx; // skip next pixel since this is maxima in 3x3
                             }
@@ -85,0 +90,0 @@ }

src/jsfeat.js

@@ -7,8 +7,1 @@ /**
 var jsfeat = jsfeat || { REVISION: 'ALPHA' };
-
-// use typed arrays if possible
-self.Int32Array = self.Int32Array || Array;
-self.Uint32Array = self.Uint32Array || Array;
-self.Uint8Array = self.Uint8Array || Array;
-self.Float32Array = self.Float32Array || Array;
-self.Float64Array = self.Float64Array || Array;

New alerts

New author

Supply chain risk

A new npm collaborator published a version of the package for the first time. New collaborators are usually benign additions to a project, but do indicate a change to the security surface area of a package.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

3091444

increased by3.61%

Number of package files

33

increased by10%

Lines of code

16657

increased by14.03%

Number of lines in readme file

41

increased by24.24%

Worsened metrics

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes