global update

Added lots of new methods and modules

compile/build.xml

@@ -4,10 +4,14 @@
             <filelist id="filelist" dir="../src">
                 <file name="jsfeat.js"/>
                 <file name="jsfeat_struct.js" />
+                <file name="jsfeat_cache.js" />
                 <file name="jsfeat_math.js" />
+                <file name="jsfeat_transform.js" />
                 <file name="jsfeat_imgproc.js" />
                 <file name="jsfeat_fast_corners.js" />
                 <file name="jsfeat_optical_flow_lk.js" />
+                <file name="jsfeat_haar.js" />
+                <file name="jsfeat_bbf.js" />
             </filelist>
         </concat>
     </target>

src/jsfeat.js

@@ -9,4 +9,4 @@ var jsfeat = jsfeat || { REVISION: 'ALPHA' };
 self.Int32Array = self.Int32Array || Array;
 self.Uint32Array = self.Uint32Array || Array;
 self.Uint8Array = self.Uint8Array || Array;
-self.Float32Array = self.Float32Array || Array;
+self.Float32Array = self.Float32Array || Array;

src/jsfeat_cache.js

@@ -0,0 +1,71 @@
+/**
+ * @author Eugene Zatepyakin / http://inspirit.ru/
+ */
+
+(function(global) {
+    "use strict";
+    //
+
+    var cache = (function() {
+
+        // very primitive array cache, still need testing if it helps
+        // of course V8 has its own powerful cache sys but i'm not sure
+        // it caches several multichannel 640x480 buffer creations each frame
+
+        var _pool_node_t = (function () {
+            function _pool_node_t(size_in_bytes) {
+                this.next = null;
+                this.size = size_in_bytes|0;
+                this.buffer = new ArrayBuffer(size_in_bytes);
+                this.u8 = new Uint8Array(this.buffer);
+                this.i32 = new Int32Array(this.buffer);
+                this.f32 = new Float32Array(this.buffer);
+            }
+            return _pool_node_t;
+        })();
+
+        var _pool_head, _pool_tail;
+        var _pool_size = 0;
+
+        return {
+
+            allocate: function(capacity, data_size) {
+                _pool_head = _pool_tail = new _pool_node_t(data_size);
+                for (var i = 0; i < capacity; ++i) {
+                    var node = new _pool_node_t(data_size);
+                    _pool_tail = _pool_tail.next = node;
+
+                    _pool_size++;
+                }
+            },
+
+            get_buffer: function(size_in_bytes) {
+                // assume we have enough free nodes
+                var node = _pool_head;
+                _pool_head = _pool_head.next;
+                _pool_size--;
+
+                if(size_in_bytes > node.size) {
+                    node.buffer = new ArrayBuffer(size_in_bytes);
+                    node.u8 = new Uint8Array(node.buffer);
+                    node.i32 = new Int32Array(node.buffer);
+                    node.f32 = new Float32Array(node.buffer);
+                    node.size = size_in_bytes;
+                }
+
+                return node;
+            },
+
+            put_buffer: function(node) {
+                _pool_tail = _pool_tail.next = node;
+                _pool_size++;
+            }
+        };
+    })();
+
+    global.cache = cache;
+    // for now we dont need more than 30 buffers
+    // if having cache sys really helps we can add auto extending sys
+    cache.allocate(30, 640*4);
+
+})(jsfeat);

src/jsfeat_fast_corners.js

@@ -38,7 +38,7 @@ The references are:
         },
 
         _cmp_score_8 = function(src, off, pixel, d, threshold) {
-            var N = 15, k = 0, v = src[off];
+            var N = 13, k = 0, v = src[off];
             var a0 = threshold,a=0,b0=0,b=0;
 
             for( ; k < N; ++k ) {
@@ -161,21 +161,28 @@ The references are:
                 return _threshold;
             },
 
-            detect: function(img, w, h, corners, border, pattern_size) {
-                if (typeof pattern_size === "undefined") { pattern_size = 16; }
+            detect: function(src, corners, border, pattern_size) {
+                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; }
 
-                var K = (pattern_size/2)|0, N = (pattern_size + K + 1)|0;
+                var K = (pattern_size>>1), N = (pattern_size + K + 1)|0;
+                var img = src.data, w = src.cols, h = src.rows;
                 var i=0, j=0, k=0, vt=0, x=0, m3=0;
-                var buf = new Uint8Array(w*3);
-                var cpbuf = new Int32Array((w+1)*3);
+                var buf_node = jsfeat.cache.get_buffer(3 * w);
+                var cpbuf_node = jsfeat.cache.get_buffer(((w+1)*3)<<2);
+                var buf = buf_node.u8;//new Uint8Array(w*3);
+                var cpbuf = cpbuf_node.i32;//new Int32Array((w+1)*3);
                 var pixel = pixel_off;
                 var sd = score_diff;
                 var sy = Math.max(3, border);
                 var ey = Math.min((h-2), (h-border));
                 var sx = Math.max(3, border);
                 var ex = Math.min((w - 3), (w - border));
-                var _count = 0, corners_cnt = 0;
+                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 thresh_tab = threshold_tab;
                 var threshold = _threshold;
@@ -307,13 +314,14 @@ The references are:
                             score > buf[pprev+jm1] && score > buf[pprev+j] && score > buf[pprev+jp1] &&
                             score > buf[curr+jm1] && score > buf[curr+j] && score > buf[curr+jp1]) ) {
                             // save corner
-                            corners[corners_cnt*3] = j;
-                            corners[corners_cnt*3+1] = (i-1);
-                            corners[corners_cnt*3+2] = score;
+                            pt = corners[corners_cnt];
+                            pt.x = j, pt.y = (i-1), pt.score = score;
                             corners_cnt++;
                         }
                     }
                 } // y loop
+                jsfeat.cache.put_buffer(buf_node);
+                jsfeat.cache.put_buffer(cpbuf_node);
                 return corners_cnt;
             }
         };
@@ -322,4 +330,4 @@ The references are:
     global.fast_corners = fast_corners;
     fast_corners.set_threshold(20); // set default
 
-})(jsfeat);
+})(jsfeat);