84 files changed, 1560 insertions, 0 deletions
diff --git a/SD-VBS/benchmarks/tracking/Makefile b/SD-VBS/benchmarks/tracking/Makefile
new file mode 100644
index 0000000..60cc0ec
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/Makefile
@@ -0,0 +1,3 @@
+include ../../common/makefiles/Makefile.include
+include $(MAKEFILE_COMMON_DIR)/Makefile.recurse
diff --git a/SD-VBS/benchmarks/tracking/data/Makefile b/SD-VBS/benchmarks/tracking/data/Makefile
new file mode 100644
index 0000000..ba33d35
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/Makefile
@@ -0,0 +1,3 @@
+include ../../../common/makefiles/Makefile.include
+include $(MAKEFILE_COMMON_DIR)/Makefile.recurse
diff --git a/SD-VBS/benchmarks/tracking/data/cif/1.bmp b/SD-VBS/benchmarks/tracking/data/cif/1.bmp
new file mode 100644
index 0000000..6744178
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/cif/1.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/cif/2.bmp b/SD-VBS/benchmarks/tracking/data/cif/2.bmp
new file mode 100644
index 0000000..8c2ac57
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/cif/2.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/cif/3.bmp b/SD-VBS/benchmarks/tracking/data/cif/3.bmp
new file mode 100644
index 0000000..b7195fb
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/cif/3.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/cif/4.bmp b/SD-VBS/benchmarks/tracking/data/cif/4.bmp
new file mode 100644
index 0000000..9f0525a
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/cif/4.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/cif/5.bmp b/SD-VBS/benchmarks/tracking/data/cif/5.bmp
new file mode 100644
index 0000000..2f88c26
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/cif/5.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/cif/Makefile b/SD-VBS/benchmarks/tracking/data/cif/Makefile
new file mode 100644
index 0000000..1be9797
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/cif/Makefile
@@ -0,0 +1,7 @@
+INPUT=cif
+include ../../../../common/makefiles/Makefile.include
+BMARK=tracking
+include $(MAKEFILE_COMMON_DIR)/Makefile.common
diff --git a/SD-VBS/benchmarks/tracking/data/cif/expected.m b/SD-VBS/benchmarks/tracking/data/cif/expected.m
new file mode 100644
index 0000000..679cea9
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/cif/expected.m
@@ -0,0 +1,2 @@
+269.915165      175.828888      195.635312      172.654409      268.516358      289.931921      267.230697      190.086741      
+147.986242      145.928399      148.067509      130.441486      124.919389      64.008098       131.967361      162.460857      
diff --git a/SD-VBS/benchmarks/tracking/data/cif/tracking b/SD-VBS/benchmarks/tracking/data/cif/tracking
new file mode 100755
index 0000000..ca31ed0
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/cif/tracking
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/fullhd/1.bmp b/SD-VBS/benchmarks/tracking/data/fullhd/1.bmp
new file mode 100644
index 0000000..3db2ad6
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/fullhd/1.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/fullhd/2.bmp b/SD-VBS/benchmarks/tracking/data/fullhd/2.bmp
new file mode 100644
index 0000000..9ff8e9c
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/fullhd/2.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/fullhd/3.bmp b/SD-VBS/benchmarks/tracking/data/fullhd/3.bmp
new file mode 100644
index 0000000..ec53ae6
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/fullhd/3.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/fullhd/4.bmp b/SD-VBS/benchmarks/tracking/data/fullhd/4.bmp
new file mode 100644
index 0000000..c45c5e9
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/fullhd/4.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/fullhd/Makefile b/SD-VBS/benchmarks/tracking/data/fullhd/Makefile
new file mode 100644
index 0000000..2b37182
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/fullhd/Makefile
@@ -0,0 +1,7 @@
+INPUT=fullhd
+include ../../../../common/makefiles/Makefile.include
+BMARK=tracking
+include $(MAKEFILE_COMMON_DIR)/Makefile.common
diff --git a/SD-VBS/benchmarks/tracking/data/fullhd/expected.m b/SD-VBS/benchmarks/tracking/data/fullhd/expected.m
new file mode 100644
index 0000000..eb034f0
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/fullhd/expected.m
@@ -0,0 +1,2 @@
+1487.193453     720.553084      1481.188344     382.962678      
+308.382612      306.797105      323.948844      369.542919      
diff --git a/SD-VBS/benchmarks/tracking/data/fullhd/tracking b/SD-VBS/benchmarks/tracking/data/fullhd/tracking
new file mode 100755
index 0000000..d6afa68
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/fullhd/tracking
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/qcif/1.bmp b/SD-VBS/benchmarks/tracking/data/qcif/1.bmp
new file mode 100644
index 0000000..140ace2
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/qcif/1.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/qcif/10.bmp b/SD-VBS/benchmarks/tracking/data/qcif/10.bmp
new file mode 100644
index 0000000..61518bc
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/qcif/10.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/qcif/2.bmp b/SD-VBS/benchmarks/tracking/data/qcif/2.bmp
new file mode 100644
index 0000000..8e1f7cc
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/qcif/2.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/qcif/3.bmp b/SD-VBS/benchmarks/tracking/data/qcif/3.bmp
new file mode 100644
index 0000000..95fe31f
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/qcif/3.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/qcif/4.bmp b/SD-VBS/benchmarks/tracking/data/qcif/4.bmp
new file mode 100644
index 0000000..464608a
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/qcif/4.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/qcif/5.bmp b/SD-VBS/benchmarks/tracking/data/qcif/5.bmp
new file mode 100644
index 0000000..71eb1b7
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/qcif/5.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/qcif/6.bmp b/SD-VBS/benchmarks/tracking/data/qcif/6.bmp
new file mode 100644
index 0000000..83e5379
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/qcif/6.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/qcif/7.bmp b/SD-VBS/benchmarks/tracking/data/qcif/7.bmp
new file mode 100644
index 0000000..95b4015
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/qcif/7.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/qcif/8.bmp b/SD-VBS/benchmarks/tracking/data/qcif/8.bmp
new file mode 100644
index 0000000..8847887
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/qcif/8.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/qcif/9.bmp b/SD-VBS/benchmarks/tracking/data/qcif/9.bmp
new file mode 100644
index 0000000..4301f11
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/qcif/9.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/qcif/Makefile b/SD-VBS/benchmarks/tracking/data/qcif/Makefile
new file mode 100644
index 0000000..fb48d25
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/qcif/Makefile
@@ -0,0 +1,7 @@
+INPUT=qcif
+include ../../../../common/makefiles/Makefile.include
+BMARK=tracking
+include $(MAKEFILE_COMMON_DIR)/Makefile.common
diff --git a/SD-VBS/benchmarks/tracking/data/qcif/expected.m b/SD-VBS/benchmarks/tracking/data/qcif/expected.m
new file mode 100644
index 0000000..65c5984
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/qcif/expected.m
@@ -0,0 +1,2 @@
+142.858025      145.068198      102.770607      141.110282      90.859800       135.351851      80.185357       113.844268      117.388158      142.126183      80.877169       
+70.993874       35.205162       77.320628       62.895414       38.040784       78.853200       86.164881       63.301686       74.036975       46.176383       92.916465       
diff --git a/SD-VBS/benchmarks/tracking/data/qcif/tracking b/SD-VBS/benchmarks/tracking/data/qcif/tracking
new file mode 100755
index 0000000..7288f16
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/qcif/tracking
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/sim/1.bmp b/SD-VBS/benchmarks/tracking/data/sim/1.bmp
new file mode 100644
index 0000000..825ea49
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sim/1.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/sim/2.bmp b/SD-VBS/benchmarks/tracking/data/sim/2.bmp
new file mode 100644
index 0000000..d3451be
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sim/2.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/sim/3.bmp b/SD-VBS/benchmarks/tracking/data/sim/3.bmp
new file mode 100644
index 0000000..b060b06
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sim/3.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/sim/4.bmp b/SD-VBS/benchmarks/tracking/data/sim/4.bmp
new file mode 100644
index 0000000..137accc
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sim/4.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/sim/Makefile b/SD-VBS/benchmarks/tracking/data/sim/Makefile
new file mode 100644
index 0000000..42e2aa9
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sim/Makefile
@@ -0,0 +1,6 @@
+INPUT=sim
+include ../../../../common/makefiles/Makefile.include
+BMARK=tracking
+include $(MAKEFILE_COMMON_DIR)/Makefile.common
diff --git a/SD-VBS/benchmarks/tracking/data/sim/expected.m b/SD-VBS/benchmarks/tracking/data/sim/expected.m
new file mode 100644
index 0000000..6f90559
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sim/expected.m
@@ -0,0 +1,2 @@
+24.422544       21.868191       40.786198       37.742716       30.302637       16.079615       30.062715       35.344185       
+14.131628       32.266282       37.315204       24.606535       32.839030       14.301861       22.509506       15.748797       
diff --git a/SD-VBS/benchmarks/tracking/data/sim/tracking b/SD-VBS/benchmarks/tracking/data/sim/tracking
new file mode 100755
index 0000000..a990020
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sim/tracking
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/sim_fast/1.bmp b/SD-VBS/benchmarks/tracking/data/sim_fast/1.bmp
new file mode 100644
index 0000000..272897c
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sim_fast/1.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/sim_fast/2.bmp b/SD-VBS/benchmarks/tracking/data/sim_fast/2.bmp
new file mode 100644
index 0000000..414d2cb
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sim_fast/2.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/sim_fast/3.bmp b/SD-VBS/benchmarks/tracking/data/sim_fast/3.bmp
new file mode 100644
index 0000000..340e885
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sim_fast/3.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/sim_fast/4.bmp b/SD-VBS/benchmarks/tracking/data/sim_fast/4.bmp
new file mode 100644
index 0000000..c347859
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sim_fast/4.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/sim_fast/Makefile b/SD-VBS/benchmarks/tracking/data/sim_fast/Makefile
new file mode 100644
index 0000000..12bcfa5
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sim_fast/Makefile
@@ -0,0 +1,6 @@
+INPUT=sim_fast
+include ../../../../common/makefiles/Makefile.include
+BMARK=tracking
+include $(MAKEFILE_COMMON_DIR)/Makefile.common
diff --git a/SD-VBS/benchmarks/tracking/data/sim_fast/expected.m b/SD-VBS/benchmarks/tracking/data/sim_fast/expected.m
new file mode 100644
index 0000000..f944bf8
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sim_fast/expected.m
@@ -0,0 +1,2 @@
+25.330446       17.728868       14.459743       
+16.949109       9.076394        22.247495       
diff --git a/SD-VBS/benchmarks/tracking/data/sim_fast/tracking b/SD-VBS/benchmarks/tracking/data/sim_fast/tracking
new file mode 100755
index 0000000..7309b27
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sim_fast/tracking
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/sqcif/1.bmp b/SD-VBS/benchmarks/tracking/data/sqcif/1.bmp
new file mode 100644
index 0000000..06a8c3d
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sqcif/1.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/sqcif/2.bmp b/SD-VBS/benchmarks/tracking/data/sqcif/2.bmp
new file mode 100644
index 0000000..fd5c01f
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sqcif/2.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/sqcif/3.bmp b/SD-VBS/benchmarks/tracking/data/sqcif/3.bmp
new file mode 100644
index 0000000..14ab860
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sqcif/3.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/sqcif/4.bmp b/SD-VBS/benchmarks/tracking/data/sqcif/4.bmp
new file mode 100644
index 0000000..7afba08
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sqcif/4.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/sqcif/Makefile b/SD-VBS/benchmarks/tracking/data/sqcif/Makefile
new file mode 100644
index 0000000..c47a0fd
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sqcif/Makefile
@@ -0,0 +1,6 @@
+INPUT=sqcif
+include ../../../../common/makefiles/Makefile.include
+BMARK=tracking
+include $(MAKEFILE_COMMON_DIR)/Makefile.common
diff --git a/SD-VBS/benchmarks/tracking/data/sqcif/expected.m b/SD-VBS/benchmarks/tracking/data/sqcif/expected.m
new file mode 100644
index 0000000..db8a05c
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sqcif/expected.m
@@ -0,0 +1,2 @@
+65.833985       96.386766       76.545247       96.006777       62.175348       60.185245       31.941927       68.970416       85.550211       109.931998      72.298306       74.080821       
+25.209999       70.490525       41.265387       59.869753       52.207516       62.050369       30.542002       70.430274       63.040458       45.825585       49.742089       63.956939       
diff --git a/SD-VBS/benchmarks/tracking/data/sqcif/tracking b/SD-VBS/benchmarks/tracking/data/sqcif/tracking
new file mode 100755
index 0000000..6ec0f98
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/sqcif/tracking
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/test/1.bmp b/SD-VBS/benchmarks/tracking/data/test/1.bmp
new file mode 100644
index 0000000..72079a8
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/test/1.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/test/2.bmp b/SD-VBS/benchmarks/tracking/data/test/2.bmp
new file mode 100644
index 0000000..d13e26c
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/test/2.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/test/3.bmp b/SD-VBS/benchmarks/tracking/data/test/3.bmp
new file mode 100644
index 0000000..10eb499
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/test/3.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/test/4.bmp b/SD-VBS/benchmarks/tracking/data/test/4.bmp
new file mode 100644
index 0000000..6536ea7
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/test/4.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/test/Makefile b/SD-VBS/benchmarks/tracking/data/test/Makefile
new file mode 100644
index 0000000..963bebc
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/test/Makefile
@@ -0,0 +1,5 @@
+INPUT=test
+include ../../../../common/makefiles/Makefile.include
+BMARK=tracking
+include $(MAKEFILE_COMMON_DIR)/Makefile.common
diff --git a/SD-VBS/benchmarks/tracking/data/test/expected.m b/SD-VBS/benchmarks/tracking/data/test/expected.m
new file mode 100644
index 0000000..139597f
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/test/expected.m
@@ -0,0 +1,2 @@
diff --git a/SD-VBS/benchmarks/tracking/data/test/tracking b/SD-VBS/benchmarks/tracking/data/test/tracking
new file mode 100755
index 0000000..665fa11
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/test/tracking
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/vga/1.bmp b/SD-VBS/benchmarks/tracking/data/vga/1.bmp
new file mode 100644
index 0000000..9695b0c
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/vga/1.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/vga/2.bmp b/SD-VBS/benchmarks/tracking/data/vga/2.bmp
new file mode 100644
index 0000000..937d03a
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/vga/2.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/vga/3.bmp b/SD-VBS/benchmarks/tracking/data/vga/3.bmp
new file mode 100644
index 0000000..faedea3
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/vga/3.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/vga/4.bmp b/SD-VBS/benchmarks/tracking/data/vga/4.bmp
new file mode 100644
index 0000000..2be82b8
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/vga/4.bmp
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/data/vga/Makefile b/SD-VBS/benchmarks/tracking/data/vga/Makefile
new file mode 100644
index 0000000..e3fa1c2
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/vga/Makefile
@@ -0,0 +1,7 @@
+INPUT=vga
+include ../../../../common/makefiles/Makefile.include
+BMARK=tracking
+include $(MAKEFILE_COMMON_DIR)/Makefile.common
diff --git a/SD-VBS/benchmarks/tracking/data/vga/expected.m b/SD-VBS/benchmarks/tracking/data/vga/expected.m
new file mode 100644
index 0000000..05d987c
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/vga/expected.m
@@ -0,0 +1,2 @@
+470.825057      292.917830      182.675337      492.818305      276.157171      504.514201      
+216.367613      229.865854      255.912628      150.704991      276.525215      149.690554      
diff --git a/SD-VBS/benchmarks/tracking/data/vga/tracking b/SD-VBS/benchmarks/tracking/data/vga/tracking
new file mode 100755
index 0000000..bb2e3b9
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/data/vga/tracking
Binary files differ
diff --git a/SD-VBS/benchmarks/tracking/src/c/calcAreaSum.c b/SD-VBS/benchmarks/tracking/src/c/calcAreaSum.c
new file mode 100644
index 0000000..40f03dc
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/src/c/calcAreaSum.c
@@ -0,0 +1,81 @@
+/********************************
+Author: Sravanthi Kota Venkata
+********************************/
+#include "tracking.h"
+/** Compute the sum of pixels over pixel neighborhood.
+    Neighborhood = winSize*winSize 
+    This will be useful when we compute the displacement
+    of the neighborhood across frames instead of tracking each pixel.
+    Input:  src Image
+            # rows, cols, size of window
+    Output: windowed-sum image, ret.
+    Example:
+    
+    winSize = 4, cols = 8, rows = 16
+    nave_half = 2, nave = 4
+    Say, the first row of the image is:
+                3 8 6 2 4 8 9 5
+    a1 =    0 0 3 8 6 2 4 8 9 5 0 0 (append nave_half zeros to left and right border)
+    asum =  (sum the first nave # pixels - 0 0 3 8 ) = 11
+    ret(0,0) =  11
+    For ret(0,1), we need to move the window to the right by one pixel and subtract
+    from a1sum the leftmost pixel. So, we add value 6 and subtract value at a1(0,0), = 0 here.
+    ret(0,1) = 17 = a1sum
+    For ret(0,2), a1sum - a1(0,1) + a1(2+nave) = 17 - 0 + 2 = 19 = a1sum
+    For ret(0,3), a1sum - a1(0,2) + a1(3+nave) = 19 - 3 + 4 = 20 = a1sum
+    We proceed this way for all the rows and then perform summantion across all cols.
+**/
+F2D* calcAreaSum(F2D* src, int cols, int rows, int winSize)
+{
+    int nave, nave_half, i, j, k;
+    F2D *ret, *a1;
+    float a1sum;
+    
+    nave = winSize;
+    nave_half = floor((nave+1)/2);
+    ret = fMallocHandle(rows, cols);
+    a1 = fSetArray(1, cols+nave,0);
+    for(i=0; i<rows; i++)
+    {
+        for(j=0; j<cols; j++) {
+            asubsref(a1,j+nave_half) = subsref(src,i,j);
+                }
+        a1sum = 0;
+        for(k=0; k<nave; k++) {
+            a1sum += asubsref(a1,k);
+                }
+        for(j=0; j<cols; j++)
+        {
+            subsref(ret,i,j) = a1sum;
+            a1sum += asubsref(a1,j+nave) - asubsref(a1,j);
+        }
+    }
+    fFreeHandle(a1);
+    a1 = fSetArray(1, rows+nave,0);
+    for(i=0; i<cols; i++)
+    {
+        for(j=0; j<rows; j++) {
+            asubsref(a1,j+nave_half) = subsref(ret,j,i);
+                }
+        a1sum = 0;
+        for(k=0; k<nave; k++) {
+            a1sum += asubsref(a1,k);
+                }
+        for(j=0; j<rows; j++)
+        {
+            subsref(ret,j,i) = a1sum;
+            a1sum += asubsref(a1,j+nave) - asubsref(a1,j);
+        }
+    }
+    fFreeHandle(a1);
+    return ret; 
+}
diff --git a/SD-VBS/benchmarks/tracking/src/c/calcGoodFeature.c b/SD-VBS/benchmarks/tracking/src/c/calcGoodFeature.c
new file mode 100644
index 0000000..0ef1862
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/src/c/calcGoodFeature.c
@@ -0,0 +1,78 @@
+/********************************
+Author: Sravanthi Kota Venkata
+********************************/
+#include "tracking.h"
+/** Computes lambda matrix, strength at each pixel
+    
+    det = determinant( [ IverticalEdgeSq IhorzVertEdge; IhorzVertEdge IhorizontalEdgeSq] ) ;
+    tr = IverticalEdgeSq + IhorizontalEdgeSq;
+    lamdba = det/tr;
+    Lambda is the measure of the strength of pixel
+    neighborhood. By strength we mean the amount of 
+    edge information it has, which translates to
+    sharp features in the image.
+    Input:  Edge images - vertical and horizontal
+            Window size (neighborhood size)
+    Output: Lambda, strength of pixel neighborhood
+    Given the edge images, we compute strength based
+    on how strong the edges are within each neighborhood.
+**/
+F2D* calcGoodFeature(F2D* verticalEdgeImage, F2D* horizontalEdgeImage, int cols, int rows, int winSize)
+{
+    int i, j, k, ind;
+    F2D *verticalEdgeSq, *horizontalEdgeSq, *horzVertEdge;
+    F2D *tr, *det, *lambda;
+    F2D *cummulative_verticalEdgeSq, *cummulative_horzVertEdge, *cummulative_horizontalEdgeSq;
+    verticalEdgeSq = fMallocHandle(rows, cols);
+    horzVertEdge = fMallocHandle(rows, cols);
+    horizontalEdgeSq = fMallocHandle(rows, cols);
+    
+    for( i=0; i<rows; i++)
+    {
+        for( j=0; j<cols; j++)
+        {
+            subsref(verticalEdgeSq,i,j) = subsref(verticalEdgeImage,i,j) * subsref(verticalEdgeImage,i,j);
+            subsref(horzVertEdge,i,j) = subsref(verticalEdgeImage,i,j) * subsref(horizontalEdgeImage,i,j);
+            subsref(horizontalEdgeSq,i,j) = subsref(horizontalEdgeImage,i,j) * subsref(horizontalEdgeImage,i,j);
+        }
+    }
+    
+    cummulative_verticalEdgeSq = calcAreaSum(verticalEdgeSq, cols, rows, winSize); 
+    cummulative_horzVertEdge = calcAreaSum(horzVertEdge, cols, rows, winSize);
+    cummulative_horizontalEdgeSq = calcAreaSum(horizontalEdgeSq, cols, rows, winSize);    
+     
+    tr = fMallocHandle(rows, cols);
+    det = fMallocHandle(rows, cols);
+    lambda = fMallocHandle(rows, cols);
+    
+    for( i=0; i<rows; i++)
+    {
+        for( j=0; j<cols; j++)
+        {
+            subsref(tr,i,j) = subsref(cummulative_verticalEdgeSq,i,j) + subsref(cummulative_horizontalEdgeSq,i,j);
+            subsref(det,i,j) = subsref(cummulative_verticalEdgeSq,i,j) * subsref(cummulative_horizontalEdgeSq,i,j) - subsref(cummulative_horzVertEdge,i,j) * subsref(cummulative_horzVertEdge,i,j);
+            subsref(lambda,i,j) = ( subsref(det,i,j) / (subsref(tr,i,j)+0.00001) ) ;
+        }
+    }
+   
+    fFreeHandle(verticalEdgeSq);
+    fFreeHandle(horzVertEdge);
+    fFreeHandle(horizontalEdgeSq);
+    fFreeHandle(cummulative_verticalEdgeSq);
+    fFreeHandle(cummulative_horzVertEdge);
+    fFreeHandle(cummulative_horizontalEdgeSq);
+    
+    fFreeHandle(tr);
+    fFreeHandle(det);
+     
+    return lambda;
+}
diff --git a/SD-VBS/benchmarks/tracking/src/c/calcPyrLKTrack.c b/SD-VBS/benchmarks/tracking/src/c/calcPyrLKTrack.c
new file mode 100644
index 0000000..3718673
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/src/c/calcPyrLKTrack.c
@@ -0,0 +1,179 @@
+/********************************
+Author: Sravanthi Kota Venkata
+********************************/
+#include "tracking.h"
+/** calcPyrLKTrack tries to find the displacement (translation in x and y) of features computed in the previous frame.
+    To compute the displacement, we interpolate the existing feature position around the pixel neighborhood.
+    For better results, we perform interpolatations across all pyramid levels.
+    Input:  Previous frame blurred images, vertical and horizontal
+            Current frame edge images, vertical and horizontal
+            Current frame blurred images, for level 0 and 1
+            Number of features from previous frame
+            Window size
+            Accuracy
+            Number of iterations to compute motion vector
+            Features from the previous frame
+            currentFrameFeatures, Populate the current frame features' displacements
+    Output: Number of valid features
+**/
+I2D* calcPyrLKTrack(F2D* previousImageBlur_level1, F2D* previousImageBlur_level2, F2D* vertEdge_level1, F2D* vertEdge_level2, F2D* horzEdge_level1, F2D* horzEdge_level2, F2D* currentImageBlur_level1, F2D* currentImageBlur_level2, F2D* previousFrameFeatures, int nFeatures, int winSize, float accuracy, int max_iter, F2D* currentFrameFeatures)
+{
+    int idx, level, pLevel, i, j, k, winSizeSq;
+    I2D *valid;
+    F2D *rate, *iPatch, *jPatch, *iDxPatch;
+    F2D *iDyPatch;
+    float tr, x, y, dX, dY, c_xx, c_yy, c_xy;
+    int imgSize_1, imgSize_2;
+    float mX, mY, dIt, eX, eY, c_det;
+    I2D *imgDims;
+    imgDims = iMallocHandle(2, 2);
+    subsref(imgDims,0,0) = previousImageBlur_level1->height;
+    subsref(imgDims,0,1) = previousImageBlur_level1->width;
+    subsref(imgDims,1,0) = previousImageBlur_level2->height;
+    subsref(imgDims,1,1) = previousImageBlur_level2->width;
+    pLevel = 2;
+    rate = fMallocHandle(1, 6);
+    asubsref(rate,0) = 1;
+    asubsref(rate,1) = 0.5;
+    asubsref(rate,2) = 0.25;
+    asubsref(rate,3) = 0.125;
+    asubsref(rate,4) = 0.0625;
+    asubsref(rate,5) = 0.03125;
+    
+    winSizeSq = 4*winSize*winSize;
+    valid = iSetArray(1,nFeatures, 1);
+    /** For each feature passed from previous frame, compute the dx and dy, the displacements **/
+    for(i=0; i<nFeatures; i++)
+    {
+        dX = 0;
+        dY = 0;
+        /** Compute the x and y co-ordinate values at "pLevel" **/
+        x = subsref(previousFrameFeatures,0,i) * asubsref(rate,pLevel);
+        y = subsref(previousFrameFeatures,1,i) * asubsref(rate,pLevel);
+        c_det = 0;
+        /** For each pyramid level, try to find correspondence.
+            We look for the correspondence in a given window size
+            , (winSize x winSize) neighborhood **/
+        for(level = pLevel-1; level>=0; level--)
+        {
+            x = x+x;
+            y = y+y;
+            dX = dX + dX;
+            dY = dY + dY;
+            imgSize_1 = subsref(imgDims,level,0);
+            imgSize_2 = subsref(imgDims,level,1);
+            c_xx = 0;
+            c_xy = 0;
+            c_yy = 0;
+        
+            if((x-winSize)<0 || (y-winSize)<0 || (y+winSize+1)>=imgSize_1 || (x+winSize+1)>=imgSize_2)
+            {
+                asubsref(valid,i) = 0;
+                break;
+            }
+            /** Perform interpolation. Use co-ord from previous
+                frame and use the images from current frame **/
+            if(level ==0)
+            {
+                iPatch = getInterpolatePatch(previousImageBlur_level1, imgSize_2, x, y, winSize);
+                iDxPatch = getInterpolatePatch(vertEdge_level1, imgSize_2, x, y, winSize);
+                iDyPatch = getInterpolatePatch(horzEdge_level1, imgSize_2, x, y, winSize);
+            }
+            if(level ==1)
+            {
+                iPatch = getInterpolatePatch(previousImageBlur_level2, imgSize_2, x, y, winSize);
+                iDxPatch = getInterpolatePatch(vertEdge_level2, imgSize_2, x, y, winSize);
+                iDyPatch = getInterpolatePatch(horzEdge_level2, imgSize_2, x, y, winSize);
+            }
+            /** Compute feature strength in similar way as calcGoodFeature **/
+            for(idx=0; idx<winSizeSq; idx++)
+            {
+                c_xx += asubsref(iDxPatch,idx) * asubsref(iDxPatch,idx);
+                c_xy += asubsref(iDxPatch,idx) * asubsref(iDyPatch,idx);
+                c_yy += asubsref(iDyPatch,idx) * asubsref(iDyPatch,idx);
+            }
+            
+            c_det = (c_xx * c_yy -c_xy * c_xy);
+            tr = c_xx + c_yy;
+            if((c_det/(tr+0.00001)) < accuracy)
+            {
+                asubsref(valid,i) = 0;
+                fFreeHandle(iPatch);
+                fFreeHandle(iDxPatch);
+                fFreeHandle(iDyPatch);
+                break;
+            }
+            c_det = 1/c_det;
+            /** We compute dX and dY using previous frame and current
+                frame images. For this, the strength is computed at each
+                pixel in the new image.  **/
+            for(k=0; k<max_iter; k++)
+            {
+                if( (x+dX-winSize)<0 || (y+dY-winSize)<0 || (y+dY+winSize+1)>=imgSize_1 || (x+dX+winSize+1)>=imgSize_2)
+                {
+                    asubsref(valid,i) = 0;
+                    break;
+                }
+                
+                if(level == 0)
+                    jPatch = getInterpolatePatch(currentImageBlur_level1, imgSize_2, x+dX, y+dY, winSize);
+                if(level == 1)
+                    jPatch = getInterpolatePatch(currentImageBlur_level2, imgSize_2, x+dX, y+dY, winSize);
+                
+                eX = 0;
+                eY = 0;
+                for(idx=0; idx<winSizeSq; idx++)
+                {
+                    dIt = asubsref(iPatch,idx) - asubsref(jPatch,idx);
+                    eX += dIt * asubsref(iDxPatch,idx);
+                    eY += dIt * asubsref(iDyPatch,idx);
+                }
+                
+                mX = c_det * (eX * c_yy - eY * c_xy);
+                mY = c_det * (-eX * c_xy + eY * c_xx);
+                dX = dX + mX;
+                dY = dY + mY;
+            
+                if( (mX*mX+mY*mY) < accuracy)
+                {
+                    fFreeHandle(jPatch);
+                    break;
+                }
+                
+                fFreeHandle(jPatch);
+            }
+            fFreeHandle(iPatch);
+            fFreeHandle(iDxPatch);
+            fFreeHandle(iDyPatch);
+        }
+        subsref(currentFrameFeatures,0,i) = subsref(previousFrameFeatures,0,i) + dX;
+        subsref(currentFrameFeatures,1,i) = subsref(previousFrameFeatures,1,i) + dY;
+        
+    }
+    fFreeHandle(rate);
+    iFreeHandle(imgDims);
+    return valid;
+}
diff --git a/SD-VBS/benchmarks/tracking/src/c/fillFeatures.c b/SD-VBS/benchmarks/tracking/src/c/fillFeatures.c
new file mode 100644
index 0000000..42de169
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/src/c/fillFeatures.c
@@ -0,0 +1,67 @@
+/********************************
+Author: Sravanthi Kota Venkata
+********************************/
+#include "tracking.h"
+/** Find the position and values of the top N_FEA features 
+        from the lambda matrix **/
+F2D* fillFeatures(F2D* lambda, int N_FEA, int win)
+{
+    int i, j, k, l;
+    int rows = lambda->height;
+    int cols = lambda->width;
+    F2D* features;
+        features = fSetArray(3, N_FEA, 0);
+        /** init array **/
+    for(i=0; i<N_FEA; i++)
+    {
+        subsref(features, 0, i) = -1.0;
+        subsref(features, 1, i) = -1.0;
+        subsref(features, 2, i) = 0.0;
+    }
+    
+        /** 
+                Find top N_FEA values and store them in 
+        features array along with row and col information 
+                It should be possible to make this algorithm better
+                if we use a pointer-based data structure,
+                but have not implemented due to MATLAB compatibility
+        **/ 
+        for (i=win; i<rows-win; i++)
+        {
+                for (j=win; j<cols-win; j++)
+                {
+            float currLambdaVal = subsref(lambda,i,j);
+                        if (subsref(features, 2, N_FEA-1) > currLambdaVal)
+                                continue;
+                        
+                        for (k=0; k<N_FEA; k++) 
+                        {
+                                if (subsref(features, 2, k) < currLambdaVal) 
+                                {
+                                        /** shift one slot **/
+                                        for (l=N_FEA-1; l>k; l--)
+                                        {
+                                                subsref(features, 0, l) = subsref(features, 0, l-1);
+                                                subsref(features, 1, l) = subsref(features, 1, l-1);
+                                                subsref(features, 2, l) = subsref(features, 2, l-1);
+                                        }       
+                                        
+                                subsref(features, 0, k) = j * 1.0;
+                                subsref(features, 1, k) = i * 1.0;
+                                subsref(features, 2, k) = currLambdaVal;
+                                        break;
+                                }
+                        }
+                }
+        }
+    return features;
+}
diff --git a/SD-VBS/benchmarks/tracking/src/c/getANMS.c b/SD-VBS/benchmarks/tracking/src/c/getANMS.c
new file mode 100644
index 0000000..7ecce8b
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/src/c/getANMS.c
@@ -0,0 +1,156 @@
+/********************************
+Author: Sravanthi Kota Venkata
+********************************/
+#include "tracking.h"
+/** ANMS - Adaptive Non-Maximal Suppression
+    This function takes features as input and suppresses those which
+    are close to each other (within the SUPPRESSION_RADIUS) and have
+    similar feature strength
+**/
+F2D *getANMS (F2D *points, float r)
+{
+    float MAX_LIMIT = 100000;
+    F2D *suppressR;
+    float C_ROBUST = 1.0;
+    F2D *srtdPnts;
+    int n;
+    I2D *srtdVIdx, *supId;
+    float t, t1, r_sq;
+    F2D *tempF, *srtdV, *interestPnts;
+    int i, j, validCount, cnt, end, k;
+    int iter, rows, cols;
+    F2D *temp;
+    int supIdPtr = 0;
+    
+    /** Concatenate x,y,v to form points matrix **/
+    r_sq = r * r;
+    n = points->height;
+    srtdVIdx = iMallocHandle(points->height, 1);
+    for (i = 0; i < srtdVIdx->height; i++) {
+        asubsref(srtdVIdx,i) = i;
+        }
+    srtdPnts = fMallocHandle (srtdVIdx->height, points->width);
+    for (i = 0; i < srtdVIdx->height; i++) {
+        for(j=0; j<points->width; j++) {
+            subsref(srtdPnts,i,j) = subsref(points, asubsref(srtdVIdx,i), j);
+                }
+        }
+    temp = fSetArray (1, 3, 0);
+    suppressR = fSetArray(n, 1, MAX_LIMIT);
+    validCount = n;
+    iter = 0;
+    
+    /** Allocate supId for #validCount and fill the values of
+        supId with the indices where suppressR>r_sq **/
+    k = 0;
+    supId = iMallocHandle(validCount, 1);
+    for (i = 0; i < (suppressR->height*suppressR->width); i++)
+    {
+        if ( asubsref(suppressR,i) > r_sq)
+        {
+            asubsref(supId,k++) = i;
+        }
+    }
+         
+    /** While number of features not-inspected is >0,  **/
+    while (validCount > 0)
+    {
+        F2D *tempp, *temps;
+        
+        /** Inspect the strongest feature point in srtdPnts
+            The index of that feature is in supId and the
+            index values in supId are arranged in descending order **/
+        asubsref(temp,0) = subsref(srtdPnts, asubsref(supId,0), 0);
+        asubsref(temp,1) = subsref(srtdPnts, asubsref(supId,0), 1);
+        asubsref(temp,2) = subsref(srtdPnts, asubsref(supId,0), 2);
+       
+        /** Stacking up the interestPnts matrix with top features
+            post suppression **/
+        if(iter == 0)
+            interestPnts = fDeepCopy(temp);
+        else
+        {
+            tempp = fDeepCopy(interestPnts);
+            fFreeHandle(interestPnts); 
+            interestPnts = ffVertcat(tempp, temp);
+            fFreeHandle(tempp);
+        }
+        iter++;
+ 
+        tempp = fDeepCopy(srtdPnts);
+        temps = fDeepCopy(suppressR);
+        fFreeHandle(srtdPnts);
+        fFreeHandle(suppressR);
+        /** Remove the feature that has been added to interestPnts **/
+        srtdPnts = fMallocHandle(supId->height-1, 3);
+        suppressR = fMallocHandle(supId->height-1, 1);
+        k=0;
+        for(i=1; i<(supId->height); i++)    /** Filling srtdPnts after removing the feature that was added to interestPnts**/
+        {
+            subsref(srtdPnts,(i-1),0) = subsref(tempp, asubsref(supId,i) ,0);
+            subsref(srtdPnts,(i-1),1) = subsref(tempp, asubsref(supId,i) ,1);
+            subsref(srtdPnts,(i-1),2) = subsref(tempp, asubsref(supId,i) ,2);
+            subsref(suppressR,(i-1),0) = subsref(temps, asubsref(supId,i) ,0);
+        }
+         
+        fFreeHandle(tempp);
+        fFreeHandle(temps);
+        rows = interestPnts->height-1;
+        cols = interestPnts->width;
+        /** For each feature, find how robust it is compared to the one in interestPnts **/
+        for (i = 0; i < srtdPnts->height; i++)
+            {
+            t = 0;
+                t1 = 0;
+                if ((C_ROBUST * subsref(interestPnts,rows,2)) >= subsref(srtdPnts, i,2))
+                {
+                        t = subsref(srtdPnts, i,0) - subsref(interestPnts,rows,0);
+                        t1 = subsref(srtdPnts, i,1) - subsref(interestPnts,rows,1);
+                        t = t * t + t1 * t1;
+                t1 = 0;
+            }
+                if ((C_ROBUST * subsref(interestPnts,rows,2)) < subsref(srtdPnts, i,2))
+                t1 = 1 * MAX_LIMIT;
+                if ( asubsref(suppressR, i) > (t + t1))
+            {
+                    asubsref(suppressR, i) = t + t1;
+            }  
+        }
+        
+        /** Inspect the new suppressR to find how many valid features left **/
+        validCount=0;
+        for (i = 0; i < suppressR->height; i++) {
+                if ( asubsref(suppressR,i) > r_sq) {
+                validCount++;
+                        } 
+                }
+        k = 0;
+        iFreeHandle(supId);
+        /** Allocate supId for #validCount and fill the values of
+        supId with the indices where suppressR>r_sq **/
+        supId = iMallocHandle(validCount, 1);
+        for (i = 0; i < suppressR->height*suppressR->width; i++) {
+            if ( asubsref(suppressR,i) > r_sq)
+                asubsref(supId,k++) = i;
+                }
+    }
+    
+    iFreeHandle(supId);
+    iFreeHandle(srtdVIdx);
+    fFreeHandle(srtdPnts);
+    fFreeHandle(temp);
+    fFreeHandle(suppressR);
+    return interestPnts;
+}
diff --git a/SD-VBS/benchmarks/tracking/src/c/getInterpolatePatch.c b/SD-VBS/benchmarks/tracking/src/c/getInterpolatePatch.c
new file mode 100644
index 0000000..99e95f9
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/src/c/getInterpolatePatch.c
@@ -0,0 +1,43 @@
+/********************************
+Author: Sravanthi Kota Venkata
+********************************/
+#include "tracking.h"
+/** Perform simple interpolation around  2*winSize*2*winSize neighbourhood **/
+F2D* getInterpolatePatch(F2D* src, int cols, float centerX, float centerY, int winSize)
+{
+    F2D *dst;
+    float a, b, a11, a12, a21, a22;
+    int i, j, k, srcIdx, dstIdx;
+    int srcIdxx, dstIdxx;
+    a = centerX - floor(centerX);
+    b = centerY - floor(centerY);
+    a11 = (1-a)*(1-b);
+    a12 = a*(1-b);
+    a21 = (1-a)*b;
+    a22 = a*b;
+    dst = fSetArray(1,2*winSize*2*winSize, 0);
+    for(i=-winSize; i<winSize; i++)
+    {
+        srcIdxx = floor(centerY) + i;
+        dstIdxx = i+winSize;
+        for(j=-winSize; j<(winSize); j++)
+        {
+            srcIdx = srcIdxx * cols + floor(centerX) + j;
+            dstIdx = dstIdxx * 2 * winSize + j + winSize;
+            asubsref(dst,dstIdx) = asubsref(src,srcIdx)*a11 + asubsref(src,srcIdx+1)*a12 + asubsref(src,srcIdx+cols)*a21 + asubsref(src,srcIdx+1+cols)*a22;
+        }
+    }
+    return dst;
+}
diff --git a/SD-VBS/benchmarks/tracking/src/c/script_tracking.c b/SD-VBS/benchmarks/tracking/src/c/script_tracking.c
new file mode 100644
index 0000000..bb48ace
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/src/c/script_tracking.c
@@ -0,0 +1,263 @@
+/********************************
+Author: Sravanthi Kota Venkata
+********************************/
+#include "tracking.h"
+#include <malloc.h>
+#include "extra.h"
+#define TRACKING_MEM 1<<29
+int main(int argc, char* argv[])
+{
+    SET_UP
+    mallopt(M_TOP_PAD, TRACKING_MEM);
+    mallopt(M_MMAP_MAX, 0);
+    int i, j, k, N_FEA, WINSZ, LK_ITER, rows, cols;
+    int endR, endC;
+    F2D *blurredImage, *previousFrameBlurred_level1, *previousFrameBlurred_level2, *blurred_level1, *blurred_level2;
+    F2D *verticalEdgeImage, *horizontalEdgeImage, *verticalEdge_level1, *verticalEdge_level2, *horizontalEdge_level1, *horizontalEdge_level2, *interestPnt;
+    F2D *lambda, *lambdaTemp, *features;
+    I2D *Ic, *status;
+    float SUPPRESION_RADIUS;
+    F2D *newpoints;
+    int numFind, m, n;
+    F2D *np_temp;
+    char im1[100];
+    int counter=2;
+    float accuracy = 0.03;
+    int count;
+    
+    N_FEA = 1600;
+    WINSZ = 4;
+    SUPPRESION_RADIUS = 10.0;
+    LK_ITER = 20;
+    #ifdef test
+        WINSZ = 2;
+        N_FEA = 100;
+        LK_ITER = 2;
+        counter = 2;
+        accuracy = 0.1;
+    #endif
+    #ifdef sim_fast
+        WINSZ = 2;
+        N_FEA = 100;
+        LK_ITER = 2;
+        counter = 4;
+    #endif
+    #ifdef sim
+        WINSZ = 2;
+        N_FEA = 200;
+        LK_ITER = 2;
+        counter = 4;
+    #endif
+    #ifdef sqcif
+        WINSZ = 8;
+        N_FEA = 500;
+        LK_ITER = 15;
+        counter = 2;
+    #endif
+    #ifdef qcif
+        WINSZ = 12;
+        N_FEA = 400;
+        LK_ITER = 15;
+        counter = 4;
+    #endif
+    #ifdef cif
+        WINSZ = 20;
+        N_FEA = 500;
+        LK_ITER = 20;
+        counter = 4;
+    #endif
+    #ifdef vga
+        WINSZ = 32;
+        N_FEA = 400;
+        LK_ITER = 20;
+        counter = 4;
+    #endif
+    #ifdef wuxga
+        WINSZ = 64;
+        N_FEA = 500;
+        LK_ITER = 20;
+        counter = 4;
+    #endif
+    #ifdef fullhd
+        WINSZ = 48;
+        N_FEA = 500;
+        LK_ITER = 20;
+        counter = 4;
+    #endif
+    I2D* images[counter];
+    /** Read input image **/
+    for(count=1; count<=counter; count++)
+    {
+        /** Read image **/
+        printf("Input image %d: ", count);
+        scanf("%s", im1);
+        images[count - 1] = readImage(im1);
+        if(count == 1) Ic = readImage(im1);
+    }
+    rows = Ic->height;
+    cols = Ic->width;
+    
+    printf("start\n");   
+    for_each_job{
+        
+        /** IMAGE PRE-PROCESSING **/
+    
+        /** Blur the image to remove noise - weighted avergae filter **/
+        blurredImage = imageBlur(Ic);
+    
+        /** Scale down the image to build Image Pyramid. We find features across all scales of the image **/
+        blurred_level1 = blurredImage;                   /** Scale 0 **/
+        blurred_level2 = imageResize(blurredImage);      /** Scale 1 **/
+    
+    
+        /** Edge Images - From pre-processed images, build gradient images, both horizontal and vertical **/
+        verticalEdgeImage = calcSobel_dX(blurredImage);
+        horizontalEdgeImage = calcSobel_dY(blurredImage);
+    
+        /** Edge images are used for feature detection. So, using the verticalEdgeImage and horizontalEdgeImage images, we compute feature strength
+            across all pixels. Lambda matrix is the feature strength matrix returned by calcGoodFeature **/
+        
+        lambda = calcGoodFeature(verticalEdgeImage, horizontalEdgeImage, verticalEdgeImage->width, verticalEdgeImage->height, WINSZ);
+        endR = lambda->height;
+        endC = lambda->width;
+        lambdaTemp = fReshape(lambda, endR*endC, 1);
+    
+        /** We sort the lambda matrix based on the strengths **/
+        /** Fill features matrix with top N_FEA features **/
+        fFreeHandle(lambdaTemp);
+        lambdaTemp = fillFeatures(lambda, N_FEA, WINSZ);
+        features = fTranspose(lambdaTemp);
+        
+        /** Suppress features that have approximately similar strength and belong to close neighborhood **/
+        interestPnt = getANMS(features, SUPPRESION_RADIUS);
+        
+        /** Refill interestPnt in features matrix **/
+        fFreeHandle(features);
+        features = fSetArray(2, interestPnt->height, 0);
+        for(i=0; i<2; i++) {
+            for(j=0; j<interestPnt->height; j++) {
+                subsref(features,i,j) = subsref(interestPnt,j,i); 
+                }
+        } 
+         
+    
+        fFreeHandle(verticalEdgeImage);
+        fFreeHandle(horizontalEdgeImage);
+        fFreeHandle(interestPnt);
+        fFreeHandle(lambda);
+        fFreeHandle(lambdaTemp);
+        /** Until now, we processed base frame. The following for loop processes other frames **/
+        for(count=1; count<=counter; count++)
+        {
+            /** Read image **/
+            //sprintf(im1, "%s/%d.bmp", argv[1], count);
+            //Ic = readImage(im1);
+            I2D* Icc = images[count-1];
+            rows = Icc->height;
+            cols = Icc->width;
+            
+        
+            /** Blur image to remove noise **/
+            blurredImage = imageBlur(Icc);
+            previousFrameBlurred_level1 = fDeepCopy(blurred_level1);
+            previousFrameBlurred_level2 = fDeepCopy(blurred_level2);
+            
+            fFreeHandle(blurred_level1);
+            fFreeHandle(blurred_level2);
+        
+            /** Image pyramid **/
+            blurred_level1 = blurredImage;
+            blurred_level2 = imageResize(blurredImage);
+        
+            /** Gradient image computation, for all scales **/
+            verticalEdge_level1 = calcSobel_dX(blurred_level1);   
+            horizontalEdge_level1 = calcSobel_dY(blurred_level1); 
+            
+            verticalEdge_level2 = calcSobel_dX(blurred_level2); 
+            horizontalEdge_level2 = calcSobel_dY(blurred_level2);
+            
+            newpoints = fSetArray(2, features->width, 0);
+                
+            /** Based on features computed in the previous frame, find correspondence in the current frame. "status" returns the index of corresponding features **/
+            status = calcPyrLKTrack(previousFrameBlurred_level1, previousFrameBlurred_level2, verticalEdge_level1, verticalEdge_level2, horizontalEdge_level1, horizontalEdge_level2, blurred_level1, blurred_level2, features, features->width, WINSZ, accuracy, LK_ITER, newpoints);
+            fFreeHandle(verticalEdge_level1);
+            fFreeHandle(verticalEdge_level2);
+            fFreeHandle(horizontalEdge_level1);
+            fFreeHandle(horizontalEdge_level2);
+            fFreeHandle(previousFrameBlurred_level1);
+            fFreeHandle(previousFrameBlurred_level2);
+            //printf("height = %d, width = %d, numFind = %d\n", newpoints->height, newpoints->width);
+            
+            /** Populate newpoints with features that had correspondence with previous frame features **/
+            np_temp = fDeepCopy(newpoints);
+            if(status->width > 0 )
+            {
+                k = 0;
+                numFind=0;
+                for(i=0; i<status->width; i++)
+                {
+                    if( asubsref(status,i) == 1)
+                        numFind++;
+                }
+                fFreeHandle(newpoints);
+                newpoints = fSetArray(2, numFind, 0);
+        
+                for(i=0; i<status->width; i++)
+                {
+                    if( asubsref(status,i) == 1)
+                    {
+                        subsref(newpoints,0,k) = subsref(np_temp,0,i);
+                        subsref(newpoints,1,k++) = subsref(np_temp,1,i);
+                    }
+                }    
+            }    
+            
+            iFreeHandle(status);
+            fFreeHandle(np_temp);
+            fFreeHandle(features);
+        
+            /** Populate newpoints into features **/
+            features = fDeepCopy(newpoints);
+            fFreeHandle(newpoints);
+        }
+    }
+    printf("end..\n");
+#ifdef CHECK   
+    /* Self checking */
+    {
+        int ret=0;
+        float tol = 2.0;
+#ifdef GENERATE_OUTPUT
+        fWriteMatrix(features, argv[1]);
+#endif
+        ret = fSelfCheck(features, "expected_C.txt", tol); 
+        if (ret == -1)
+            printf("Error in Tracking Map\n");
+    }
+#endif
+    
+    fFreeHandle(blurred_level1);
+    fFreeHandle(blurred_level2);
+    fFreeHandle(features);
+    for(count=1; count<=counter; count++)
+    {
+        free(images[count - 1] );
+    }
+    iFreeHandle(Ic);
+    WRITE_TO_FILE
+    return 0;
+}
diff --git a/SD-VBS/benchmarks/tracking/src/c/tracking.h b/SD-VBS/benchmarks/tracking/src/c/tracking.h
new file mode 100644
index 0000000..24b8b2d
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/src/c/tracking.h
@@ -0,0 +1,20 @@
+/********************************
+Author: Sravanthi Kota Venkata
+********************************/
+#ifndef _SCRIPT_TRACK_
+#define _SCRIPT_TRACK_
+#include "sdvbs_common.h"
+F2D* calcAreaSum(F2D* src, int cols, int rows, int winSize);
+F2D* calcGoodFeature(F2D* dX, F2D* dY, int cols, int rows, int winSize);
+I2D* calcPyrLKTrack(F2D* ip1, F2D* ip2, F2D* idxp1, F2D* idxp2, F2D* idyp1, F2D* idyp2, F2D* jp1, F2D* jp2, F2D* fPnt, int nFeatures, int winSize, float accuracy, int maxIter, F2D* newPnt);
+F2D *getANMS (F2D *points, float r);
+F2D* getInterpolatePatch(F2D* src, int cols, float centerX, float centerY, int winSize);
+float polynomial(int d, F2D* a, F2D* b, int dim);
+I2D* sortInd(F2D* input, int dim);
+F2D* fillFeatures(F2D* lambda, int N_FEA, int win);
+#endif
diff --git a/SD-VBS/benchmarks/tracking/src/matlab/Filtering.m b/SD-VBS/benchmarks/tracking/src/matlab/Filtering.m
new file mode 100755
index 0000000..d42ebb7
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/src/matlab/Filtering.m
@@ -0,0 +1,30 @@
+function imageOut = Filtering(imageIn, rows, cols, kernel, kernelSize)
+imageOut = zeros(rows, cols);%initalize output image to all zeros
+imageIn = double(imageIn);%convert to double to allow image arithmetic
+ intialCol = ((kernelSize+1)/2);
+ endCol = round(cols - ((kernelSize+1)/2));
+ halfKernel = (kernelSize-1)/2;
+ 
+ initialRow = ((kernelSize+1)/2);
+ endRow = (rows - ((kernelSize+1)/2));
+ 
+ %% Start 1-D filtering row-wise first.
+ 
+ for i=initialRow:endRow
+     for j=initialCol:endCol
+     imageOut(i,j) = sum(imageIn(i,j-halfKernel:j+halfKernel).*kernel)/sum(kernel);%actual filtering step
+     end
+ end
+ 
+ %% Start 1-D filtering col-wise first.
+ 
+% kernelT = kernel';
+% for i=initialRow:endRow
+%     for j=initialCol:endCol
+%     imageOut(i,j) = sum(imageOut(i-halfKernel:i+halfKernel,j).*kernelT)/sum(kernel);%kernel to be transposed for performing multiplcation
+%     end
+% end
+% 
+% %imshow(uint8(imageOut));
diff --git a/SD-VBS/benchmarks/tracking/src/matlab/calcAreaSum.m b/SD-VBS/benchmarks/tracking/src/matlab/calcAreaSum.m
new file mode 100755
index 0000000..f8dd3da
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/src/matlab/calcAreaSum.m
@@ -0,0 +1,48 @@
+%calcAreaSum:
+% sizeX = cols
+% sizeY = rows
+function ret = calcAreaSum(src, sizeX, sizeY, winSize, dataDir)
+src = double(src);
+nave = winSize;
+nave_half = floor((nave+1)/2);
+a1=zeros(1,sizeX+nave);
+    
+for i=1:sizeY
+        %pull out one row
+        for j=1:sizeX
+                a1(j+nave_half)=src(i,j);
+        end
+        a1sum=0;
+        %sum up values within a window
+        for k=1:nave
+                a1sum = a1sum+a1(k);
+        end
+        for j=1:sizeX
+                ret(i,j) = a1sum;
+                a1sum = a1sum + a1(j+nave) - a1(j);
+        end
+end
+a1=zeros(1,sizeY+nave);
+for i=1:sizeX
+        %pull out one col
+        for j=1:sizeY
+                a1(j+nave_half)=ret(j,i);
+        end
+        a1sum=0;
+        %sum up values within a window
+        for k=1:nave
+                a1sum = a1sum+a1(k);
+        end
+        for j=1:sizeY
+                ret(j,i) = a1sum;
+                a1sum = a1sum + a1(j+nave) - a1(j);
+        end
+end
diff --git a/SD-VBS/benchmarks/tracking/src/matlab/calcGoodFeature.m b/SD-VBS/benchmarks/tracking/src/matlab/calcGoodFeature.m
new file mode 100755
index 0000000..b83faa6
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/src/matlab/calcGoodFeature.m
@@ -0,0 +1,28 @@
+%calcGoodFeature:
+function [lambda, tr, det,c_xx, c_xy, c_yy] = calcGoodFeature(dX, dY, sizeX, sizeY, winSize, dataDir) 
+    for i=1:sizeY
+        for j=1:sizeX
+                xx(i,j)=dX(i,j)*dX(i,j);
+                xy(i,j)=dX(i,j)*dY(i,j);
+            yy(i,j)=dY(i,j)*dY(i,j);
+        end
+    end
+    
+        c_xx=calcAreaSum(xx, sizeX, sizeY, winSize,dataDir);
+    c_xy=calcAreaSum(xy, sizeX, sizeY, winSize,dataDir);
+        c_yy=calcAreaSum(yy, sizeX, sizeY, winSize,dataDir);
+ 
+        for i=1:sizeY
+        for j=1:sizeX
+                tr(i,j)= c_xx(i,j)+c_yy(i,j);
+                det(i,j)= c_xx(i,j)*c_yy(i,j)-c_xy(i,j)*c_xy(i,j);
+%             if( tr(i,j) == 0 )
+%                 lambda(i,j) = 0;
+%             else
+                lambda(i,j)=det(i,j)/(tr(i,j) + 0.00001);
+%            end
+        end
+    end
+ 
diff --git a/SD-VBS/benchmarks/tracking/src/matlab/calcPyrLKTrack.m b/SD-VBS/benchmarks/tracking/src/matlab/calcPyrLKTrack.m
new file mode 100755
index 0000000..c965c2b
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/src/matlab/calcPyrLKTrack.m
@@ -0,0 +1,108 @@
+function [newFPnt, valid] = calcPyrLKTrack(iP, iDxP, iDyP, jP, fPnt, nFeatures, winSize, accuracy_th, max_iter)
+        
+cellDims = size(iP);
+GOOD_FEATURE_LAMBDA_TH = accuracy_th;
+for i=1:(cellDims(1))
+    curImgDims = size(iP{i});
+        imgDims(i,1)= curImgDims(1);
+        imgDims(i,2)= curImgDims(2);
+end
+pLevel = cellDims(1);
+rate=[1, 0.5, 0.25, 0.125, 0.0625, 0.03125];
+winSizeSq=4*winSize*winSize;
+iPatch=cell(1, winSizeSq);
+jPatch=cell(1, winSizeSq);
+iDxPatch=cell(1,winSizeSq);
+iDyPatch=cell(1,winSizeSq);
+valid(1:nFeatures) = 1;
+newFPnt = zeros(2,nFeatures);
+for i=1:nFeatures
+    dX=0;
+    dY=0;
+%% x is rows here and y is cols
+    
+    x=fPnt(1,i)*rate(pLevel+1);                 %half size of real level
+    y=fPnt(2,i)*rate(pLevel+1);
+    for level=pLevel:-1:1
+        x = x+x;
+        y = y+y;
+        dX = dX+dX;
+        dY = dY+dY;
+        imgSize(1)=imgDims(level,1); %y,x               
+        imgSize(2)=imgDims(level,2); %y,x               
+        c_xx = 0;
+        c_xy = 0;
+        c_yy = 0;
+            
+        %when feature goes out to the boundary.
+        if ((x-winSize)<1 || (y-winSize)<1 || (y+winSize+1)>imgSize(1) || (x+winSize+1)>imgSize(2))
+            %winSize+1due to interpolation
+            %error or skip the level??
+            valid(i) = 0;
+            break;
+        end
+        
+        iPatch = getInterpolatePatch(iP{level}, imgSize(1), imgSize(2), x, y, winSize);
+        iDxPatch = getInterpolatePatch(iDxP{level}, imgSize(1), imgSize(2), x, y, winSize);
+        iDyPatch = getInterpolatePatch(iDyP{level}, imgSize(1), imgSize(2), x, y, winSize);
+        for idx=1:winSizeSq
+            c_xx = c_xx + iDxPatch(idx) * iDxPatch(idx);
+            c_xy = c_xy + iDxPatch(idx) * iDyPatch(idx);
+            c_yy = c_yy + iDyPatch(idx) * iDyPatch(idx);
+        end
+        c_det = c_xx * c_yy - c_xy * c_xy;
+        
+        if (c_det/(c_xx+c_yy+0.00001)) < GOOD_FEATURE_LAMBDA_TH
+            valid(i)=0;
+            break;
+        end
+        c_det=1/c_det;
+        for k=1:max_iter
+            if ((x+dX-winSize)<1 || (y+dY-winSize)<1 || (y+dY+winSize+1)>imgSize(1) || (x+dX+winSize+1)>imgSize(2))
+                %winSize+1due to interpolation
+                %error or skip the level??
+                valid(i)=0;
+                break;
+            end
+            jPatch = getInterpolatePatch(jP{level}, imgSize(1), imgSize(2), x+dX, y+dY, winSize);
+            eX = 0;
+            eY = 0;
+            for idx=1:winSizeSq
+                dIt = iPatch(idx) - jPatch(idx);
+                eX = eX + (dIt*iDxPatch(idx));
+                eY = eY + (dIt*iDyPatch(idx));
+            end
+            mX = c_det*(eX*c_yy-eY*c_xy);
+            mY = c_det*(-eX*c_xy+eY*c_xx);
+            dX = dX + mX;
+            dY = dY + mY;
+            if ((mX*mX+mY*mY)<accuracy_th)
+                break;
+            end
+        end
+    end
+    
+    newFPnt(1, i) = fPnt(1,i)+dX;
+    newFPnt(2, i) = fPnt(2,i)+dY;
+end
diff --git a/SD-VBS/benchmarks/tracking/src/matlab/calcSobel.m b/SD-VBS/benchmarks/tracking/src/matlab/calcSobel.m
new file mode 100755
index 0000000..8617c25
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/src/matlab/calcSobel.m
@@ -0,0 +1,74 @@
+function [Dx, Dy] = calcSobel(imageIn)
+imsize = size(imageIn);
+rows = imsize(1);
+cols = imsize(2);
+Dx = zeros(rows, cols);     %initalize output image to all zeros
+Dy = zeros(rows, cols);     %initalize output image to all zeros
+imageIn = double(imageIn);  %convert to double to allow image arithmetic
+kernel_1 = [1 2 1];
+kernel_2 = [1 0 -1];
+kernelSize = 3;
+sum_kernel_1 = 4;
+sum_kernel_2 = 2;
+startCol = 2;           %((kernelSize+1)/2);
+endCol = cols - 1;      %round(cols - ((kernelSize+1)/2));
+halfKernel = 1;         %(kernelSize-1)/2;
+startRow = 2;           %((kernelSize+1)/2);
+endRow = rows - 1;      %(rows - ((kernelSize+1)/2));
+%imshow(uint8(imageIn));
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Calculate Gx (gradient in X-dir)
+%% Gx = ([1 2 1]') * ([1 0 -1] * imageIn)
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Start 1-D filtering row-wise first.
+tempOut = zeros(rows, cols);%initalize temp image to all zeros
+for i=startRow:endRow
+   for j=startCol:endCol
+       tempOut(i,j) = sum(imageIn(i,j-halfKernel:j+halfKernel).*kernel_2)/sum_kernel_2;%actual filtering step
+   end
+end
+% Start 1-D filtering col-wise first.
+for i=startRow:endRow
+   for j=startCol:endCol
+       Dx(i,j) = sum(tempOut(i-halfKernel:i+halfKernel,j).*kernel_1')/sum_kernel_1;%kernel to be transposed for performing multiplcation
+       Dx(i,j) = Dx(i,j);% + 128;
+   end
+end
+%imshow(uint8(Dx));
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Calculate Gy (gradient in Y-dir)
+%% Gy = ([1 0 -1]') * ([1 2 1] * imageIn)
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Start 1-D filtering row-wise first.
+for i=startRow:endRow
+    for j=startCol:endCol
+        tempOut(i,j) = sum(imageIn(i-halfKernel:i+halfKernel,j).*kernel_2')/sum_kernel_2;%kernel to be transposed for performing multiplcation
+    end
+end
+for i=startRow:endRow
+    for j=startCol:endCol
+        Dy(i,j) = sum(tempOut(i,j-halfKernel:j+halfKernel).*kernel_1)/sum_kernel_1;
+    end
+end
+%imshow(uint8(Dy));
diff --git a/SD-VBS/benchmarks/tracking/src/matlab/getInterpolatePatch.m b/SD-VBS/benchmarks/tracking/src/matlab/getInterpolatePatch.m
new file mode 100755
index 0000000..d0a64d3
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/src/matlab/getInterpolatePatch.m
@@ -0,0 +1,22 @@
+function [dstImg] = getInterpolatePatch(srcImg,rows, cols,centerX,centerY,winSize)
+a=centerX-floor(centerX);
+b=centerY-floor(centerY);
+a11=(1-a)*(1-b);
+a12=a*(1-b);
+a21=(1-a)*b;
+a22=a*b;
+for i=-winSize:winSize-1
+        srcIdxx=floor(centerY)+i;
+        dstIdxx=i+winSize+1;
+        for j=-winSize:winSize-1
+                srcIdx = srcIdxx * cols + floor(centerX) + j;
+                dstIdx = dstIdxx*2*winSize+j+winSize+1;
+                dstImg(dstIdx)=srcImg(srcIdxx, floor(centerX)+j)*a11;
+        dstImg(dstIdx)= dstImg(dstIdx) + srcImg(srcIdxx, floor(centerX)+j+1)*a12;
+        dstImg(dstIdx)= dstImg(dstIdx) + srcImg(srcIdxx+1, floor(centerX)+j)*a21;
+        dstImg(dstIdx)= dstImg(dstIdx) + srcImg(srcIdxx+1, floor(centerX)+j+1)*a22;
+    end
+end
diff --git a/SD-VBS/benchmarks/tracking/src/matlab/getPyramid.m b/SD-VBS/benchmarks/tracking/src/matlab/getPyramid.m
new file mode 100755
index 0000000..845456a
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/src/matlab/getPyramid.m
@@ -0,0 +1,10 @@
+function pyr=getPyramid(img, level)
+kernel=[1/16,1/4,3/8,1/4,1/16];
+pyr=cell(level,1);
+pyr{1}=double(img);
+for i=2:level
+%    imgBlur=conv2(pyr{i-1}, kernel, 'same');
+%    imgBlur=conv2(imgBlur, kernel, 'same');
+%    pyr{i}=imgBlur(1:2:end, 1:2:end);
+    pyr{i}=calcResizedImgMex(pyr{i-1});
+end
diff --git a/SD-VBS/benchmarks/tracking/src/matlab/imageBlur.m b/SD-VBS/benchmarks/tracking/src/matlab/imageBlur.m
new file mode 100755
index 0000000..fd6c199
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/src/matlab/imageBlur.m
@@ -0,0 +1,36 @@
+function imageOut = imageBlur(imageIn)
+imsize = size(imageIn);
+rows = imsize(1);
+cols = imsize(2);
+imageOut = zeros(rows, cols);%initalize output image to all zeros
+imageIn = double(imageIn);%convert to double to allow image arithmetic
+kernel = [1 4 6 4 1];
+kernelSize = 5;
+startCol = 3;       %((kernelSize+1)/2);
+endCol = cols - 2;  %round(cols - ((kernelSize+1)/2));
+halfKernel = 2;     %(kernelSize-1)/2;
+startRow = 3;       %((kernelSize+1)/2);
+endRow = rows - 2;  %(rows - ((kernelSize+1)/2));
+%% Start 1-D filtering row-wise first.
+tempOut = zeros(rows, cols);%initalize temp image to all zeros
+for i=startRow:endRow
+    for j=startCol:endCol
+        tempOut(i,j) = sum(imageIn(i,j-halfKernel:j+halfKernel).*kernel)/sum(kernel);%actual filtering step
+    end
+end
+%% Start 1-D filtering col-wise first.
+for i=startRow:endRow
+    for j=startCol:endCol
+    imageOut(i,j) = sum(tempOut(i-halfKernel:i+halfKernel,j).*kernel')/sum(kernel);%kernel to be transposed for performing multiplcation
+    end
+end
diff --git a/SD-VBS/benchmarks/tracking/src/matlab/imageResize.m b/SD-VBS/benchmarks/tracking/src/matlab/imageResize.m
new file mode 100755
index 0000000..e5fa7b8
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/src/matlab/imageResize.m
@@ -0,0 +1,50 @@
+function [imageOut] = imageResize(imageIn)
+ imageIn = double(imageIn);
+ imsize = size(imageIn);
+ rows = imsize(1);
+ cols = imsize(2);
+ 
+ %% level 1 is the base image.
+ 
+ outputRows = floor((rows+1)/2);
+ outputCols = floor((cols+1)/2);
+ 
+ kernel = [1,4,6,4,1];
+ kernelSize = 5;
+ 
+ temp = zeros(rows, outputCols);%initalize output image to all zeros
+ imageOut = zeros(outputRows, outputCols);%initalize output image to all zeros
+ imageIn = double(imageIn);%convert to double to allow image arithmetic
+ 
+ initialCol = 3;        %((kernelSize+1)/2);
+ endCol = cols - 2;     %round(cols - ((kernelSize+1)/2));
+ halfKernel = 2;        %(kernelSize-1)/2;
+ 
+ initialRow = 3;        %((kernelSize+1)/2);
+ endRow = rows - 2;     %(rows - ((kernelSize+1)/2));
+ %% Start 1-D filtering row-wise first.
+ 
+ for i=initialRow:endRow
+     k = 1;
+     for j=initialCol:2:endCol
+         temp(i,k) = sum(imageIn(i,j-halfKernel:j+halfKernel).*kernel)/sum(kernel);%actual filtering step
+         k = k+1;
+     end
+ end
+ 
+ %imshow(uint8(temp));
+ 
+ %% Start 1-D filtering col-wise first.
+% 
+ kernelT = kernel';
+ j = 1;
+ for i=initialRow:2:endRow
+     for k=1:outputCols
+         imageOut(j,k) = sum(temp(i-halfKernel:i+halfKernel,k).*kernelT)/sum(kernel);%kernel to be transposed for performing multiplcation
+     end
+     j = j + 1;
+ end
+ 
+% %imshow(uint8(imageOut));
diff --git a/SD-VBS/benchmarks/tracking/src/matlab/rgb2gray_f2_f3.m b/SD-VBS/benchmarks/tracking/src/matlab/rgb2gray_f2_f3.m
new file mode 100755
index 0000000..23397a3
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/src/matlab/rgb2gray_f2_f3.m
@@ -0,0 +1,16 @@
+%! _rgb2gray_f2_f3
+function grayImage = rgb2gray_f2_f3(colorImage)
+%0.2989 * R + 0.5870 * G + 0.1140 * B
+rows = size(colorImage, 1);
+cols = size(colorImage, 2);
+rgb = size(colorImage, 3);
+grayImage = zeros(rows, cols);
+for i = 1:rows
+    for j = 1:cols
+        grayImage(i,j) = 0.2989 * colorImage(i,j,1) + 0.5870 * colorImage(i,j,2) + 0.1140 * colorImage(i,j,3);
+    end
+end
+    
+\ No newline at end of file
diff --git a/SD-VBS/benchmarks/tracking/src/matlab/script_run_profile.m b/SD-VBS/benchmarks/tracking/src/matlab/script_run_profile.m
new file mode 100755
index 0000000..62d367f
--- /dev/null
+++ b/SD-VBS/benchmarks/tracking/src/matlab/script_run_profile.m
@@ -0,0 +1,178 @@
+function script_run_profile(dataDir, resultDir, type, common, toolDir)
+if(~isdeployed)
+    addpath(fullfile(toolDir, '/lagrcv/'));
+    addpath(fullfile(toolDir, '/toolbox_basic/filter/'));
+    addpath(fullfile(toolDir, '/ikkjin/'));
+end
+IMAGE_DIR=dataDir;
+path(path,common); 
+tol = 2;
+%% Input params
+N_FEA=1600;
+WINSZ=4; %size of sum-up window
+NO_PYR=2;
+SUPPRESION_RADIUS=10;
+LK_ITER=20;
+counter = 2;
+accuracy = 0.03;
+if(strcmp(type,'test'))
+    WINSZ = 2;
+    N_FEA = 10;
+    LK_ITER = 2;
+    counter = 2;
+    accuracy = 0.1;
+elseif(strcmp(type, 'sim_fast'))
+    WINSZ = 2;
+    N_FEA = 100;
+    LK_ITER = 2;
+    counter = 4;
+elseif(strcmp(type,'sim'))
+    WINSZ = 2;
+    N_FEA = 200;
+    LK_ITER = 2;
+    counter = 4;
+elseif(strcmp(type,'sqcif'))
+    WINSZ = 8;
+    N_FEA = 500;
+    LK_ITER = 15;
+    counter = 2;
+elseif(strcmp(type, 'qcif'))
+    WINSZ = 12;
+    N_FEA = 400;
+    LK_ITER = 15;
+    counter = 4;
+elseif(strcmp(type,'cif'))
+    WINSZ = 20;
+    N_FEA = 500;
+    LK_ITER = 20;
+    counter = 4;
+elseif(strcmp(type, 'vga'))
+    WINSZ = 32;
+    N_FEA = 400;
+    LK_ITER = 20;
+    counter = 4;
+elseif(strcmp(type,'fullhd'))
+    WINSZ = 48;
+    N_FEA = 500;
+    LK_ITER = 20;
+    counter = 4;
+elseif(strcmp(type,'wuxga'))
+    WINSZ = 64;
+    N_FEA = 500;
+    LK_ITER = 20;
+    counter = 4;
+end
+imgName = [dataDir, '/1.bmp'];
+Icur=readImage(imgName);
+[rows,cols] = size(Icur);
+fprintf(1,'Input size\t\t- (%dx%d)\n', rows, cols);
+%% Timing
+start = photonStartTiming;
+Icur = imageBlur(double(Icur));
+ Jpyr = cell(2,1);
+ Jpyr{1} = Icur;
+ Jpyr{2} = imageResize(Icur);
+ [dX, dY] = calcSobel(double(Icur));
+ sizeWin = size(dX);
+ [lambda, tr, det, c_xx, c_xy, c_yy] = calcGoodFeature(dX, dY, sizeWin(2), sizeWin(1), WINSZ, dataDir);
+imgsz=size(lambda);
+lambda([1:WINSZ,end-WINSZ:end],:)=0;
+lambda(:,[1:WINSZ,end-WINSZ:end])=0;
+[temp,idx]=sort(lambda(:), 'descend');
+featureIdx=idx(1:N_FEA);
+features=zeros(3, N_FEA);
+features(1,:)=ceil(featureIdx/imgsz(1));
+fIdxT = featureIdx';
+features(2,:)=fIdxT-(features(1,:)-1)*imgsz(1);
+features(3,:)=lambda(featureIdx);
+for i=1:N_FEA
+    features(3,i) = lambda(idx(i));
+end
+f1T = features(1,:)';
+f2T = features(2,:)';
+f3T = features(3,:)';
+interestPnt=getANMS(f1T, f2T, f3T, SUPPRESION_RADIUS, dataDir);
+interestPnt=interestPnt';
+features=interestPnt(1:2,:);
+    
+%% Timing
+endC = photonEndTiming;
+elapsed = photonReportTiming(start, endC);
+for iter=1:counter
+    imgName = [dataDir, '/', num2str(iter),  '.bmp'];
+    Iprev=Icur;
+    Icur=readImage(imgName);
+    
+    %% Self check params
+    tol = 0.1;
+    %% Timing
+    start = photonStartTiming;
+    Icur = imageBlur(double(Icur));
+    
+    Ipyr=Jpyr;
+    
+    Jpyr = cell(2,1);
+    Jpyr{1} = Icur;
+    Jpyr{2} = imageResize(Icur);
+    dxPyr = cell(2,1);
+    dyPyr = cell(2,1);
+     
+    [dxPyr{1}, dyPyr{1}] = calcSobel(Jpyr{1});
+    [dxPyr{2}, dyPyr{2}] = calcSobel(Jpyr{2});
+    
+    sizeWin = size(dxPyr{2});
+    nFeatures = size(features);
+     
+    [newpoints, currStatus] = calcPyrLKTrack(Ipyr, dxPyr, dyPyr, Jpyr, double(features), nFeatures(2), WINSZ, 0.03, LK_ITER);
+    
+    newpoints=newpoints(:,find(currStatus));
+    %% Timing
+    stop = photonEndTiming;
+    temp = photonReportTiming(start, stop);
+    elapsed(1) = elapsed(1) + temp(1);
+    elapsed(2) = elapsed(2) + temp(2);
+%      figure(1);
+%      imagesc(Icur);colormap gray
+%      hold on;
+%      scatter(newpoints(1,:), newpoints(2,:), 'r+');
+%      hold off;    
+%      drawnow
+%     
+    features=newpoints;
+end
+    
+%% Self checking
+fWriteMatrix(features, dataDir);
+photonPrintTiming(elapsed);
+if(~isdeployed)
+    rmpath(fullfile(toolDir, '/lagrcv/'));
+    rmpath(fullfile(toolDir, '/toolbox_basic/filter/'));
+    rmpath(fullfile(toolDir, '/ikkjin/'));
+end