From: yeom <yeom>
Date: Sun, 1 Aug 2010 03:48:36 +0000 (+0000)
Subject: add tracking benchmark
X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=509363ab4ecdd344f28f5972f308362403afcca2;p=IRC.git

add tracking benchmark
---

diff --git a/Robust/src/Benchmarks/oooJava/tracking/1.bmp b/Robust/src/Benchmarks/oooJava/tracking/1.bmp
new file mode 100644
index 00000000..06a8c3d9
Binary files /dev/null and b/Robust/src/Benchmarks/oooJava/tracking/1.bmp differ
diff --git a/Robust/src/Benchmarks/oooJava/tracking/BlurPiece.java b/Robust/src/Benchmarks/oooJava/tracking/BlurPiece.java
new file mode 100644
index 00000000..20bd359b
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/BlurPiece.java
@@ -0,0 +1,138 @@
+public class BlurPiece {
+    
+    /* current processing image related */
+    int[] m_image;
+    int m_rows;
+    int m_cols;
+    
+    /* results related */
+    float[] m_result;
+    int m_rows_rs;
+    int m_rows_re;
+    int m_cols_r;
+    
+    /* id indicating the piece # */
+    int m_id;  
+    int m_range;
+
+    /* constructor */
+    public BlurPiece(int id,
+                     int range,
+                     int[] data) {
+      this.m_id = id;
+      this.m_range = range;
+      this.m_image = data;
+      this.m_rows = data[0];
+      this.m_cols = data[1];
+    }
+    
+    public int getId() {
+      return this.m_id;
+    }
+    
+    public int getRows() {
+      return this.m_rows;
+    }
+    
+    public int getCols() {
+      return this.m_cols;
+    }
+    
+    public float[] getResult() {
+      return this.m_result;
+    }
+    
+    public int getRowsRS() {
+      return this.m_rows_rs;
+    }
+    
+    public int getRowsRE() {
+      return this.m_rows_re;
+    }
+    
+    public int getColsR() {
+      return this.m_cols_r;
+    }
+    
+    public void blur() {
+      int rows, cols;
+      float temp;
+      int[] kernel, imageIn;
+      int rows_k, cols_k;
+      int k, i, j;
+      int kernelSize, startCol, endCol, halfKernel, startRow, endRow, kernelSum;
+      int[] inputs;
+      float[] image;
+
+      inputs = this.m_image;
+      rows = this.m_rows;
+      cols = this.m_cols;
+      this.m_rows_rs = this.m_id * this.m_range;
+      this.m_rows_re = (this.m_id + 1) * this.m_range;
+      if(rows < this.m_rows_re) {
+        this.m_rows_re = rows;
+      }
+      this.m_cols_r = this.m_cols;
+      image = this.m_result = new float[(this.m_rows_re-this.m_rows_rs)*cols];
+
+      kernel = new int[5];
+      rows_k = 1;
+      cols_k = 5;
+
+      kernel[0] = 1;
+      kernel[1] = 4;
+      kernel[2] = 6;
+      kernel[3] = 4;
+      kernel[4] = 1;
+
+      kernelSize = 5;
+      kernelSum = 16;
+
+      startCol = 2;       //((kernelSize)/2);
+      endCol = cols - 2;  //round(cols - (kernelSize/2));
+      halfKernel = 2;     //(kernelSize-1)/2;
+
+      if((this.m_rows_re <= 2) || (this.m_rows_rs >= rows - 2)) {
+        return;
+      }
+      startRow = (2>this.m_rows_rs)?2:(this.m_rows_rs);       //(kernelSize)/2;
+      endRow = ((rows-2)<this.m_rows_re)?(rows-2):(this.m_rows_re);  //(rows - (kernelSize)/2);
+      
+      int ii = startRow - this.m_rows_rs;
+      for(i=startRow; i<endRow; i++){
+        for(j=startCol; j<endCol; j++) {
+          temp = 0;
+          for(k=-halfKernel; k<=halfKernel; k++) {
+            temp += (float)((inputs[4 + i * cols + (j+k)] 
+                                    * (float)(kernel[k+halfKernel])));
+          }
+
+          image[ii * cols + j] = (float)(temp/kernelSum);
+        }
+        ii++;
+      }
+
+      /*ii = startRow - this.m_rows_rs;
+      for(i=startRow; i<endRow; i++) {
+        for(j=startCol; j<endCol; j++) {
+          temp = 0;
+          for(k=-halfKernel; k<=halfKernel; k++)  {
+            temp += (float)((image[(ii+k) * cols + j] 
+                                   * (float)(kernel[k+halfKernel])));
+          }
+          image[ii * cols + j] = (float)(temp/kernelSum);
+        }
+        ii++;
+      }*/
+    }
+    
+    public void printImage() {
+      //    result validation
+      System.printI(33333333);
+      for(int i=0; i<this.m_rows; i++) {
+          for(int j=0; j<this.m_cols; j++) {
+              System.printI(this.m_image[i * this.m_cols + j + 4]);
+          }
+      }
+    }
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/tracking/BlurPieceL.java b/Robust/src/Benchmarks/oooJava/tracking/BlurPieceL.java
new file mode 100644
index 00000000..0c08727b
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/BlurPieceL.java
@@ -0,0 +1,138 @@
+public class BlurPieceL {
+    
+    /* current processing image related */
+    int[] m_image;
+    int m_rows;
+    int m_cols;
+    
+    /* results related */
+    float[] m_result;
+    int m_rows_rs;
+    int m_rows_re;
+    int m_cols_r;
+    
+    /* id indicating the piece # */
+    int m_id;  
+    int m_range;
+
+    /* constructor */
+    public BlurPieceL(int id,
+                      int range,
+                      int[] data) {
+      this.m_id = id;
+      this.m_range = range;
+      this.m_image = data;
+      this.m_rows = data[0];
+      this.m_cols = data[1];
+    }
+    
+    public int getId() {
+      return this.m_id;
+    }
+    
+    public int getRows() {
+      return this.m_rows;
+    }
+    
+    public int getCols() {
+      return this.m_cols;
+    }
+    
+    public float[] getResult() {
+      return this.m_result;
+    }
+    
+    public int getRowsRS() {
+      return this.m_rows_rs;
+    }
+    
+    public int getRowsRE() {
+      return this.m_rows_re;
+    }
+    
+    public int getColsR() {
+      return this.m_cols_r;
+    }
+    
+    public void blur() {
+      int rows, cols;
+      float temp;
+      int[] kernel, imageIn;
+      int rows_k, cols_k;
+      int k, i, j;
+      int kernelSize, startCol, endCol, halfKernel, startRow, endRow, kernelSum;
+      int[] inputs;
+      float[] image;
+
+      inputs = this.m_image;
+      rows = this.m_rows;
+      cols = this.m_cols;
+      this.m_rows_rs = this.m_id * this.m_range;
+      this.m_rows_re = (this.m_id + 1) * this.m_range;
+      if(rows < this.m_rows_re) {
+        this.m_rows_re = rows;
+      }
+      this.m_cols_r = this.m_cols;
+      image = this.m_result = new float[(this.m_rows_re-this.m_rows_rs)*cols];
+
+      kernel = new int[5];
+      rows_k = 1;
+      cols_k = 5;
+
+      kernel[0] = 1;
+      kernel[1] = 4;
+      kernel[2] = 6;
+      kernel[3] = 4;
+      kernel[4] = 1;
+
+      kernelSize = 5;
+      kernelSum = 16;
+
+      startCol = 2;       //((kernelSize)/2);
+      endCol = cols - 2;  //round(cols - (kernelSize/2));
+      halfKernel = 2;     //(kernelSize-1)/2;
+
+      if((this.m_rows_re <= 2) || (this.m_rows_rs >= rows - 2)) {
+        return;
+      }
+      startRow = (2>this.m_rows_rs)?2:(this.m_rows_rs);       //(kernelSize)/2;
+      endRow = ((rows-2)<this.m_rows_re)?(rows-2):(this.m_rows_re);  //(rows - (kernelSize)/2);
+      
+      int ii = startRow - this.m_rows_rs;
+      for(i=startRow; i<endRow; i++){
+        for(j=startCol; j<endCol; j++) {
+          temp = 0;
+          for(k=-halfKernel; k<=halfKernel; k++) {
+            temp += (float)((inputs[4 + i * cols + (j+k)] 
+                                    * (float)(kernel[k+halfKernel])));
+          }
+
+          image[ii * cols + j] = (float)(temp/kernelSum);
+        }
+        ii++;
+      }
+
+      /*ii = startRow - this.m_rows_rs;
+      for(i=startRow; i<endRow; i++) {
+        for(j=startCol; j<endCol; j++) {
+          temp = 0;
+          for(k=-halfKernel; k<=halfKernel; k++)  {
+            temp += (float)((image[(ii+k) * cols + j] 
+                                   * (float)(kernel[k+halfKernel])));
+          }
+          image[ii * cols + j] = (float)(temp/kernelSum);
+        }
+        ii++;
+      }*/
+    }
+    
+    public void printImage() {
+      //    result validation
+      System.printI(33333333);
+      for(int i=0; i<this.m_rows; i++) {
+          for(int j=0; j<this.m_cols; j++) {
+              System.printI(this.m_image[i * this.m_cols + j + 4]);
+          }
+      }
+    }
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/tracking/IDX.java b/Robust/src/Benchmarks/oooJava/tracking/IDX.java
new file mode 100644
index 00000000..c5d5ca95
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/IDX.java
@@ -0,0 +1,125 @@
+public class IDX {
+    /* current processing image related */
+    float[] m_image;
+    int m_rows;
+    int m_cols;
+    int m_r;
+    
+    /* results related */
+    int m_rows_rs;
+    int m_rows_re;
+    int m_cols_r;
+    int[] m_ind;
+    
+    /* benchmark constants */
+    public int N_FEA;
+    
+    /* id indicating the piece # */
+    int m_id;  
+    int m_range;
+
+    /* constructor */
+    public IDX(int nfea,
+               int id,
+               int range,
+               float[] data,
+               int rows,
+               int cols,
+               int r) {
+      this.N_FEA = nfea;
+      
+      this.m_id = id;
+      this.m_range = range;
+      
+      this.m_image = data;
+      this.m_rows = rows;
+      this.m_cols = cols;
+      this.m_r = r;
+
+      this.m_rows_rs = this.m_id * this.m_range;
+      this.m_rows_re = (this.m_id + 1) * this.m_range;
+      this.m_cols_r = cols;
+      
+      this.m_ind = new int[(this.m_rows_re - this.m_rows_rs) * this.m_cols_r];
+    }
+    
+    public int getR() {
+      return this.m_r;
+    }
+    
+    public int getRows() {
+      return this.m_rows;
+    }
+    
+    public int getCols() {
+      return this.m_cols;
+    }
+    
+    public float[] getImage() {
+      return this.m_image;
+    }
+    
+    public int[] getInd() {
+      return this.m_ind;
+    }
+    
+    public int getRowsRS() {
+      return this.m_rows_rs;
+    }
+    
+    public int getRowsRE() {
+      return this.m_rows_re;
+    }
+    
+    public int getColsR() {
+      return this.m_cols_r;
+    }
+    
+    public void fSortIndices() {
+      int i, j, k, startRow, endRow;
+      int[] ind;
+      int rows_i, cols_i;
+      float[] image;
+
+      image = this.m_image;
+      
+      rows_i = this.m_rows;
+      cols_i = this.m_cols;
+      ind = this.m_ind;
+
+      startRow = this.m_rows_rs;  
+      endRow = this.m_rows_re;
+      int ii = 0;
+      for(k=0; k<cols_i; k++) {
+        for(i=0; i<rows_i; i++) {
+          float local = image[i * cols_i + k];
+          ii = 0;
+          for(j=startRow; j<endRow; j++) {
+            if(local <= image[j*cols_i+k]) {
+              ind[ii * cols_i + k]++;
+            }
+            ii++;
+          }
+        }
+      }
+    }
+    
+    public void printImage() {
+      //    result validation
+      for(int i=0; i<this.m_rows; i++) {
+          for(int j=0; j<this.m_cols; j++) {
+              System.printI((int)(this.m_image[i * this.m_cols + j]*10));
+          }
+      }
+    }
+    
+    public void printInd() {
+      //    result validation
+      System.printI(44444444);
+      for(int i=0; i<this.m_rows_re-this.m_rows_rs; i++) {
+          for(int j=0; j<this.m_cols_r; j++) {
+              System.printI((int)(this.m_ind[i * this.m_cols_r + j]*10));
+          }
+      }
+    }
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/tracking/IXL.java b/Robust/src/Benchmarks/oooJava/tracking/IXL.java
new file mode 100644
index 00000000..68050657
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/IXL.java
@@ -0,0 +1,126 @@
+public class IXL {
+
+  /* current processing image related */
+  float[] m_image;
+  int m_rows;
+  int m_cols;
+
+  /* results related */
+  float[] m_result;
+  int m_rows_rs;
+  int m_rows_re;
+  int m_cols_r;
+
+  /* id indicating the piece # */
+  int m_id;
+  int m_range;
+
+  /* constructor */
+  public IXL(int id, int range, float[] data, int rows, int cols) {
+    this.m_id = id;
+    this.m_range = range;
+    this.m_image = data;
+    this.m_rows = rows;
+    this.m_cols = cols;
+  }
+
+  public int getId() {
+    return this.m_id;
+  }
+
+  public float[] getResult() {
+    return this.m_result;
+  }
+
+  public int getRowsRS() {
+    return this.m_rows_rs;
+  }
+
+  public int getRowsRE() {
+    return this.m_rows_re;
+  }
+
+  public int getColsR() {
+    return this.m_cols_r;
+  }
+
+  public int getRows() {
+    return this.m_rows;
+  }
+
+  public int getCols() {
+    return this.m_cols;
+  }
+
+  public void calcSobel_dX() {
+    int rows_k1, cols_k1, rows_k2, cols_k2;
+    int[] kernel_1, kernel_2;
+    float temp;
+    int kernelSize, startCol, endCol, halfKernel, startRow, endRow;
+    int k, i, j, kernelSum_1, kernelSum_2;
+    float[] result, image;
+    int rows = this.m_rows;
+    int cols = this.m_cols;
+
+    image = this.m_image;
+
+    this.m_rows_rs = this.m_id * this.m_range;
+    this.m_rows_re = (this.m_id + 1) * this.m_range;
+    this.m_cols_r = cols;
+    result = this.m_result = new float[(this.m_rows_re - this.m_rows_rs) * this.m_cols_r];
+
+    rows_k1 = 1;
+    cols_k1 = 3;
+    kernel_1 = new int[rows_k1 * cols_k1];
+    rows_k2 = 1;
+    cols_k2 = 3;
+    kernel_2 = new int[rows_k2 * cols_k2];
+
+    kernel_1[0] = 1;
+    kernel_1[1] = 2;
+    kernel_1[2] = 1;
+
+    kernelSize = 3;
+    kernelSum_1 = 4;
+
+    kernel_2[0] = 1;
+    kernel_2[1] = 0;
+    kernel_2[2] = -1;
+
+    kernelSum_2 = 2;
+
+    startCol = 1; // ((kernelSize)/2);
+    endCol = cols - 1; // (int)(cols - (kernelSize/2));
+    halfKernel = 1; // (kernelSize-1)/2;
+
+    if ((this.m_rows_re < 1) || (this.m_rows_rs > rows - 1)) {
+      return;
+    }
+    startRow = (1 > this.m_rows_rs) ? 1 : (this.m_rows_rs); // (kernelSize)/2;
+    endRow = ((rows - 1) < this.m_rows_re) ? (rows - 1) : (this.m_rows_re); // (rows
+                                                                            // -
+                                                                            // (kernelSize)/2);
+
+    int ii = startRow - this.m_rows_rs;
+    for (i = startRow; i < endRow; i++) {
+      for (j = startCol; j < endCol; j++) {
+        temp = 0;
+        for (k = -halfKernel; k <= halfKernel; k++) {
+          temp += (float) (image[i * cols + (j + k)] * (float) (kernel_2[k + halfKernel]));
+        }
+        result[ii * cols + j] = (float) (temp / kernelSum_2);
+      }
+      ii++;
+    }
+  }
+
+  public void printResult() {
+    // result validation
+    System.printI(11111111);
+    for (int i = 0; i < this.m_rows_re - this.m_rows_rs; i++) {
+      for (int j = 0; j < this.m_cols_r; j++) {
+        System.printI((int) (this.m_result[i * this.m_cols_r + j] * 10));
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/tracking/IXLM.java b/Robust/src/Benchmarks/oooJava/tracking/IXLM.java
new file mode 100644
index 00000000..babd499a
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/IXLM.java
@@ -0,0 +1,143 @@
+public class IXLM {
+    
+    /* current processing image related */
+    float[] m_image;
+    int m_rows;
+    int m_cols;
+    
+    /* current processing image related */
+    float[] m_result;
+    int m_rows_r;
+    int m_cols_r;
+    
+    int m_counter;
+    
+    /* constructor */
+    public IXLM(int counter,
+                float[] data,
+                int rows,
+                int cols) {
+      this.m_counter = counter;
+      this.m_rows = this.m_rows_r = rows;
+      this.m_cols = this.m_cols_r = cols;
+      this.m_image = data;
+      this.m_result = new float[rows * cols];
+    }
+    
+    public int getRows() {
+      return this.m_rows;
+    }
+    
+    public int getCols() {
+      return this.m_cols;
+    }
+    
+    public float[] getImage() {
+      return this.m_image;
+    }
+    
+    public int getRowsR() {
+      return this.m_rows_r;
+    }
+    
+    public int getColsR() {
+      return this.m_cols_r;
+    }
+    
+    public float[] getResult() {
+      return this.m_result;
+    }
+    
+    public boolean addCalcSobelResult(IXL ixl) {
+      int startRow = ixl.getRowsRS();
+      int endRow = ixl.getRowsRE();
+      int i, j, k, cols;
+      float[] image, r;
+      
+      image = this.m_result;
+      this.m_counter--;
+      cols = this.m_cols_r;
+      
+      // clone data piece      
+      r = ixl.getResult();
+      k = 0;
+      for(i = startRow; i < endRow; i++) {
+        for(j = 0; j < cols; j++) {
+          image[i * cols + j] = r[k * cols + j];
+        }
+        k++;
+      }
+      
+      return (0 == this.m_counter);
+    }
+    
+    public void calcSobel_dX() {
+      int rows_k1, cols_k1, rows_k2, cols_k2;
+      int[] kernel_1, kernel_2;
+      float temp;
+      int kernelSize, startCol, endCol, halfKernel, startRow, endRow;
+      int k, i, j, kernelSum_1, kernelSum_2;
+      float[] result, image;
+      int rows = this.m_rows_r;
+      int cols = this.m_cols_r;
+
+      image = this.m_result;
+      
+      rows_k1 = 1;
+      cols_k1 = 3;
+      kernel_1 = new int[rows_k1 * cols_k1];
+      rows_k2 = 1;
+      cols_k2 = 3;
+      kernel_2 = new int[rows_k2 * cols_k2];   
+
+      kernel_1[0] = 1;
+      kernel_1[1] = 2;
+      kernel_1[2] = 1;
+
+      kernelSize = 3;
+      kernelSum_1 = 4;
+      
+      kernel_2[0] = 1;
+      kernel_2[1] = 0;
+      kernel_2[2] = -1;
+
+      kernelSum_2 = 2;
+
+      startCol = 1;           //((kernelSize)/2);
+      endCol = cols - 1;      //(int)(cols - (kernelSize/2));
+      halfKernel = 1;         //(kernelSize-1)/2;
+
+      startRow = 1;       //(kernelSize)/2;
+      endRow = (rows-1);  //(rows - (kernelSize)/2);
+
+      for(i=startRow; i<endRow; i++) {
+          for(j=startCol; j<endCol; j++) {
+              temp = 0;
+              for(k=-halfKernel; k<=halfKernel; k++) {
+                  temp += (float)(image[(i+k) * cols + j] 
+                                         * (float)(kernel_1[k+halfKernel]));
+              }
+              image[i * cols + j] = (float)(temp/kernelSum_1);
+              image[i * cols + j] = (float)(image[i * cols + j] + 128);
+          }
+      }
+    }
+    
+    public void printImage() {
+      //    result validation
+      for(int i=0; i<this.m_rows; i++) {
+          for(int j=0; j<this.m_cols; j++) {
+              System.printI((int)(this.m_image[i * this.m_cols + j]*10));
+          }
+      }
+    }
+    
+    public void printResult() {
+      //    result validation
+      for(int i=0; i<this.m_rows_r; i++) {
+          for(int j=0; j<this.m_cols_r; j++) {
+              System.printI((int)(this.m_result[i * this.m_cols_r + j]*10));
+          }
+      }
+    }
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/tracking/IXLMR.java b/Robust/src/Benchmarks/oooJava/tracking/IXLMR.java
new file mode 100644
index 00000000..d70c1247
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/IXLMR.java
@@ -0,0 +1,143 @@
+public class IXLMR {
+    
+    /* current processing image related */
+    float[] m_image;
+    int m_rows;
+    int m_cols;
+    
+    /* current processing image related */
+    float[] m_result;
+    int m_rows_r;
+    int m_cols_r;
+    
+    int m_counter;
+    
+    /* constructor */
+    public IXLMR(int counter,
+                 float[] data,
+                 int rows,
+                 int cols) {
+      this.m_counter = counter;
+      this.m_rows = this.m_rows_r = rows;
+      this.m_cols = this.m_cols_r = cols;
+      this.m_image = data;
+      this.m_result = new float[rows * cols];
+    }
+    
+    public int getRows() {
+      return this.m_rows;
+    }
+    
+    public int getCols() {
+      return this.m_cols;
+    }
+    
+    public float[] getImage() {
+      return this.m_image;
+    }
+    
+    public int getRowsR() {
+      return this.m_rows_r;
+    }
+    
+    public int getColsR() {
+      return this.m_cols_r;
+    }
+    
+    public float[] getResult() {
+      return this.m_result;
+    }
+    
+    public boolean addCalcSobelResult(IXLR ixl) {
+      int startRow = ixl.getRowsRS();
+      int endRow = ixl.getRowsRE();
+      int i, j, k, cols;
+      float[] image, r;
+      
+      image = this.m_result;
+      this.m_counter--;
+      cols = this.m_cols_r;
+      
+      // clone data piece      
+      r = ixl.getResult();
+      k = 0;
+      for(i = startRow; i < endRow; i++) {
+        for(j = 0; j < cols; j++) {
+          image[i * cols + j] = r[k * cols + j];
+        }
+        k++;
+      }
+      
+      return (0 == this.m_counter);
+    }
+    
+    public void calcSobel_dX() {
+      int rows_k1, cols_k1, rows_k2, cols_k2;
+      int[] kernel_1, kernel_2;
+      float temp;
+      int kernelSize, startCol, endCol, halfKernel, startRow, endRow;
+      int k, i, j, kernelSum_1, kernelSum_2;
+      float[] result, image;
+      int rows = this.m_rows_r;
+      int cols = this.m_cols_r;
+
+      image = this.m_result;
+      
+      rows_k1 = 1;
+      cols_k1 = 3;
+      kernel_1 = new int[rows_k1 * cols_k1];
+      rows_k2 = 1;
+      cols_k2 = 3;
+      kernel_2 = new int[rows_k2 * cols_k2];   
+
+      kernel_1[0] = 1;
+      kernel_1[1] = 2;
+      kernel_1[2] = 1;
+
+      kernelSize = 3;
+      kernelSum_1 = 4;
+      
+      kernel_2[0] = 1;
+      kernel_2[1] = 0;
+      kernel_2[2] = -1;
+
+      kernelSum_2 = 2;
+
+      startCol = 1;           //((kernelSize)/2);
+      endCol = cols - 1;      //(int)(cols - (kernelSize/2));
+      halfKernel = 1;         //(kernelSize-1)/2;
+
+      startRow = 1;       //(kernelSize)/2;
+      endRow = (rows-1);  //(rows - (kernelSize)/2);
+
+      for(i=startRow; i<endRow; i++) {
+          for(j=startCol; j<endCol; j++) {
+              temp = 0;
+              for(k=-halfKernel; k<=halfKernel; k++) {
+                  temp += (float)(image[(i+k) * cols + j] 
+                                         * (float)(kernel_1[k+halfKernel]));
+              }
+              image[i * cols + j] = (float)(temp/kernelSum_1);
+              image[i * cols + j] = (float)(image[i * cols + j] + 128);
+          }
+      }
+    }
+    
+    public void printImage() {
+      //    result validation
+      for(int i=0; i<this.m_rows; i++) {
+          for(int j=0; j<this.m_cols; j++) {
+              System.printI((int)(this.m_image[i * this.m_cols + j]*10));
+          }
+      }
+    }
+    
+    public void printResult() {
+      //    result validation
+      for(int i=0; i<this.m_rows_r; i++) {
+          for(int j=0; j<this.m_cols_r; j++) {
+              System.printI((int)(this.m_result[i * this.m_cols_r + j]*10));
+          }
+      }
+    }
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/tracking/IXLR.java b/Robust/src/Benchmarks/oooJava/tracking/IXLR.java
new file mode 100644
index 00000000..a70be64b
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/IXLR.java
@@ -0,0 +1,130 @@
+public class IXLR {
+
+    
+    /* current processing image related */
+    float[] m_image;
+    int m_rows;
+    int m_cols;
+    
+    /* results related */
+    float[] m_result;
+    int m_rows_rs;
+    int m_rows_re;
+    int m_cols_r;
+    
+    /* id indicating the piece # */
+    int m_id;  
+    int m_range;
+    
+    /* constructor */
+    public IXLR(int id,
+                int range,
+                float[] data,
+                int rows,
+                int cols) {
+      this.m_id = id;
+      this.m_range = range;
+      this.m_image = data;
+      this.m_rows = rows;
+      this.m_cols = cols;
+    }
+    
+    public int getId() {
+      return this.m_id;
+    }
+    
+    public float[] getResult() {
+      return this.m_result;
+    }
+    
+    public int getRowsRS() {
+      return this.m_rows_rs;
+    }
+    
+    public int getRowsRE() {
+      return this.m_rows_re;
+    }
+    
+    public int getColsR() {
+      return this.m_cols_r;
+    }
+    
+    public int getRows() {
+      return this.m_rows;
+    }
+    
+    public int getCols() {
+      return this.m_cols;
+    }
+    
+    public void calcSobel_dX() {
+      int rows_k1, cols_k1, rows_k2, cols_k2;
+      int[] kernel_1, kernel_2;
+      float temp;
+      int kernelSize, startCol, endCol, halfKernel, startRow, endRow;
+      int k, i, j, kernelSum_1, kernelSum_2;
+      float[] result, image;
+      int rows = this.m_rows;
+      int cols = this.m_cols;
+
+      image = this.m_image;
+      
+      this.m_rows_rs = this.m_id * this.m_range;
+      this.m_rows_re = (this.m_id + 1) * this.m_range;
+      this.m_cols_r = cols;
+      result=this.m_result=new float[(this.m_rows_re-this.m_rows_rs)*this.m_cols_r];
+      
+      rows_k1 = 1;
+      cols_k1 = 3;
+      kernel_1 = new int[rows_k1 * cols_k1];
+      rows_k2 = 1;
+      cols_k2 = 3;
+      kernel_2 = new int[rows_k2 * cols_k2];   
+
+      kernel_1[0] = 1;
+      kernel_1[1] = 2;
+      kernel_1[2] = 1;
+
+      kernelSize = 3;
+      kernelSum_1 = 4;
+      
+      kernel_2[0] = 1;
+      kernel_2[1] = 0;
+      kernel_2[2] = -1;
+
+      kernelSum_2 = 2;
+
+      startCol = 1;           //((kernelSize)/2);
+      endCol = cols - 1;      //(int)(cols - (kernelSize/2));
+      halfKernel = 1;         //(kernelSize-1)/2;
+
+      if((this.m_rows_re < 1) || (this.m_rows_rs > rows - 1)) {
+        return;
+      }
+      startRow = (1>this.m_rows_rs)?1:(this.m_rows_rs);       //(kernelSize)/2;
+      endRow = ((rows-1)<this.m_rows_re)?(rows-1):(this.m_rows_re);  //(rows - (kernelSize)/2);
+
+      int ii = startRow - this.m_rows_rs;
+      for(i=startRow; i<endRow; i++) {
+          for(j=startCol; j<endCol; j++) {
+              temp = 0;
+              for(k=-halfKernel; k<=halfKernel; k++) {
+                  temp += (float)(image[i * cols + (j+k)] 
+                                        * (float)(kernel_2[k+halfKernel]));
+              }
+              result[ii * cols + j] = (float)(temp/kernelSum_2);
+          }
+          ii++;
+      }
+    }
+    
+    public void printResult() {
+      //    result validation
+      System.printI(11111111);
+      for(int i=0; i<this.m_rows_re-this.m_rows_rs; i++) {
+          for(int j=0; j<this.m_cols_r; j++) {
+              System.printI((int)(this.m_result[i * this.m_cols_r + j]*10));
+          }
+      }
+    }
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/tracking/IYL.java b/Robust/src/Benchmarks/oooJava/tracking/IYL.java
new file mode 100644
index 00000000..da88bf46
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/IYL.java
@@ -0,0 +1,126 @@
+public class IYL {
+
+    
+    /* current processing image related */
+    float[] m_image;
+    int m_rows;
+    int m_cols;
+    
+    /* results related */
+    float[] m_result;
+    int m_rows_rs;
+    int m_rows_re;
+    int m_cols_r;
+    
+    /* id indicating the piece # */
+    int m_id;  
+    int m_range;
+    
+    /* constructor */
+    public IYL(int id,
+               int range,
+               float[] image,
+               int rows,
+               int cols) {
+      this.m_id = id;
+      this.m_range = range;
+      this.m_image = image;
+      this.m_rows = rows;
+      this.m_cols = cols;
+    }
+    
+    public int getId() {
+      return this.m_id;
+    }
+    
+    public int getRowsRS() {
+      return this.m_rows_rs;
+    }
+    
+    public int getRowsRE() {
+      return this.m_rows_re;
+    }
+
+    public int getColsR() {
+      return this.m_cols_r;
+    }
+    
+    public float[] getResult() {
+      return this.m_result;
+    }
+    
+    public int getRows() {
+      return this.m_rows;
+    }
+    
+    public int getCols() {
+      return this.m_cols;
+    }
+    
+    public float[] getImage() {
+      return this.m_image;
+    }
+    
+    public void calcSobel_dY() {
+      int rows_k1, cols_k1, rows_k2, cols_k2;
+      int[] kernel_1, kernel_2;
+      float temp;
+      int kernelSize, startCol, endCol, halfKernel, startRow, endRow;
+      int k, i, j, kernelSum_1, kernelSum_2;
+      float[] result, image;
+      int rows = this.m_rows;
+      int cols = this.m_cols;
+      
+      // level 1 is the base image.
+      
+      image = this.m_image;
+      
+      this.m_rows_rs = this.m_id * this.m_range;
+      this.m_rows_re = (this.m_id + 1) * this.m_range;
+      this.m_cols_r = cols;
+      result=this.m_result=new float[(this.m_rows_re-this.m_rows_rs)*this.m_cols_r];
+      
+      rows_k1 = 1;
+      cols_k1 = 3;
+      kernel_1 = new int[rows_k1 * cols_k1];
+      rows_k2 = 1;
+      cols_k2 = 3;
+      kernel_2 = new int[rows_k2 * cols_k2];
+
+      kernel_1[0] = 1;
+      kernel_1[1] = 0;
+      kernel_1[2] = -1;
+
+      kernelSize = 3;
+      kernelSum_1 = 2;
+      
+      kernel_2[0] = 1;
+      kernel_2[1] = 2;
+      kernel_2[2] = 1;
+
+      kernelSum_2 = 4;
+
+      startCol = 1;       //(kernelSize/2);
+      endCol = cols - 1;  //(int)(cols - (kernelSize/2));
+      halfKernel = 1;     //(kernelSize-1)/2;
+      
+      if((this.m_rows_re < 1) || (this.m_rows_rs > rows - 1)) {
+        return;
+      }
+      startRow = (1>this.m_rows_rs)?1:(this.m_rows_rs);       //(kernelSize)/2;
+      endRow = ((rows-1)<this.m_rows_re)?(rows-1):(this.m_rows_re);  //(rows - (kernelSize)/2);
+
+      int ii = startRow - this.m_rows_rs;
+      for(i=startRow; i<endRow; i++) {
+          for(j=startCol; j<endCol; j++) {
+              temp = 0;
+              for(k=-halfKernel; k<=halfKernel; k++) {
+                  temp += (float)(image[i * cols + (j+k)] 
+                                        * (float)(kernel_2[k+halfKernel]));
+              }
+              result[ii * cols + j] = (float)(temp/kernelSum_2);
+          }
+          ii++;
+      }
+    }
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/tracking/IYLM.java b/Robust/src/Benchmarks/oooJava/tracking/IYLM.java
new file mode 100644
index 00000000..357cf4ed
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/IYLM.java
@@ -0,0 +1,145 @@
+public class IYLM {
+
+    /* current processing image related */
+    float[] m_image;
+    int m_rows;
+    int m_cols;
+    
+    /* current processing image related */
+    float[] m_result;
+    int m_rows_r;
+    int m_cols_r;
+    
+    int m_counter;
+    
+    /* constructor */
+    public IYLM(int counter,
+                float[] data,
+                int rows,
+                int cols) {
+      this.m_counter = counter;
+      this.m_rows = this.m_rows_r = rows;
+      this.m_cols = this.m_cols_r = cols;
+      this.m_image = data;
+      this.m_result = new float[rows * cols];
+    }
+    
+    public int getRows() {
+      return this.m_rows;
+    }
+    
+    public int getCols() {
+      return this.m_cols;
+    }
+    
+    public float[] getImage() {
+      return this.m_image;
+    }
+    
+    public int getRowsR() {
+      return this.m_rows_r;
+    }
+    
+    public int getColsR() {
+      return this.m_cols_r;
+    }
+    
+    public float[] getResult() {
+      return this.m_result;
+    }
+    
+    public boolean addCalcSobelResult(IYL iyl) {
+      int startRow = iyl.getRowsRS();
+      int endRow = iyl.getRowsRE();
+      int i, j, k, cols;
+      float[] image, r;
+      
+      image = this.m_result;
+      this.m_counter--;
+      cols = this.m_cols_r;
+      
+      // clone data piece      
+      r = iyl.getResult();
+      k = 0;
+      for(i = startRow; i < endRow; i++) {
+        for(j = 0; j < cols; j++) {
+          image[i * cols + j] = r[k * cols + j];
+        }
+        k++;
+      }
+      
+      return (0 == this.m_counter);
+    }
+    
+    public void calcSobel_dY() {
+      int rows_k1, cols_k1, rows_k2, cols_k2;
+      int[] kernel_1, kernel_2;
+      float temp;
+      int kernelSize, startCol, endCol, halfKernel, startRow, endRow;
+      int k, i, j, kernelSum_1, kernelSum_2;
+      float[] result, image;
+      int rows = this.m_rows_r;
+      int cols = this.m_cols_r;
+      
+      // level 1 is the base image.
+      
+      image = this.m_result;
+      
+      rows_k1 = 1;
+      cols_k1 = 3;
+      kernel_1 = new int[rows_k1 * cols_k1];
+      rows_k2 = 1;
+      cols_k2 = 3;
+      kernel_2 = new int[rows_k2 * cols_k2];
+
+      kernel_1[0] = 1;
+      kernel_1[1] = 0;
+      kernel_1[2] = -1;
+
+      kernelSize = 3;
+      kernelSum_1 = 2;
+      
+      kernel_2[0] = 1;
+      kernel_2[1] = 2;
+      kernel_2[2] = 1;
+
+      kernelSum_2 = 4;
+
+      startCol = 1;       //(kernelSize/2);
+      endCol = cols - 1;  //(int)(cols - (kernelSize/2));
+      halfKernel = 1;     //(kernelSize-1)/2;
+
+      startRow = 1;       //(kernelSize)/2;
+      endRow = (rows-1);  //(rows - (kernelSize)/2);
+
+      for(i=startRow; i<endRow; i++) {
+          for(j=startCol; j<endCol; j++) {
+              temp = 0;
+              for(k=-halfKernel; k<=halfKernel; k++) {
+                  temp += (float)(image[(i+k) * cols + j] 
+                                         * (float)(kernel_1[k+halfKernel]));
+              }
+              image[i * cols + j] = (float)(temp/kernelSum_1);
+              image[i * cols + j] = (float)(image[i * cols + j] + 128);
+          }
+      }
+    }
+    
+    public void printImage() {
+      //    result validation
+      for(int i=0; i<this.m_rows; i++) {
+          for(int j=0; j<this.m_cols; j++) {
+              System.printI((int)(this.m_image[i * this.m_cols + j]*10));
+          }
+      }
+    }
+    
+    public void printResult() {
+      //    result validation
+      for(int i=0; i<this.m_rows_r; i++) {
+          for(int j=0; j<this.m_cols_r; j++) {
+              System.printI((int)(this.m_result[i * this.m_cols_r + j]*10));
+          }
+      }
+    }
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/tracking/IYLMR.java b/Robust/src/Benchmarks/oooJava/tracking/IYLMR.java
new file mode 100644
index 00000000..d7fa7ea8
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/IYLMR.java
@@ -0,0 +1,146 @@
+public class IYLMR {
+  
+    
+    /* current processing image related */
+    float[] m_image;
+    int m_rows;
+    int m_cols;
+    
+    /* current processing image related */
+    float[] m_result;
+    int m_rows_r;
+    int m_cols_r;
+    
+    int m_counter;
+    
+    /* constructor */
+    public IYLMR(int counter,
+                 float[] data,
+                 int rows,
+                 int cols) {
+      this.m_counter = counter;
+      this.m_rows = this.m_rows_r = rows;
+      this.m_cols = this.m_cols_r = cols;
+      this.m_image = data;
+      this.m_result = new float[rows * cols];
+    }
+    
+    public int getRows() {
+      return this.m_rows;
+    }
+    
+    public int getCols() {
+      return this.m_cols;
+    }
+    
+    public float[] getImage() {
+      return this.m_image;
+    }
+    
+    public int getRowsR() {
+      return this.m_rows_r;
+    }
+    
+    public int getColsR() {
+      return this.m_cols_r;
+    }
+    
+    public float[] getResult() {
+      return this.m_result;
+    }
+    
+    public boolean addCalcSobelResult(IYLR iyl) {
+      int startRow = iyl.getRowsRS();
+      int endRow = iyl.getRowsRE();
+      int i, j, k, cols;
+      float[] image, r;
+      
+      image = this.m_result;
+      this.m_counter--;
+      cols = this.m_cols_r;
+      
+      // clone data piece      
+      r = iyl.getResult();
+      k = 0;
+      for(i = startRow; i < endRow; i++) {
+        for(j = 0; j < cols; j++) {
+          image[i * cols + j] = r[k * cols + j];
+        }
+        k++;
+      }
+      
+      return (0 == this.m_counter);
+    }
+    
+    public void calcSobel_dY() {
+      int rows_k1, cols_k1, rows_k2, cols_k2;
+      int[] kernel_1, kernel_2;
+      float temp;
+      int kernelSize, startCol, endCol, halfKernel, startRow, endRow;
+      int k, i, j, kernelSum_1, kernelSum_2;
+      float[] result, image;
+      int rows = this.m_rows_r;
+      int cols = this.m_cols_r;
+      
+      // level 1 is the base image.
+      
+      image = this.m_result;
+      
+      rows_k1 = 1;
+      cols_k1 = 3;
+      kernel_1 = new int[rows_k1 * cols_k1];
+      rows_k2 = 1;
+      cols_k2 = 3;
+      kernel_2 = new int[rows_k2 * cols_k2];
+
+      kernel_1[0] = 1;
+      kernel_1[1] = 0;
+      kernel_1[2] = -1;
+
+      kernelSize = 3;
+      kernelSum_1 = 2;
+      
+      kernel_2[0] = 1;
+      kernel_2[1] = 2;
+      kernel_2[2] = 1;
+
+      kernelSum_2 = 4;
+
+      startCol = 1;       //(kernelSize/2);
+      endCol = cols - 1;  //(int)(cols - (kernelSize/2));
+      halfKernel = 1;     //(kernelSize-1)/2;
+
+      startRow = 1;       //(kernelSize)/2;
+      endRow = (rows-1);  //(rows - (kernelSize)/2);
+
+      for(i=startRow; i<endRow; i++) {
+          for(j=startCol; j<endCol; j++) {
+              temp = 0;
+              for(k=-halfKernel; k<=halfKernel; k++) {
+                  temp += (float)(image[(i+k) * cols + j] 
+                                         * (float)(kernel_1[k+halfKernel]));
+              }
+              image[i * cols + j] = (float)(temp/kernelSum_1);
+              image[i * cols + j] = (float)(image[i * cols + j] + 128);
+          }
+      }
+    }
+    
+    public void printImage() {
+      //    result validation
+      for(int i=0; i<this.m_rows; i++) {
+          for(int j=0; j<this.m_cols; j++) {
+              System.printI((int)(this.m_image[i * this.m_cols + j]*10));
+          }
+      }
+    }
+    
+    public void printResult() {
+      //    result validation
+      for(int i=0; i<this.m_rows_r; i++) {
+          for(int j=0; j<this.m_cols_r; j++) {
+              System.printI((int)(this.m_result[i * this.m_cols_r + j]*10));
+          }
+      }
+    }
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/tracking/IYLR.java b/Robust/src/Benchmarks/oooJava/tracking/IYLR.java
new file mode 100644
index 00000000..f1eb6ca7
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/IYLR.java
@@ -0,0 +1,126 @@
+public class IYLR {
+
+    
+    /* current processing image related */
+    float[] m_image;
+    int m_rows;
+    int m_cols;
+    
+    /* results related */
+    float[] m_result;
+    int m_rows_rs;
+    int m_rows_re;
+    int m_cols_r;
+    
+    /* id indicating the piece # */
+    int m_id;  
+    int m_range;
+    
+    /* constructor */
+    public IYLR(int id,
+                int range,
+                float[] image,
+                int rows,
+                int cols) {
+      this.m_id = id;
+      this.m_range = range;
+      this.m_image = image;
+      this.m_rows = rows;
+      this.m_cols = cols;
+    }
+    
+    public int getId() {
+      return this.m_id;
+    }
+    
+    public int getRowsRS() {
+      return this.m_rows_rs;
+    }
+    
+    public int getRowsRE() {
+      return this.m_rows_re;
+    }
+
+    public int getColsR() {
+      return this.m_cols_r;
+    }
+    
+    public float[] getResult() {
+      return this.m_result;
+    }
+    
+    public int getRows() {
+      return this.m_rows;
+    }
+    
+    public int getCols() {
+      return this.m_cols;
+    }
+    
+    public float[] getImage() {
+      return this.m_image;
+    }
+    
+    public void calcSobel_dY() {
+      int rows_k1, cols_k1, rows_k2, cols_k2;
+      int[] kernel_1, kernel_2;
+      float temp;
+      int kernelSize, startCol, endCol, halfKernel, startRow, endRow;
+      int k, i, j, kernelSum_1, kernelSum_2;
+      float[] result, image;
+      int rows = this.m_rows;
+      int cols = this.m_cols;
+      
+      // level 1 is the base image.
+      
+      image = this.m_image;
+      
+      this.m_rows_rs = this.m_id * this.m_range;
+      this.m_rows_re = (this.m_id + 1) * this.m_range;
+      this.m_cols_r = cols;
+      result=this.m_result=new float[(this.m_rows_re-this.m_rows_rs)*this.m_cols_r];
+      
+      rows_k1 = 1;
+      cols_k1 = 3;
+      kernel_1 = new int[rows_k1 * cols_k1];
+      rows_k2 = 1;
+      cols_k2 = 3;
+      kernel_2 = new int[rows_k2 * cols_k2];
+
+      kernel_1[0] = 1;
+      kernel_1[1] = 0;
+      kernel_1[2] = -1;
+
+      kernelSize = 3;
+      kernelSum_1 = 2;
+      
+      kernel_2[0] = 1;
+      kernel_2[1] = 2;
+      kernel_2[2] = 1;
+
+      kernelSum_2 = 4;
+
+      startCol = 1;       //(kernelSize/2);
+      endCol = cols - 1;  //(int)(cols - (kernelSize/2));
+      halfKernel = 1;     //(kernelSize-1)/2;
+      
+      if((this.m_rows_re < 1) || (this.m_rows_rs > rows - 1)) {
+        return;
+      }
+      startRow = (1>this.m_rows_rs)?1:(this.m_rows_rs);       //(kernelSize)/2;
+      endRow = ((rows-1)<this.m_rows_re)?(rows-1):(this.m_rows_re);  //(rows - (kernelSize)/2);
+
+      int ii = startRow - this.m_rows_rs;
+      for(i=startRow; i<endRow; i++) {
+          for(j=startCol; j<endCol; j++) {
+              temp = 0;
+              for(k=-halfKernel; k<=halfKernel; k++) {
+                  temp += (float)(image[i * cols + (j+k)] 
+                                        * (float)(kernel_2[k+halfKernel]));
+              }
+              result[ii * cols + j] = (float)(temp/kernelSum_2);
+          }
+          ii++;
+      }
+    }
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/tracking/ImageReader.java b/Robust/src/Benchmarks/oooJava/tracking/ImageReader.java
new file mode 100644
index 00000000..c08b0216
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/ImageReader.java
@@ -0,0 +1,170 @@
+public class ImageReader {
+  
+  int row;
+  int col;
+
+  public ImageReader() {
+
+  }
+
+  public int[] readImage(String file) {
+
+    FileInputStream fs = new FileInputStream(file);
+    int bflen = 14; // 14 byte BITMAPFILEHEADER
+    byte bf[] = new byte[bflen];
+    // fs.read(bf,0,bflen);
+    fs.read(bf);
+    int bilen = 40; // 40-byte BITMAPINFOHEADER
+    byte bi[] = new byte[bilen];
+    // fs.read(bi,0,bilen);
+    fs.read(bi);
+    // Interperet data.
+    int nsize =
+        (((int) bf[5] & 0xff) << 24) | (((int) bf[4] & 0xff) << 16) | (((int) bf[3] & 0xff) << 8)
+            | (int) bf[2] & 0xff;
+//    System.out.println("File type is :" + (char) bf[0] + (char) bf[1]);
+//    System.out.println("Size of file is :" + nsize);
+    int nbisize =
+        (((int) bi[3] & 0xff) << 24) | (((int) bi[2] & 0xff) << 16) | (((int) bi[1] & 0xff) << 8)
+            | (int) bi[0] & 0xff;
+//    System.out.println("Size of bitmapinfoheader is :" + nbisize);
+    int nwidth =
+        (((int) bi[7] & 0xff) << 24) | (((int) bi[6] & 0xff) << 16) | (((int) bi[5] & 0xff) << 8)
+            | (int) bi[4] & 0xff;
+    col=nwidth;
+//    System.out.println("Width is :" + nwidth);
+    int nheight =
+        (((int) bi[11] & 0xff) << 24) | (((int) bi[10] & 0xff) << 16) | (((int) bi[9] & 0xff) << 8)
+            | (int) bi[8] & 0xff;
+    row=nheight;
+//    System.out.println("Height is :" + nheight);
+    int nplanes = (((int) bi[13] & 0xff) << 8) | (int) bi[12] & 0xff;
+//    System.out.println("Planes is :" + nplanes);
+    int nbitcount = (((int) bi[15] & 0xff) << 8) | (int) bi[14] & 0xff;
+//    System.out.println("BitCount is :" + nbitcount);
+    // Look for non-zero values to indicate compression
+    int ncompression =
+        (((int) bi[19]) << 24) | (((int) bi[18]) << 16) | (((int) bi[17]) << 8) | (int) bi[16];
+//    System.out.println("Compression is :" + ncompression);
+    int nsizeimage =
+        (((int) bi[23] & 0xff) << 24) | (((int) bi[22] & 0xff) << 16)
+            | (((int) bi[21] & 0xff) << 8) | (int) bi[20] & 0xff;
+//    System.out.println("SizeImage is :" + nsizeimage);
+    int nxpm =
+        (((int) bi[27] & 0xff) << 24) | (((int) bi[26] & 0xff) << 16)
+            | (((int) bi[25] & 0xff) << 8) | (int) bi[24] & 0xff;
+//    System.out.println("X-Pixels per meter is :" + nxpm);
+    int nypm =
+        (((int) bi[31] & 0xff) << 24) | (((int) bi[30] & 0xff) << 16)
+            | (((int) bi[29] & 0xff) << 8) | (int) bi[28] & 0xff;
+//    System.out.println("Y-Pixels per meter is :" + nypm);
+    int nclrused =
+        (((int) bi[35] & 0xff) << 24) | (((int) bi[34] & 0xff) << 16)
+            | (((int) bi[33] & 0xff) << 8) | (int) bi[32] & 0xff;
+//    System.out.println("Colors used are :" + nclrused);
+    int nclrimp =
+        (((int) bi[39] & 0xff) << 24) | (((int) bi[38] & 0xff) << 16)
+            | (((int) bi[37] & 0xff) << 8) | (int) bi[36] & 0xff;
+//    System.out.println("Colors important are :" + nclrimp);
+    
+    int ndata[];
+
+    if (nbitcount == 24) {
+      // No Palatte data for 24-bit format but scan lines are
+      // padded out to even 4-byte boundaries.
+      int npad = (nsizeimage / nheight) - nwidth * 3;
+      ndata = new int[(nheight * nwidth) + 4];
+      byte brgb[] = new byte[(nwidth + npad) * 3 * nheight];
+      // fs.read (brgb, 0, (nwidth + npad) * 3 * nheight);
+      fs.read(brgb);
+      int nindex = 0;
+      for (int j = 0; j < nheight; j++) {
+        for (int i = 0; i < nwidth; i++) {
+//          ndata[nwidth * (nheight - j - 1) + i] =
+//              (255 & 0xff) << 24 | (((int) brgb[nindex + 2] & 0xff) << 16)
+//                  | (((int) brgb[nindex + 1] & 0xff) << 8) | (int) brgb[nindex] & 0xff;
+//           System.out.println("Encoded Color at ("
+//           +i+","+j+")is:"+brgb+" (R,G,B)= (" +((int)(brgb[nindex + 2]) & 0xff)+","
+//           +((int)brgb[nindex + 1]&0xff)+"," +((int)brgb[nindex]&0xff)+")");
+          int ta=((3*((int)(brgb[nindex + 2]) & 0xff)+6*((int)brgb[nindex + 1]&0xff)+((int)brgb[nindex]&0xff))) /10 ;
+          ndata[nwidth * (nheight - j - 1) + i+4] =ta;
+//           System.out.println(ta);
+          nindex += 3;
+        }
+        nindex += npad;
+      }
+      // image = createImage
+      // ( new MemoryImageSource (nwidth, nheight,
+      // ndata, 0, nwidth));
+   
+    } else if (nbitcount == 8) {
+      // Have to determine the number of colors, the clrsused
+      // parameter is dominant if it is greater than zero. If
+      // zero, calculate colors based on bitsperpixel.
+      int nNumColors = 0;
+      if (nclrused > 0) {
+        nNumColors = nclrused;
+      } else {
+        nNumColors = (1 & 0xff) << nbitcount;
+      }
+      System.out.println("The number of Colors is" + nNumColors);
+      // Some bitmaps do not have the sizeimage field calculated
+      // Ferret out these cases and fix 'em.
+      if (nsizeimage == 0) {
+        nsizeimage = ((((nwidth * nbitcount) + 31) & 31) >> 3);
+        nsizeimage *= nheight;
+        System.out.println("nsizeimage (backup) is" + nsizeimage);
+      }
+      // Read the palatte colors.
+      int npalette[] = new int[nNumColors];
+      byte bpalette[] = new byte[nNumColors * 4];
+      // fs.read (bpalette, 0, nNumColors*4);
+      fs.read(bpalette);
+      int nindex8 = 0;
+      for (int n = 0; n < nNumColors; n++) {
+        npalette[n] =
+            (255 & 0xff) << 24 | (((int) bpalette[nindex8 + 2] & 0xff) << 16)
+                | (((int) bpalette[nindex8 + 1] & 0xff) << 8) | (int) bpalette[nindex8] & 0xff;
+        // System.out.println ("Palette Color "+n
+        // +" is:"+npalette[n]+" (res,R,G,B)= (" +((int)(bpalette[nindex8+3]) &
+        // 0xff)+"," +((int)(bpalette[nindex8+2]) & 0xff)+","
+        // +((int)bpalette[nindex8+1]&0xff)+","
+        // +((int)bpalette[nindex8]&0xff)+")");
+        nindex8 += 4;
+      }
+      // Read the image data (actually indices into the palette)
+      // Scan lines are still padded out to even 4-byte
+      // boundaries.
+      int npad8 = (nsizeimage / nheight) - nwidth;
+      System.out.println("nPad is:" + npad8);
+//      int ndata8[] = new int[nwidth * nheight];
+      ndata = new int[(nwidth * nheight)+4];
+      byte bdata[] = new byte[(nwidth + npad8) * nheight];
+      // fs.read (bdata, 0, (nwidth+npad8)*nheight);
+      fs.read(bdata);
+      nindex8 = 0;
+      for (int j8 = 0; j8 < nheight; j8++) {
+        for (int i8 = 0; i8 < nwidth; i8++) {
+          ndata[nwidth * (nheight - j8 - 1) + i8+4] = npalette[((int) bdata[nindex8] & 0xff)];
+          nindex8++;
+        }
+        nindex8 += npad8;
+      }
+      // image = createImage ( new MemoryImageSource (nwidth, nheight,
+      // ndata8, 0, nwidth));
+    } else {
+      System.out.println("Not a 24-bit or 8-bit Windows Bitmap, aborting...");
+      // image = (Image)null;
+    }
+    fs.close();
+    
+    ndata[0] = nheight;
+    ndata[1] = nwidth;
+    ndata[2] = nheight * nwidth;
+    ndata[3] = 2;
+    
+    return ndata;
+
+  }
+
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/tracking/ImageX.java b/Robust/src/Benchmarks/oooJava/tracking/ImageX.java
new file mode 100644
index 00000000..07a8c337
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/ImageX.java
@@ -0,0 +1,129 @@
+public class ImageX {
+    
+    /* current processing image related */
+    float[] m_image;
+    int m_rows;
+    int m_cols;
+    
+    /* results related */
+    float[] m_result;
+    int m_rows_rs;
+    int m_rows_re;
+    int m_cols_r;
+    
+    /* id indicating the piece # */
+    int m_id;  
+    int m_range;
+    
+    /* constructor */
+    public ImageX(int id,
+                  int range,
+                  float[] data,
+                  int rows,
+                  int cols) {
+      this.m_id = id;
+      this.m_range = range;
+      this.m_image = data;
+      this.m_rows = rows;
+      this.m_cols = cols;
+    }
+    
+    public int getId() {
+      return this.m_id;
+    }
+    
+    public float[] getResult() {
+      return this.m_result;
+    }
+    
+    public int getRowsRS() {
+      return this.m_rows_rs;
+    }
+    
+    public int getRowsRE() {
+      return this.m_rows_re;
+    }
+    
+    public int getColsR() {
+      return this.m_cols_r;
+    }
+    
+    public int getRows() {
+      return this.m_rows;
+    }
+    
+    public int getCols() {
+      return this.m_cols;
+    }
+    
+    public void calcSobel_dX() {
+      int rows_k1, cols_k1, rows_k2, cols_k2;
+      int[] kernel_1, kernel_2;
+      float temp;
+      int kernelSize, startCol, endCol, halfKernel, startRow, endRow;
+      int k, i, j, kernelSum_1, kernelSum_2;
+      float[] result, image;
+      int rows = this.m_rows;
+      int cols = this.m_cols;
+
+      image = this.m_image;
+      
+      this.m_rows_rs = this.m_id * this.m_range;
+      this.m_rows_re = (this.m_id + 1) * this.m_range;
+      this.m_cols_r = cols;
+      result=this.m_result=new float[(this.m_rows_re-this.m_rows_rs)*this.m_cols_r];
+      
+      rows_k1 = 1;
+      cols_k1 = 3;
+      kernel_1 = new int[rows_k1 * cols_k1];
+      rows_k2 = 1;
+      cols_k2 = 3;
+      kernel_2 = new int[rows_k2 * cols_k2];   
+
+      kernel_1[0] = 1;
+      kernel_1[1] = 2;
+      kernel_1[2] = 1;
+
+      kernelSize = 3;
+      kernelSum_1 = 4;
+      
+      kernel_2[0] = 1;
+      kernel_2[1] = 0;
+      kernel_2[2] = -1;
+
+      kernelSum_2 = 2;
+
+      startCol = 1;           //((kernelSize)/2);
+      endCol = cols - 1;      //(int)(cols - (kernelSize/2));
+      halfKernel = 1;         //(kernelSize-1)/2;
+
+      if((this.m_rows_re < 1) || (this.m_rows_rs > rows - 1)) {
+        return;
+      }
+      startRow = (1>this.m_rows_rs)?1:(this.m_rows_rs);       //(kernelSize)/2;
+      endRow = ((rows-1)<this.m_rows_re)?(rows-1):(this.m_rows_re);  //(rows - (kernelSize)/2);
+
+      int ii = startRow - this.m_rows_rs;
+      for(i=startRow; i<endRow; i++) {
+          for(j=startCol; j<endCol; j++) {
+              temp = 0;
+              for(k=-halfKernel; k<=halfKernel; k++) {
+                  temp += (float)(image[i * cols + (j+k)] 
+                                        * (float)(kernel_2[k+halfKernel]));
+              }
+              result[ii * cols + j] = (float)(temp/kernelSum_2);
+          }
+          ii++;
+      }
+    }
+    
+    public void printResult() {
+      //    result validation
+      System.printI(11111111);
+      for(int i=0; i<this.m_rows_re-this.m_rows_rs; i++) {
+          for(int j=0; j<this.m_cols_r; j++) {
+              System.printI((int)(this.m_result[i * this.m_cols_r + j]*10));
+          }
+      }
+    }
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/tracking/ImageXM.java b/Robust/src/Benchmarks/oooJava/tracking/ImageXM.java
new file mode 100644
index 00000000..3fb3a03e
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/ImageXM.java
@@ -0,0 +1,115 @@
+public class ImageXM {
+    
+    /* current processing image related */
+    float[] m_image;
+    int m_rows;
+    int m_cols;
+
+    int m_counter;
+    
+    /* constructor */
+    public ImageXM(int counter,
+                   int rows,
+                   int cols) {
+      this.m_counter = counter;
+      this.m_rows = rows;
+      this.m_cols = cols;
+      this.m_image = new float[rows * cols];
+    }
+
+    public int getRows() {
+      return this.m_rows;
+    }
+    
+    public int getCols() {
+      return this.m_cols;
+    }
+    
+    public float[] getImage() {
+      return this.m_image;
+    }
+
+    public boolean addCalcSobelResult(ImageX imx) {
+      int startRow = imx.getRowsRS();
+      int endRow = imx.getRowsRE();
+      int i, j, k, cols;
+      float[] image, r;
+      
+      image = this.m_image;
+      this.m_counter--;
+      cols = this.m_cols;
+      
+      // clone data piece      
+      r = imx.getResult();
+      k = 0;
+      for(i = startRow; i < endRow; i++) {
+        for(j = 0; j < cols; j++) {
+          image[i * cols + j] = r[k * cols + j];
+        }
+        k++;
+      }
+      
+      return (0 == this.m_counter);
+    }
+    
+    public void calcSobel_dX() {
+      int rows_k1, cols_k1, rows_k2, cols_k2;
+      int[] kernel_1, kernel_2;
+      float temp;
+      int kernelSize, startCol, endCol, halfKernel, startRow, endRow;
+      int k, i, j, kernelSum_1, kernelSum_2;
+      float[] result, image;
+      int rows = this.m_rows;
+      int cols = this.m_cols;
+
+      image = this.m_image;
+      
+      rows_k1 = 1;
+      cols_k1 = 3;
+      kernel_1 = new int[rows_k1 * cols_k1];
+      rows_k2 = 1;
+      cols_k2 = 3;
+      kernel_2 = new int[rows_k2 * cols_k2];   
+
+      kernel_1[0] = 1;
+      kernel_1[1] = 2;
+      kernel_1[2] = 1;
+
+      kernelSize = 3;
+      kernelSum_1 = 4;
+      
+      kernel_2[0] = 1;
+      kernel_2[1] = 0;
+      kernel_2[2] = -1;
+
+      kernelSum_2 = 2;
+
+      startCol = 1;           //((kernelSize)/2);
+      endCol = cols - 1;      //(int)(cols - (kernelSize/2));
+      halfKernel = 1;         //(kernelSize-1)/2;
+
+      startRow = 1;       //(kernelSize)/2;
+      endRow = (rows-1);  //(rows - (kernelSize)/2);
+
+      for(i=startRow; i<endRow; i++) {
+          for(j=startCol; j<endCol; j++) {
+              temp = 0;
+              for(k=-halfKernel; k<=halfKernel; k++) {
+                  temp += (float)(image[(i+k) * cols + j] 
+                                         * (float)(kernel_1[k+halfKernel]));
+              }
+              image[i * cols + j] = (float)(temp/kernelSum_1);
+              image[i * cols + j] = (float)(image[i * cols + j] + 128);
+          }
+      }
+    }
+    
+    public void printImage() {
+      //    result validation
+      for(int i=0; i<this.m_rows; i++) {
+          for(int j=0; j<this.m_cols; j++) {
+              System.printI((int)(this.m_image[i * this.m_cols + j]*10));
+          }
+      }
+    }
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/tracking/ImageY.java b/Robust/src/Benchmarks/oooJava/tracking/ImageY.java
new file mode 100644
index 00000000..531d7c3b
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/ImageY.java
@@ -0,0 +1,125 @@
+public class ImageY {
+    
+    /* current processing image related */
+    float[] m_image;
+    int m_rows;
+    int m_cols;
+    
+    /* results related */
+    float[] m_result;
+    int m_rows_rs;
+    int m_rows_re;
+    int m_cols_r;
+    
+    /* id indicating the piece # */
+    int m_id;  
+    int m_range;
+    
+    /* constructor */
+    public ImageY(int id,
+                  int range,
+                  float[] image,
+                  int rows,
+                  int cols) {
+      this.m_id = id;
+      this.m_range = range;
+      this.m_image = image;
+      this.m_rows = rows;
+      this.m_cols = cols;
+    }
+    
+    public int getId() {
+      return this.m_id;
+    }
+    
+    public int getRowsRS() {
+      return this.m_rows_rs;
+    }
+    
+    public int getRowsRE() {
+      return this.m_rows_re;
+    }
+
+    public int getColsR() {
+      return this.m_cols_r;
+    }
+    
+    public float[] getResult() {
+      return this.m_result;
+    }
+    
+    public int getRows() {
+      return this.m_rows;
+    }
+    
+    public int getCols() {
+      return this.m_cols;
+    }
+    
+    public float[] getImage() {
+      return this.m_image;
+    }
+    
+    public void calcSobel_dY() {
+      int rows_k1, cols_k1, rows_k2, cols_k2;
+      int[] kernel_1, kernel_2;
+      float temp;
+      int kernelSize, startCol, endCol, halfKernel, startRow, endRow;
+      int k, i, j, kernelSum_1, kernelSum_2;
+      float[] result, image;
+      int rows = this.m_rows;
+      int cols = this.m_cols;
+      
+      // level 1 is the base image.
+      
+      image = this.m_image;
+      
+      this.m_rows_rs = this.m_id * this.m_range;
+      this.m_rows_re = (this.m_id + 1) * this.m_range;
+      this.m_cols_r = cols;
+      result=this.m_result=new float[(this.m_rows_re-this.m_rows_rs)*this.m_cols_r];
+      
+      rows_k1 = 1;
+      cols_k1 = 3;
+      kernel_1 = new int[rows_k1 * cols_k1];
+      rows_k2 = 1;
+      cols_k2 = 3;
+      kernel_2 = new int[rows_k2 * cols_k2];
+
+      kernel_1[0] = 1;
+      kernel_1[1] = 0;
+      kernel_1[2] = -1;
+
+      kernelSize = 3;
+      kernelSum_1 = 2;
+      
+      kernel_2[0] = 1;
+      kernel_2[1] = 2;
+      kernel_2[2] = 1;
+
+      kernelSum_2 = 4;
+
+      startCol = 1;       //(kernelSize/2);
+      endCol = cols - 1;  //(int)(cols - (kernelSize/2));
+      halfKernel = 1;     //(kernelSize-1)/2;
+      
+      if((this.m_rows_re < 1) || (this.m_rows_rs > rows - 1)) {
+        return;
+      }
+      startRow = (1>this.m_rows_rs)?1:(this.m_rows_rs);       //(kernelSize)/2;
+      endRow = ((rows-1)<this.m_rows_re)?(rows-1):(this.m_rows_re);  //(rows - (kernelSize)/2);
+
+      int ii = startRow - this.m_rows_rs;
+      for(i=startRow; i<endRow; i++) {
+          for(j=startCol; j<endCol; j++) {
+              temp = 0;
+              for(k=-halfKernel; k<=halfKernel; k++) {
+                  temp += (float)(image[i * cols + (j+k)] 
+                                        * (float)(kernel_2[k+halfKernel]));
+              }
+              result[ii * cols + j] = (float)(temp/kernelSum_2);
+          }
+          ii++;
+      }
+    }
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/tracking/ImageYM.java b/Robust/src/Benchmarks/oooJava/tracking/ImageYM.java
new file mode 100644
index 00000000..03e2c124
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/ImageYM.java
@@ -0,0 +1,117 @@
+public class ImageYM {
+    
+    /* current processing image related */
+    float[] m_image;
+    int m_rows;
+    int m_cols;
+
+    int m_counter;
+  
+    /* constructor */
+    public ImageYM(int counter,
+                   int rows,
+                   int cols) {
+      this.m_counter = counter;
+      this.m_rows = rows;
+      this.m_cols = cols;
+      this.m_image = new float[rows * cols];
+    }
+
+    public int getRows() {
+      return this.m_rows;
+    }
+    
+    public int getCols() {
+      return this.m_cols;
+    }
+    
+    public float[] getImage() {
+      return this.m_image;
+    }
+
+    public boolean addCalcSobelResult(ImageY imy) {
+      int startRow = imy.getRowsRS();
+      int endRow = imy.getRowsRE();
+      int i, j, k, cols;
+      float[] image, r;
+      
+      image = this.m_image;
+      this.m_counter--;
+      cols = this.m_cols;
+      
+      // clone data piece      
+      r = imy.getResult();
+      k = 0;
+      for(i = startRow; i < endRow; i++) {
+        for(j = 0; j < cols; j++) {
+          image[i * cols + j] = r[k * cols + j];
+        }
+        k++;
+      }
+      
+      return (0 == this.m_counter);
+    }
+    
+    public void calcSobel_dY() {
+      int rows_k1, cols_k1, rows_k2, cols_k2;
+      int[] kernel_1, kernel_2;
+      float temp;
+      int kernelSize, startCol, endCol, halfKernel, startRow, endRow;
+      int k, i, j, kernelSum_1, kernelSum_2;
+      float[] result, image;
+      int rows = this.m_rows;
+      int cols = this.m_cols;
+      
+      // level 1 is the base image.
+      
+      image = this.m_image;
+      
+      rows_k1 = 1;
+      cols_k1 = 3;
+      kernel_1 = new int[rows_k1 * cols_k1];
+      rows_k2 = 1;
+      cols_k2 = 3;
+      kernel_2 = new int[rows_k2 * cols_k2];
+
+      kernel_1[0] = 1;
+      kernel_1[1] = 0;
+      kernel_1[2] = -1;
+
+      kernelSize = 3;
+      kernelSum_1 = 2;
+      
+      kernel_2[0] = 1;
+      kernel_2[1] = 2;
+      kernel_2[2] = 1;
+
+      kernelSum_2 = 4;
+
+      startCol = 1;       //(kernelSize/2);
+      endCol = cols - 1;  //(int)(cols - (kernelSize/2));
+      halfKernel = 1;     //(kernelSize-1)/2;
+
+      startRow = 1;       //(kernelSize)/2;
+      endRow = (rows-1);  //(rows - (kernelSize)/2);
+
+      for(i=startRow; i<endRow; i++) {
+          for(j=startCol; j<endCol; j++) {
+              temp = 0;
+              for(k=-halfKernel; k<=halfKernel; k++) {
+                  temp += (float)(image[(i+k) * cols + j] 
+                                         * (float)(kernel_1[k+halfKernel]));
+              }
+              image[i * cols + j] = (float)(temp/kernelSum_1);
+              image[i * cols + j] = (float)(image[i * cols + j] + 128);
+          }
+      }
+    }
+    
+    public void printImage() {
+      //    result validation
+      for(int i=0; i<this.m_rows; i++) {
+          for(int j=0; j<this.m_cols; j++) {
+              System.printI((int)(this.m_image[i * this.m_cols + j]*10));
+          }
+      }
+    }
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/tracking/Lambda.java b/Robust/src/Benchmarks/oooJava/tracking/Lambda.java
new file mode 100644
index 00000000..d691b7f7
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/Lambda.java
@@ -0,0 +1,201 @@
+public class Lambda {
+    
+    /* current processing image related */
+    float[] m_image;
+    int m_rows;
+    int m_cols;
+    int m_r;
+    
+    int m_num_p;
+    
+    /* benchmark constants */
+    int WINSZ;
+    public int N_FEA;
+
+    /* constructor */
+    public Lambda(int winsz,
+                  int nfea,
+                  int pnum,
+                  int nump) {
+      this.WINSZ = winsz;
+      this.N_FEA = nfea;
+      this.m_num_p = nump;
+    }
+    
+    public int getNumP() {
+      return this.m_num_p;
+    }
+    
+    public int getR() {
+      return this.m_r;
+    }
+    
+    public int getRows() {
+      return this.m_rows;
+    }
+    
+    public int getCols() {
+      return this.m_cols;
+    }
+    
+    public float[] getImage() {
+      return this.m_image;
+    }
+    
+    public void calcGoodFeature(ImageXM imxm,
+                                ImageYM imym) {
+      float[] dX, dY;
+      int sizeX, sizeY, rowY, colY;
+      int i, j;
+      float[] xx, yy, xy, image;
+      int rows_xx, cols_xx, rows_yy, cols_yy, rows_xy, cols_xy;
+      float[] tr, det, c_xx, c_xy, c_yy;
+      int rows_tr, cols_tr, rows_det, cols_det, rows_cxx, cols_cxx;
+      int rows_cxy, cols_cxyrows_cyy, cols_cyy;
+      
+      dX = imxm.getImage();
+      dY = imym.getImage();
+      sizeX = imxm.getRows();
+      sizeY = imxm.getCols();
+      rowY = imym.getRows();
+      colY = imym.getCols();
+
+      rows_xx = sizeX;
+      cols_xx = sizeY;
+      xx = new float[rows_xx * cols_xx];
+      rows_xy = sizeX;
+      cols_xy = sizeY;
+      xy = new float[rows_xy * cols_xy];
+      rows_yy = sizeX;
+      cols_yy = sizeY;
+      yy = new float[rows_yy * cols_yy];
+
+      for( i=0; i<sizeX; i++) {
+        for( j=0; j<sizeY; j++) {
+          xx[i * sizeY + j] = (float)(dX[i * sizeY + j] * dX[i * sizeY + j]);
+          xy[i * sizeY + j] = (float)(dX[i * sizeY + j] * dY[i * sizeY + j]);            
+          yy[i * sizeY + j] = (float)(dY[i * sizeY + j] * dY[i * sizeY + j]);            
+        }
+      }
+
+      c_xx = calcAreaSum(xx, sizeY, sizeX);
+      c_xy = calcAreaSum(xy, sizeY, sizeX);
+      c_yy = calcAreaSum(yy, sizeY, sizeX);    
+
+      rows_tr = sizeX;
+      cols_tr = sizeY;
+      tr = new float[rows_tr * cols_tr];
+      rows_det = sizeX;
+      cols_det = sizeY;
+      det = new float[rows_det * cols_det];
+      this.m_rows = sizeX;
+      this.m_cols = sizeY;
+      image = this.m_image = new float[this.m_rows * this.m_cols];        
+
+      for( i=0; i<sizeX; i++) {
+        for( j=0; j<sizeY; j++) {
+          tr[i * sizeY + j] = c_xx[i * sizeY + j] + c_yy[i * sizeY + j];
+          det[i * sizeY + j] = c_xx[i * sizeY + j] * c_yy[i * sizeY + j] 
+                                                          - c_xy[i * sizeY + j] * c_xy[i * sizeY + j];            
+//        lambda[i * sizeY + j] = (float)(det[i * sizeY + j]/(tr[i * sizeY + j]) + 0.00001);       
+          image[i * sizeY + j] = (float)((det[i * sizeY + j]*100000)
+              /((tr[i * sizeY + j]*100000) + 0.1));  
+        }
+      }
+    }
+
+    public float[] calcAreaSum(float[] src, 
+        int sizeY, 
+        int sizeX) {
+      int nave, nave_half, i, j, k;
+      float[] ret, a1;
+      int rows_ret, cols_ret, rows_a1, cols_a1;
+      float a1sum;
+
+      nave = this.WINSZ;
+      nave_half = (int)(Math.floor((nave+1)/2))-1;
+
+      rows_ret = sizeX;
+      cols_ret = sizeY;
+      ret = new float[rows_ret * cols_ret];
+
+      for(i=0; i<sizeX; i++) {
+        rows_a1 = 1;
+        cols_a1 = sizeY+nave;
+        a1 = new float[rows_a1 * cols_a1];
+
+        for(j=0; j<sizeY; j++) {
+          a1[j+nave_half] = src[i*sizeY+j];
+        }
+
+        a1sum = 0;
+        for(k=0; k<nave; k++) {
+          a1sum += a1[k];
+        }
+
+        for(j=0; j<sizeY; j++) {
+          ret[i*sizeY+j] = a1sum;
+          a1sum += a1[j+nave] - a1[j];
+        }
+      }
+      a1 = null;
+
+      for(i=0; i<sizeY; i++) {
+        rows_a1 = 1;
+        cols_a1 = sizeX+nave;
+        a1 = new float[rows_a1 * cols_a1];
+
+        for(j=0; j<sizeX; j++) {
+          a1[j+nave_half] = ret[j*sizeY+i];
+        }
+
+        a1sum = 0;
+        for(k=0; k<nave; k++) {
+          a1sum += a1[k];
+        }
+
+        for(j=0; j<sizeX; j++) {
+          ret[j*sizeY+i] = a1sum;
+          a1sum += a1[j+nave] - a1[j];
+        }
+      }
+      a1 = null;
+
+      return ret; 
+    }
+    
+    public void reshape() {
+      float[] out, image;
+      int i, j, k;
+      int r, c;
+
+      image = this.m_image;
+      r = this.m_rows;
+      c = this.m_cols;
+
+      out = new float[r * c];
+
+      k = 0;
+      for(i=0; i<c; i++) {
+        for(j=0; j<r; j++) {
+          out[k++] = image[j * c + i];
+        }
+      }
+      this.m_image = out;
+      this.m_rows = r * c;
+      this.m_cols = 1;
+      this.m_r= r;
+    }
+
+    
+    public void printImage() {
+      //    result validation
+      for(int i=0; i<this.m_rows; i++) {
+          for(int j=0; j<this.m_cols; j++) {
+              System.printI((int)(this.m_image[i * this.m_cols + j]*10));
+          }
+      }
+    }
+    
+    
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/tracking/TrackDemo.java b/Robust/src/Benchmarks/oooJava/tracking/TrackDemo.java
new file mode 100644
index 00000000..fbc713ed
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/TrackDemo.java
@@ -0,0 +1,1315 @@
+public class TrackDemo {
+  /* input data and the counter to record the input to be processed next */
+  int[][] m_inputs;
+  int m_count;
+
+  /* current processing image related */
+  float[] m_image; // Icur/Jpyr1
+  int m_rows;
+  int m_cols;
+  float[] m_image_resized; // Jpyr2
+  int m_rows_r;
+  int m_cols_r;
+
+  /* BP related */
+  int m_num_bp;
+  /* BPL related */
+  int m_num_bpl;
+
+  /* feature related */
+  float[] m_features;
+  int m_rows_f;
+  int m_cols_f;
+
+  /*  */
+  float[][] m_3f;
+  int m_rows_3f;
+  int m_cols_3f;
+  int m_counter_3f;
+  int m_num_p;
+
+  /* benchmark constants */
+  public int WINSZ;
+  public int N_FEA;
+  int SUPPRESION_RADIUS;
+  int LK_ITER;
+  int m_counter;
+  float accuracy;
+
+  /* constructor */
+  public TrackDemo(int nump) {
+    this.m_inputs = new int[2][];
+
+    int rows = 10 * 60; // * 2;
+    int cols = 12 * 5;
+    int offset = 0;
+    this.m_inputs[0] = this.makeImage(rows, cols, offset);
+    offset = 100;
+    this.m_inputs[1] = this.makeImage(rows, cols, offset);
+    this.m_count = 0;
+
+    this.m_num_bp = 0;
+    this.m_num_bpl = 0;
+
+    this.WINSZ = 8;
+    this.N_FEA = 16; // 00;
+    this.SUPPRESION_RADIUS = 10;
+    this.LK_ITER = 20;
+    this.accuracy = (float) 0.03;
+    this.m_counter = 2;
+    // #ifdef test
+    /*
+     * this.WINSZ = 2; this.N_FEA = 10; this.LK_ITER = 1; this.m_counter = 2;
+     * this.accuracy = (float)0.1; /* //#ifdef sim_fast this.WINSZ = 4;
+     * this.N_FEA = 10; this.LK_ITER = 2; this.counter = 2;
+     * 
+     * //#ifdef sim this.WINSZ = 4; this.N_FEA = 20; this.LK_ITER = 4;
+     * this.counter = 2;
+     */
+    this.m_3f = new float[3][this.N_FEA];
+    this.m_rows_3f = this.N_FEA;
+    this.m_cols_3f = this.N_FEA;
+    this.m_cols_3f = 1;
+//    this.m_counter_3f = 3;
+    this.m_num_p = nump;
+
+    this.m_rows = 0;
+    this.m_cols = 0;
+    this.m_image = null;
+    this.m_image_resized = null;
+    this.m_rows_r = 0;
+    this.m_cols_r = 0;
+
+    this.m_features = null;
+    this.m_rows_f = 0;
+    this.m_cols_f = 0;
+  }
+
+  public int getNumP() {
+    return this.m_num_p;
+  }
+
+  public boolean isFinish() {
+    return (this.m_count == this.m_counter);
+  }
+
+  public int getRows() {
+    return this.m_rows;
+  }
+
+  public int getCols() {
+    return this.m_cols;
+  }
+
+  public float[] getImage() {
+    return this.m_image;
+  }
+
+  public int getRowsR() {
+    return this.m_rows_r;
+  }
+
+  public int getColsR() {
+    return this.m_cols_r;
+  }
+
+  public float[] getImageR() {
+    return this.m_image_resized;
+  }
+
+  public int[] getInput(boolean isadvance) {
+    int[] input = this.m_inputs[this.m_count];
+    if (isadvance) {
+      this.m_count++;
+    }
+
+    return input;
+  }
+
+  public void setBPNum(int num) {
+    this.m_num_bp = num;
+  }
+
+  public void setBPLNum(int num) {
+    this.m_num_bpl = num;
+  }
+
+  public int[] makeImage(int rows, int cols, int offset) {
+    int k, i, j;
+    int[] out;
+
+    out = new int[rows * cols + 4];
+    out[0] = rows;
+    out[1] = cols;
+    out[2] = rows * cols;
+    out[3] = 2;
+
+    k = offset;
+    for (i = 0; i < rows; i++) {
+      for (j = 0; j < cols; j++) {
+        out[i * cols + j + 4] = ((k++) * rows) % 255;
+      }
+    }
+
+    return out;
+  }
+
+  public boolean addBP(BlurPiece bp) {
+    int startRow = bp.getRowsRS();
+    int endRow = bp.getRowsRE();
+    int i, j, k, cols;
+    float[] image, input;
+
+    if (this.m_image == null) {
+      this.m_rows = bp.getRows();
+      this.m_cols = bp.getCols();
+      this.m_image = new float[this.m_rows * this.m_cols];
+    }
+    image = this.m_image;
+    cols = this.m_cols;
+
+    input = bp.getResult();
+    k = 0;
+    for (i = startRow; i < endRow; i++) {
+      for (j = 0; j < cols; j++) {
+        image[i * cols + j] = input[k * cols + j];
+      }
+      k++;
+    }
+
+    this.m_num_bp--;
+    return (0 == this.m_num_bp);
+  }
+
+  public boolean addBPL(BlurPieceL bpl) {
+    int startRow = bpl.getRowsRS();
+    int endRow = bpl.getRowsRE();
+    int i, j, k, cols;
+    float[] image, input;
+
+    if (this.m_image == null) {
+      this.m_rows = bpl.getRows();
+      this.m_cols = bpl.getCols();
+      this.m_image = new float[this.m_rows * this.m_cols];
+    }
+    image = this.m_image;
+    cols = this.m_cols;
+
+    input = bpl.getResult();
+    k = 0;
+    for (i = startRow; i < endRow; i++) {
+      for (j = 0; j < cols; j++) {
+        image[i * cols + j] = input[k * cols + j];
+      }
+      k++;
+    }
+
+    this.m_num_bpl--;
+    return (0 == this.m_num_bpl);
+  }
+
+  public void postBlur() {
+    int rows, cols;
+    float temp;
+    int[] kernel;
+    int rows_k, cols_k;
+    int k, i, j;
+    int kernelSize, startCol, endCol, halfKernel, startRow, endRow, kernelSum;
+    float[] image;
+
+    rows = this.m_rows;
+    cols = this.m_cols;
+    image = this.m_image;
+
+    kernel = new int[5];
+    rows_k = 1;
+    cols_k = 5;
+
+    kernel[0] = 1;
+    kernel[1] = 4;
+    kernel[2] = 6;
+    kernel[3] = 4;
+    kernel[4] = 1;
+
+    kernelSize = 5;
+    kernelSum = 16;
+
+    startCol = 2; // ((kernelSize)/2);
+    endCol = cols - 2; // round(cols - (kernelSize/2));
+    halfKernel = 2; // (kernelSize-1)/2;
+
+    startRow = 2; // (kernelSize)/2;
+    endRow = rows - 2; // (rows - (kernelSize)/2);
+
+    for (i = startRow; i < endRow; i++) {
+      for (j = startCol; j < endCol; j++) {
+        temp = 0;
+        for (k = -halfKernel; k <= halfKernel; k++) {
+          temp += (float) ((image[(i + k) * cols + j] * (float) (kernel[k + halfKernel])));
+        }
+        image[i * cols + j] = (float) (temp / kernelSum);
+      }
+    }
+  }
+
+  public float[] resize(float image[]){
+    int m, k, i, j;
+    int kernel[];
+    int rows_k, cols_k;
+    float tempVal;
+    int kernelSize, startCol, endCol, halfKernel, startRow, endRow, kernelSum;
+    int outputRows, outputCols;
+    float temp[];
+    int rows_t;
+    int cols_t;
+    float[]  resized;
+    int rows = this.m_rows;
+    int cols = this.m_cols;
+
+    // level 1 is the base image.
+
+    outputRows = (int) (Math.floor((rows + 1) / 2));
+    outputCols = (int) (Math.floor((cols + 1) / 2));
+
+    rows_t = rows;
+    cols_t = outputCols;
+    temp = new float[rows_t * cols_t];
+
+    this.m_rows_r = outputRows;
+    this.m_cols_r = outputCols;
+    resized =new float[this.m_rows_r * this.m_cols_r];
+
+    rows_k = 1;
+    cols_k = 5;
+    kernel = new int[rows_k * cols_k];
+
+    kernel[0] = 1;
+    kernel[1] = 4;
+    kernel[2] = 6;
+    kernel[3] = 4;
+    kernel[4] = 1;
+
+    kernelSize = 5;
+    kernelSum = 16;
+
+    startCol = 2; // (kernelSize/2);
+    endCol = cols - 2; // (int)(cols - (kernelSize/2));
+    halfKernel = 2; // (kernelSize-1)/2;
+
+    startRow = 2; // kernelSize/2;
+    endRow = rows - 2; // (rows - (kernelSize)/2);
+
+    for (i = startRow; i < endRow; i++) {
+      m = 0;
+      for (j = startCol; j < endCol; j += 2) {
+        tempVal = 0;
+        for (k = -halfKernel; k <= halfKernel; k++) {
+          tempVal += (float) (image[i * cols + (j + k)] * (float) (kernel[k + halfKernel]));
+        }
+        temp[i * outputCols + m] = (float) (tempVal / kernelSum);
+        m = m + 1;
+      }
+    }
+
+    m = 0;
+    for (i = startRow; i < endRow; i += 2) {
+      for (j = 0; j < outputCols; j++) {
+        tempVal = 0;
+        for (k = -halfKernel; k <= halfKernel; k++) {
+          tempVal += (float) (temp[(i + k) * outputCols + j] * (float) (kernel[k + halfKernel]));
+        }
+        resized[m * outputCols + j] = (float) (tempVal / kernelSum);
+      }
+      m = m + 1;
+    }
+    return resized;
+  }
+  
+  public void resize() {
+    int m, k, i, j;
+    int kernel[];
+    int rows_k, cols_k;
+    float tempVal;
+    int kernelSize, startCol, endCol, halfKernel, startRow, endRow, kernelSum;
+    int outputRows, outputCols;
+    float temp[];
+    int rows_t;
+    int cols_t;
+    float[] image, resized;
+    int rows = this.m_rows;
+    int cols = this.m_cols;
+
+    // level 1 is the base image.
+
+    outputRows = (int) (Math.floor((rows + 1) / 2));
+    outputCols = (int) (Math.floor((cols + 1) / 2));
+
+    rows_t = rows;
+    cols_t = outputCols;
+    temp = new float[rows_t * cols_t];
+
+    this.m_rows_r = outputRows;
+    this.m_cols_r = outputCols;
+    resized = this.m_image_resized = new float[this.m_rows_r * this.m_cols_r];
+    image = this.m_image;
+
+    rows_k = 1;
+    cols_k = 5;
+    kernel = new int[rows_k * cols_k];
+
+    kernel[0] = 1;
+    kernel[1] = 4;
+    kernel[2] = 6;
+    kernel[3] = 4;
+    kernel[4] = 1;
+
+    kernelSize = 5;
+    kernelSum = 16;
+
+    startCol = 2; // (kernelSize/2);
+    endCol = cols - 2; // (int)(cols - (kernelSize/2));
+    halfKernel = 2; // (kernelSize-1)/2;
+
+    startRow = 2; // kernelSize/2;
+    endRow = rows - 2; // (rows - (kernelSize)/2);
+
+    for (i = startRow; i < endRow; i++) {
+      m = 0;
+      for (j = startCol; j < endCol; j += 2) {
+        tempVal = 0;
+        for (k = -halfKernel; k <= halfKernel; k++) {
+          tempVal += (float) (image[i * cols + (j + k)] * (float) (kernel[k + halfKernel]));
+        }
+        temp[i * outputCols + m] = (float) (tempVal / kernelSum);
+        m = m + 1;
+      }
+    }
+
+    m = 0;
+    for (i = startRow; i < endRow; i += 2) {
+      for (j = 0; j < outputCols; j++) {
+        tempVal = 0;
+        for (k = -halfKernel; k <= halfKernel; k++) {
+          tempVal += (float) (temp[(i + k) * outputCols + j] * (float) (kernel[k + halfKernel]));
+        }
+        resized[m * outputCols + j] = (float) (tempVal / kernelSum);
+      }
+      m = m + 1;
+    }
+  }
+
+  public boolean addIDX(IDX idx) {
+    float[][] m3f = this.m_3f;
+    int rows = idx.getRowsRS();
+    int rowe = idx.getRowsRE();
+    int threshold = this.N_FEA;
+    int[] ind = idx.getInd();
+    float[] image = idx.getImage();
+    int r = idx.getR();
+    int nfea = this.N_FEA;
+    int length = this.m_rows * this.m_cols;
+    int[] h_ind = new int[this.N_FEA];
+    boolean[] f_ind = new boolean[this.N_FEA];
+    for (int i = 0; i < this.N_FEA; i++) {
+      f_ind[i] = false;
+    }
+
+    int j = 0;
+    int localindex = 0;
+    int rindex = 0;
+    for (int i = rows; i < rowe; i++) {
+      rindex = length - ind[j];
+      if (rindex < nfea) {
+        localindex = j + rows;
+        if (!f_ind[rindex]) {
+          // empty
+          m3f[2][rindex] = image[localindex];
+          h_ind[rindex] = localindex;
+          localindex++;
+          m3f[0][rindex] = Math.ceilf((float) (localindex / (float) r));
+          m3f[1][rindex] = (float) localindex - (m3f[0][rindex] - 1) * (float) r * (float) 1.0;
+          f_ind[rindex] = true;
+        } else {
+          // previously held by some others with the same value
+          int k = rindex; // the place to insert
+          int k1 = rindex; // the first one which is not set
+          for (; k1 < nfea; k1++) {
+            if (h_ind[k1] > localindex) {
+              k = k1;
+            }
+            if (!f_ind[k1]) {
+              break;
+            }
+          }
+          if (k == nfea) {
+            // System.printI(77777777);
+            return false;
+          } else if (k == rindex) {
+            k = k1;
+          }
+          if (f_ind[k] && (m3f[2][k] != image[localindex])) {
+            // System.printI(88888888);
+            return false;
+          }
+          // move all things after k behind
+          int p = k1;
+          for (; p > k; p--) {
+            m3f[2][p] = m3f[2][p - 1];
+            h_ind[p] = h_ind[p - 1];
+            m3f[0][p] = m3f[0][p - 1];
+            m3f[1][p] = m3f[1][p - 1];
+            f_ind[p] = true;
+          }
+          // insert
+          m3f[2][p] = image[localindex];
+          h_ind[p] = localindex;
+          localindex++;
+          m3f[0][p] = Math.ceilf((float) (localindex / (float) r));
+          m3f[1][p] = (float) localindex - (m3f[0][p] - 1) * (float) r * (float) 1.0;
+          f_ind[p] = true;
+        }
+      }
+      j++;
+    }
+
+    this.m_num_p--;
+
+    return (0 == this.m_num_p);
+  }
+
+  public void calcFeatures() {
+    float[] f1, f2, f3;
+    int rows_f1, cols_f1, rows_f2, cols_f2, rows_f3, cols_f3;
+    float[] interestPnts;
+    int[] rows_ip, cols_ip;
+    int rows_ipt, cols_ipt;
+    rows_ip = new int[1];
+    cols_ip = new int[1];
+
+    f1 = this.m_3f[0];
+    f2 = this.m_3f[1];
+    f3 = this.m_3f[2];
+    rows_f1 = this.m_rows_3f;
+    rows_f2 = this.m_rows_3f;
+    rows_f3 = this.m_rows_3f;
+    cols_f1 = this.m_cols_3f;
+    cols_f2 = this.m_cols_3f;
+    cols_f3 = this.m_cols_3f;
+
+    interestPnts =
+        this.getANMs(f1, rows_f1, cols_f1, f2, rows_f2, cols_f2, f3, rows_f3, cols_f3, rows_ip,
+            cols_ip);
+    rows_ipt = rows_ip[0];
+    cols_ipt = cols_ip[0];
+    rows_ip = cols_ip = null;
+
+    // fTranspose(interestPnts)
+    float[] trans;
+    int i, j, k, rows_trans, cols_trans;
+
+    rows_trans = cols_ipt;
+    cols_trans = rows_ipt;
+    trans = new float[rows_trans * cols_trans];
+
+    k = 0;
+    for (i = 0; i < cols_ipt; i++) {
+      for (j = 0; j < rows_ipt; j++) {
+        trans[k++] = interestPnts[j * cols_ipt + i];
+      }
+    }
+
+    // fDeepCopyRange(interestPnt, 0, 2, 0, cols_ip[0])
+    int rows, cols;
+    int numberRows = 2;
+    int startRow = 0;
+    int numberCols = cols_trans;
+    int startCol = 0;
+
+    rows = numberRows + startRow;
+    cols = numberCols + startCol;
+
+    rows_ipt = numberRows;
+    cols_ipt = numberCols;
+    interestPnts = new float[rows_ipt * cols_ipt];
+
+    k = 0;
+    for (i = startRow; i < rows; i++) {
+      for (j = startCol; j < cols; j++) {
+        interestPnts[k++] = trans[i * cols_trans + j];
+      }
+    }
+
+    float[] features;
+    this.m_rows_f = 2;
+    this.m_cols_f = cols_ipt;
+    
+    features = this.m_features = new float[this.m_rows_f * this.m_cols_f];
+    for (i = 0; i < 2; i++) {
+      for (j = 0; j < cols_ipt; j++) {
+        features[i * cols_ipt + j] = interestPnts[i * cols_ipt + j];
+      }
+    }
+  }
+
+  public float[] horzcat(float[] f1, int rows_f1, int cols_f1, float[] f2, int rows_f2,
+      int cols_f2, float[] f3, int rows_f3, int cols_f3) {
+    float[] out;
+    int rows = 0, cols = 0, i, j, k, c_1, c_2, r_3, c_3;
+
+    c_1 = cols_f1;
+    cols += c_1;
+
+    c_2 = cols_f2;
+    cols += c_2;
+
+    r_3 = rows_f3;
+    c_3 = cols_f3;
+    cols += c_3;
+
+    rows = r_3;
+
+    out = new float[rows * cols];
+
+    for (i = 0; i < rows; i++) {
+      k = 0;
+      for (j = 0; j < c_1; j++) {
+        out[i * cols + k] = f1[i * c_1 + j];
+        k++;
+      }
+      for (j = 0; j < c_2; j++) {
+        out[i * cols + k] = f2[i * c_2 + j];
+        k++;
+      }
+      for (j = 0; j < c_3; j++) {
+        out[i * cols + k] = f3[i * c_3 + j];
+        k++;
+      }
+    }
+
+    return out;
+  }
+
+  public int[] fSortIndices(float[] input, int rows, int cols) {
+    float[] in;
+    int i, j, k;
+    int[] ind;
+
+    // fDeepCopy
+    in = new float[input.length];
+    for (i = 0; i < input.length; i++) {
+      in[i] = input[i];
+    }
+
+    ind = new int[rows * cols];
+
+    for (k = 0; k < cols; k++) {
+      for (i = 0; i < rows; i++) {
+        float localMax = in[i * cols + k];
+        int localIndex = i;
+        ind[i * cols + k] = i;
+        for (j = 0; j < rows; j++) {
+          if (localMax < in[j * cols + k]) {
+            ind[i * cols + k] = j;
+            localMax = in[j * cols + k];
+            localIndex = j;
+          }
+        }
+        in[localIndex * cols + k] = 0;
+      }
+    }
+
+    return ind;
+  }
+
+  public float[] ffVertcat(float[] matrix1, int rows_m1, int cols_m1, float[] matrix2, int rows_m2,
+      int cols_m2) {
+    float[] outMatrix;
+    int rows_o, cols_o, i, j, k;
+
+    rows_o = rows_m1 + rows_m2;
+    cols_o = cols_m1;
+    outMatrix = new float[rows_o * cols_o];
+
+    for (i = 0; i < cols_m1; i++) {
+      for (j = 0; j < rows_m1; j++) {
+        outMatrix[j * cols_m1 + i] = matrix1[j * cols_m1 + i];
+      }
+      for (k = 0; k < rows_m2; k++) {
+        outMatrix[(k + rows_m1) * cols_m1 + i] = matrix2[k * cols_m2 + i];
+      }
+    }
+
+    return outMatrix;
+
+  }
+
+  public float[] getANMs(float[] f1, int rows_f1, int cols_f1, float[] f2, int rows_f2,
+      int cols_f2, float[] f3, int rows_f3, int cols_f3, int[] rows_ip, int[] cols_ip) {
+    float MAX_LIMIT = (float) 100000000;
+    float C_ROBUST = (float) 1.0;
+    float[] suppressR, points, srtdPnts, tempF, srtdV, interestPnts, temp;
+    int rows_sr, cols_sr, rows_p, cols_p, rows_sp, cols_sp, rows_tf, cols_tf;
+    int rows_sv, cols_sv, rows_tmp, cols_tmp;
+    int[] srtdVIdx, supId;
+    int rows_svi, cols_svi, rows_si, cols_si;
+    float t, t1, r_sq;
+    int n, i, j, k, validCount, cnt, end, iter, rows, cols;
+    int supIdPtr = 0;
+
+    r_sq = (float) (this.SUPPRESION_RADIUS ^ 2);
+    points = this.horzcat(f1, rows_f1, cols_f1, f2, rows_f2, cols_f2, f3, rows_f3, cols_f3);
+    rows_p = rows_f3;
+    cols_p = cols_f1 + cols_f2 + cols_f3;
+    n = rows_f3;
+
+    /** sort() arg 2 is for descend = 1, arg3 = indices. Returns sorted values **/
+
+    srtdVIdx = this.fSortIndices(f3, rows_f3, cols_f3);
+    rows_svi = rows_f3;
+    cols_svi = cols_f3;
+
+    rows_sp = rows_svi;
+    cols_sp = cols_p;
+    srtdPnts = new float[rows_sp * cols_sp];
+
+    for (i = 0; i < rows_sp; i++) {
+      for (j = 0; j < cols_sp; j++) {
+        srtdPnts[i * cols_sp + j] = points[srtdVIdx[i] * cols_sp + j];
+      }
+    }
+
+    rows_tmp = 1;
+    cols_tmp = 3;
+    temp = new float[rows_tmp * cols_tmp];
+    rows_sr = n;
+    cols_sr = 1;
+    suppressR = new float[rows_sr * cols_sr];
+    for (i = 0; i < rows_sr; i++) {
+      for (j = 0; j < cols_sr; j++) {
+        suppressR[i * cols_sr + j] = MAX_LIMIT;
+      }
+    }
+
+    validCount = 0;
+    iter = 0;
+    for (i = 0; i < rows_sr; i++) {
+      if (suppressR[i] > r_sq) {
+        validCount++;
+      }
+    }
+
+    k = 0;
+    rows_si = validCount;
+    cols_si = 1;
+    supId = new int[rows_si * cols_si];
+    for (i = 0; i < (rows_sr * cols_sr); i++) {
+      if (suppressR[i] > r_sq) {
+        supId[k++] = i;
+      }
+    }
+   
+
+    while (validCount > 0) {
+      float[] tempp, temps;
+      int rows_tpp, cols_tpp, rows_tps, cols_tps;
+      temp[0] = srtdPnts[supId[0] * cols_sp + 0];
+      temp[1] = srtdPnts[supId[0] * cols_sp + 1];
+      temp[2] = srtdPnts[supId[0] * cols_sp + 2];
+
+      if (iter == 0) {
+        interestPnts = temp;
+        rows_ip[0] = rows_tmp;
+        cols_ip[0] = cols_tmp;
+      } else {
+        interestPnts =
+            this.ffVertcat(interestPnts, rows_ip[0], cols_ip[0], temp, rows_tmp, cols_tmp);
+        rows_ip[0] = rows_ip[0] + rows_tmp;
+        cols_ip[0] = cols_ip[0];
+      }
+
+      iter++;
+
+      // fDeepCopy
+      rows_tpp = rows_sp;
+      cols_tpp = cols_sp;
+      tempp = new float[rows_tpp * cols_tpp];
+      for (i = 0; i < rows_tpp * cols_tpp; i++) {
+        tempp[i] = srtdPnts[i];
+      }
+      // fDeepCopy
+      rows_tps = rows_sr;
+      cols_tps = cols_sr;
+      temps = new float[rows_tps * cols_tps];
+      for (i = 0; i < rows_tps * cols_tps; i++) {
+        temps[i] = suppressR[i];
+      }
+
+      rows_sp = validCount - 1;
+      cols_sp = 3;
+      srtdPnts = new float[rows_sp * cols_sp];
+      rows_sr = validCount - 1;
+      cols_sr = 1;
+      suppressR = new float[rows_sr * cols_sr];
+
+      k = 0;
+      for (i = 0; i < (validCount - 1); i++) {
+        srtdPnts[i * cols_sp + 0] = tempp[supId[i + 1] * cols_sp + 0];
+        srtdPnts[i * cols_sp + 1] = tempp[supId[i + 1] * cols_sp + 1];
+        srtdPnts[i * cols_sp + 2] = tempp[supId[i + 1] * cols_sp + 2];
+        suppressR[i * cols_sr + 0] = temps[supId[i + 1] * cols_sr + 0];
+      }
+
+      int rows1 = rows_ip[0] - 1;
+      int cols1 = cols_ip[0];
+      for (i = 0; i < rows_sp; i++) {
+        t = (float) 0;
+        t1 = (float) 0;
+        if ((C_ROBUST * interestPnts[rows1 * cols1 + 2]) >= srtdPnts[supId[i] * cols_sp + 2]) {
+          t = srtdPnts[supId[i] * cols_sp + 0] - interestPnts[rows1 * cols1 + 0];
+          t1 = srtdPnts[supId[i] * cols_sp + 1] - interestPnts[rows1 * cols1 + 1];
+          t = t * t + t1 * t1;
+          t1 = (float) 0;
+        }
+
+        if ((C_ROBUST * interestPnts[rows1 * cols1 + 2]) < srtdPnts[supId[i] * cols_sp + 2]) {
+          t1 = (float) 1 * (float) MAX_LIMIT;
+        }
+
+        if (suppressR[supId[i]] > (t + t1)) {
+          suppressR[supId[i]] = t + t1;
+        }
+      }
+
+      validCount = 0;
+      for (i = 0; i < rows_sr; i++) {
+        if (suppressR[i] > r_sq) {
+          validCount++;
+        }
+      }
+
+      k = 0;
+      rows_si = validCount;
+      cols_si = 1;
+      supId = new int[rows_si * cols_si];
+
+      for (i = 0; i < rows_sr * cols_sr; i++) {
+        if (suppressR[i] > r_sq) {
+          supId[k++] = i;
+        }
+      }
+    }
+
+    return interestPnts;
+  }
+
+  public void startTrackingLoop() {
+    this.m_image = null;
+    this.m_image_resized = null;
+  }
+
+  public float[] getInterpolatePatch(float[] src, int rows, int cols, float centerX, float centerY) {
+    float[] dst;
+    int rows_d, cols_d;
+    float a, b, a11, a12, a21, a22;
+    int i, j, srcIdxX, dstIdxX, srcIdy, dstIdy, dstIndex;
+
+    a = centerX - (float) (Math.floor(centerX));
+    b = centerY - (float) (Math.floor(centerY));
+
+    a11 = (1 - a) * (1 - b);
+    a12 = a * (1 - b);
+    a21 = (1 - a) * b;
+    a22 = a * b;
+
+    rows_d = 1;
+    cols_d = 2 * this.WINSZ * 2 * this.WINSZ;
+    dst = new float[rows_d * cols_d];
+
+    for (i = -this.WINSZ; i <= (this.WINSZ - 1); i++) {
+      srcIdxX = (int) (Math.floor(centerX)) + i;
+      dstIdxX = i + this.WINSZ;
+
+      for (j = -this.WINSZ; j <= (this.WINSZ - 1); j++) {
+        srcIdy = (int) (Math.floor(centerY)) + j;
+        dstIdy = j + this.WINSZ;
+        dstIndex = dstIdy * 2 * this.WINSZ + dstIdxX;
+        // printf("%f\t%f\t%d\t%d\n", centerX, centerY, srcIdxX, srcIdy);
+        dst[dstIndex] =
+            src[srcIdy * cols + srcIdxX] * a11 + src[(srcIdy + 1) * cols + srcIdxX] * a12
+                + src[srcIdy * cols + (srcIdxX + 1)] * a21
+                + src[(srcIdy + 1) * cols + (srcIdxX + 1)] * a22;
+      }
+    }
+
+    return dst;
+  }
+
+  public int[] calcPyrLKTrack(float[][] Ipyrs, int[] rows, int[] cols, float[] newPnt) {
+    float[] ip1, ip2, idxp1, idxp2, idyp1, idyp2, jp1, jp2, fPnt;
+    int k = 0;
+
+    ip1 = Ipyrs[k++];
+    ip2 = Ipyrs[k++];
+    idxp1 = Ipyrs[k++];
+    idyp1 = Ipyrs[k++];
+    idxp2 = Ipyrs[k++];
+    idyp2 = Ipyrs[k++];
+    jp1 = this.m_image;
+    jp2 = this.m_image_resized;
+    fPnt = this.m_features;
+
+    int idx, level, pLevel, i, winSizeSq;
+    int[] valid, imgDims;
+    int rows_v, cols_v, rows_id, cols_id;
+    float[] rate, iPatch, jPatch, iDxPatch, iDyPatch;
+    int rows_r, cols_r, rows_ip, cols_ip, rows_jp, cols_jp;
+    int rows_idxp, cols_idxp, rows_idyp, cols_idyp;
+    float x, y, dX, dY, c_xx, c_yy, c_xy, tr;
+    int imgSize_1, /* max_iter, */imgSize_2;
+    float mX, mY, dIt, eX, eY, c_det;
+    int nFeatures = this.m_cols_f;
+
+    rows_id = 4;
+    cols_id = 1;
+    imgDims = new int[rows_id * cols_id];
+
+    imgDims[0] = rows[0];
+    imgDims[1] = cols[0];
+    imgDims[2] = rows[1];
+    imgDims[3] = cols[1];
+
+    pLevel = 2;
+    rows_r = 1;
+    cols_r = 6;
+    rate = new float[rows_r * cols_r];
+
+    rate[0] = (float) 1;
+    rate[1] = (float) 0.5;
+    rate[2] = (float) 0.25;
+    rate[3] = (float) 0.125;
+    rate[4] = (float) 0.0625;
+    rate[5] = (float) 0.03125;
+
+    winSizeSq = 4 * this.WINSZ * this.WINSZ;
+    rows_ip = 1;
+    cols_ip = winSizeSq;
+    iPatch = new float[rows_ip * cols_ip];
+    rows_jp = 1;
+    cols_jp = winSizeSq;
+    jPatch = new float[rows_jp * cols_jp];
+    rows_idxp = 1;
+    cols_idxp = winSizeSq;
+    iDxPatch = new float[rows_idxp * cols_idxp];
+    rows_idyp = 1;
+    cols_idyp = winSizeSq;
+    iDyPatch = new float[rows_idyp * cols_idyp];
+
+    rows_v = 1;
+    cols_v = nFeatures;
+    valid = new int[rows_v * cols_v];
+    for(int valid_idx=0;valid_idx<valid.length;valid_idx++){
+      valid[valid_idx]=1;
+    }
+
+    for (i = 0; i < nFeatures; i++) {
+      dX = (float) 0;
+      dY = (float) 0;
+      x = fPnt[i * 2 + 0] * rate[pLevel];
+      y = fPnt[i * 2 + 1] * rate[pLevel];
+      c_det = (float) 0;
+
+      for (level = pLevel - 1; level >= 0; level--) {
+        x = x + x;
+        y = y + y;
+        dX = dX + dX;
+        dY = dY + dY;
+        imgSize_1 = imgDims[level * 2];
+        imgSize_2 = imgDims[level * 2 + 1];
+
+        c_xx = (float) 0;
+        c_xy = (float) 0;
+        c_yy = (float) 0;
+
+        if ((x - (float) this.WINSZ) < (float) 0 || (y - (float) this.WINSZ) < (float) 0
+            || (y + (float) this.WINSZ) >= (float) imgSize_1
+            || (x + (float) this.WINSZ) >= (float) imgSize_2) {
+          valid[i] = 0;
+          break;
+        }
+
+        if (level == 0) {
+          iPatch = getInterpolatePatch(ip1, rows[0], cols[0], x, y);
+          iDxPatch = getInterpolatePatch(idxp1, rows[2], cols[2], x, y);
+          iDyPatch = getInterpolatePatch(idyp1, rows[3], cols[3], x, y);
+        }
+        if (level == 1) {
+          iPatch = getInterpolatePatch(ip2, rows[1], cols[1], x, y);
+          iDxPatch = getInterpolatePatch(idxp2, rows[4], cols[4], x, y);
+          iDyPatch = getInterpolatePatch(idyp2, rows[5], cols[5], x, y);
+        }
+        rows_ip = rows_idxp = rows_idyp = 1;
+        cols_ip = cols_idxp = cols_idyp = 2 * this.WINSZ * 2 * this.WINSZ;
+
+        for (idx = 0; idx < this.WINSZ; idx++) {
+          c_xx += iDxPatch[idx] * iDxPatch[idx];
+          c_xy += iDxPatch[idx] * iDyPatch[idx];
+          c_yy += iDyPatch[idx] * iDyPatch[idx];
+        }
+
+        c_det = (c_xx * c_yy - c_xy * c_xy);
+        tr = c_xx + c_yy;
+
+        if (c_det == (float) 0) {
+          break;
+        }
+
+        if ((float) (c_det / (tr + (float) 0.00001)) < (float) this.accuracy) {
+          valid[i] = 0;
+          break;
+        }
+
+        c_det = (float) (1 / c_det);
+        for (k = 0; k < this.LK_ITER; /* max_iter; */k++) {
+          if ((x + dX - (float) this.WINSZ) < (float) 0
+              || (y + dY - (float) this.WINSZ) < (float) 0
+              || (y + dY + (float) this.WINSZ) >= (float) imgSize_1
+              || (x + dX + (float) this.WINSZ) >= (float) imgSize_2) {
+            valid[i] = 0;
+            break;
+          }
+
+          // printf("x and dx = %d\t%d\t%f\t%f\t%f\t%f\n", i, level, x, dX, y,
+          // dY);
+          if (level == 0) {
+            jPatch = getInterpolatePatch(jp1, this.m_rows, this.m_cols, x + dX, y + dY);
+          }
+          if (level == 1) {
+            jPatch = getInterpolatePatch(jp2, this.m_rows_r, this.m_cols_r, x + dX, y + dY);
+          }
+          rows_jp = 1;
+          cols_jp = 2 * this.WINSZ * 2 * this.WINSZ;
+
+          eX = 0;
+          eY = 0;
+          for (idx = 0; idx < winSizeSq; idx++) {
+            dIt = iPatch[idx] - jPatch[idx];
+            eX += dIt * iDxPatch[idx];
+            eY += dIt * iDyPatch[idx];
+          }
+
+          mX = c_det * (eX * c_yy - eY * c_xy);
+          mY = c_det * (-eX * c_xy + eY * c_xx);
+          // printf("mx = %d\t%d\t%f\t%f\t%f\t%f\t%f\n", i, level, mX, mY,
+          // c_det, eX, eY);
+          dX = dX + mX;
+          dY = dY + mY;
+
+          if ((mX * mX + mY + mY) < this.accuracy) {
+            break;
+          }
+        }
+      }
+
+      newPnt[i] = fPnt[i * 2] + dX;
+      newPnt[1 * nFeatures + i] = fPnt[i * 2 + 1] + dY;
+
+    }
+
+    return valid;
+  }
+
+  public void calcTrack(IXLM ixlm, IYLM iylm, IXLMR ixlmr, IYLMR iylmr) {
+    float[][] Ipyrs = new float[6][];
+    int[] rows = new int[6];
+    int[] cols = new int[6];
+    float[] newpoints, features, np_temp;
+    int rows_n, cols_n, rows_np, cols_np, i, j, k, m, n, numFind;
+    int[] status;
+    int rows_s, cols_s;
+
+    Ipyrs[0] = ixlm.getImage();
+    rows[0] = ixlm.getRows();
+    cols[0] = ixlm.getCols();
+    Ipyrs[2] = ixlm.getResult();
+    rows[2] = ixlm.getRowsR();
+    cols[2] = ixlm.getColsR();
+    Ipyrs[3] = iylm.getResult();
+    rows[3] = iylm.getRowsR();
+    cols[3] = iylm.getColsR();
+
+    Ipyrs[1] = ixlmr.getImage();
+    rows[1] = ixlmr.getRows();
+    cols[1] = ixlmr.getCols();
+    Ipyrs[4] = ixlmr.getResult();
+    rows[4] = ixlmr.getRowsR();
+    cols[4] = ixlmr.getColsR();
+    Ipyrs[5] = iylmr.getResult();
+    rows[5] = iylmr.getRowsR();
+    cols[5] = iylmr.getColsR();
+
+    features = this.m_features;
+    rows_n = 2;
+    cols_n = this.m_cols_f;
+    newpoints = new float[rows_n * cols_n];
+
+    // status_ = calcPyrLKTrack(...)
+    status = this.calcPyrLKTrack(Ipyrs, rows, cols, newpoints);
+    rows_s = 1;
+    cols_s = this.m_cols_f;
+
+    // fDeepCopy
+    np_temp = new float[newpoints.length];
+    rows_np = rows_n;
+    cols_np = cols_n;
+    for (i = 0; i < newpoints.length; i++) {
+      np_temp[i] = newpoints[i];
+    }
+    if (rows_s * cols_s > 0) {
+      int[] findInd;
+      int rows_f, cols_f;
+      rows_f = rows_s * cols_s;
+      cols_f = 1;
+      findInd = new int[rows_f * cols_f];
+
+      k = 0;
+      m = 0;
+      numFind = 0;
+      for (i = 0; i < cols_s; i++) {
+        for (j = 0; j < rows_s; j++) {
+          if (status[j * cols_s + i] != 0) {
+            findInd[k] = m;
+            numFind++;
+          } else {
+            findInd[k] = 0;
+          }
+
+          m++;
+          k++;
+        }
+      }
+
+      rows_n = rows_np;
+      cols_n = numFind;
+      newpoints = new float[rows_n * cols_n];
+
+      k = 0;
+      n = 0;
+      for (i = 0; i < rows_np; i++) {
+        for (j = 0; j < cols_np; j++) {
+          m = findInd[j];
+          if (m > 0) {
+            newpoints[k++] = np_temp[i * cols_np + m];
+          }
+        }
+      }
+    }
+
+    // features_ = fDeepCopy(newpoints_);
+    this.m_rows_f = rows_n;
+    this.m_cols_f = cols_n;
+    features = this.m_features = new float[newpoints.length];
+    for (k = 0; k < newpoints.length; k++) {
+      features[k] = newpoints[k];
+    }
+  }
+
+  public void printImage() {
+    // result validation
+    for (int i = 0; i < this.m_rows; i++) {
+      for (int j = 0; j < this.m_cols; j++) {
+        System.printI((int) (this.m_image[i * this.m_cols + j] * 10));
+      }
+    }
+  }
+
+  public void print3f() {
+    // result validation
+    System.out.println(11111111);
+    for (int j = 0; j < this.N_FEA; j++) {
+      System.out.println((int) (this.m_3f[0][j] * 10));
+    }
+    System.printI(22222222);
+    for (int j = 0; j < this.N_FEA; j++) {
+      System.out.println((int) (this.m_3f[1][j] * 10));
+    }
+    System.printI(33333333);
+    for (int j = 0; j < this.N_FEA; j++) {
+      System.out.println((int) (this.m_3f[2][j] * 10));
+    }
+  }
+
+  public void printFeatures() {
+    // result validation
+    System.out.println("this.m_rows_f="+this.m_rows_f);
+    System.out.println("this.m_cols_="+this.m_cols_f);
+    System.out.println("m_features.length="+this.m_features.length);
+    for (int i = 0; i < this.m_rows_f; i++) {
+      for (int j = 0; j < this.m_cols_f; j++) {
+        System.out.println((int) (this.m_features[i * this.m_cols_f + j] * 10));
+      }
+    }
+  }
+
+  public void run() {
+    
+    
+    ImageReader imageReader=new ImageReader();
+    
+//    int[] input = getInput(false);
+    int[]  input=imageReader.readImage("1.bmp");
+    
+    int pnum = 32; // 60;
+    setBPNum(pnum);
+    int range = (input[0]) / pnum;
+    for (int i = 0; i < pnum; i++) {
+      BlurPiece bp = new BlurPiece(i, range, input);
+      bp.blur();
+      addBP(bp);
+    }
+    postBlur();
+    
+
+    float[] Icur = getImage();
+
+    pnum = 16; // 30;
+    range = getRows() / pnum;
+    int rows = getRows();
+    int cols = getCols();
+
+    // create ImageX to calc Sobel_dX
+    ImageXM imageXM = new ImageXM(pnum, rows, cols);
+    for (int i = 0; i < pnum; i++) {
+      ImageX imageX = new ImageX(i, range, Icur, rows, cols);
+      imageX.calcSobel_dX();
+      imageXM.addCalcSobelResult(imageX);
+    }
+    imageXM.calcSobel_dX();
+
+
+    // create ImageY to calc Sobel_dY
+    ImageYM imageYM = new ImageYM(pnum, rows, cols);
+    for (int i = 0; i < pnum; i++) {
+      ImageY imageY = new ImageY(i, range, Icur, rows, cols);
+      imageY.calcSobel_dY();
+      imageYM.addCalcSobelResult(imageY);
+    }
+    imageYM.calcSobel_dY();
+    
+
+    // create a Lambda to aggregate results from the ImageXs
+    Lambda lda = new Lambda(WINSZ, N_FEA, pnum, getNumP());
+    lda.calcGoodFeature(imageXM, imageYM);
+//    lda.calcGoodFeature(eom_imageXM, eom_imageYM);
+    // validation
+    // lda.printImage();
+    lda.reshape();
+    // validation
+    // lda.printImage();
+    
+    // TASK: calcInd
+    int r = lda.getR();
+    float[] data = lda.getImage();
+    int c_rows = lda.getRows();
+    int c_cols = lda.getCols();
+    int c_pnum = lda.getNumP();
+    int c_range = c_rows / c_pnum;
+
+    IDX IDXarray[]=new IDX[c_pnum];
+    for (int i = 0; i < c_pnum; i++) {
+      IDX idx = new IDX(lda.N_FEA, i, c_range, data, c_rows, c_cols, r);
+      idx.fSortIndices();
+      // validation
+      // idx.printInd();
+      IDXarray[i]=idx;
+    }
+    
+    resize();
+    
+    for (int i = 0; i < c_pnum; i++) {
+      addIDX(IDXarray[i]);
+    }
+
+    // TASK:calcFeatures
+    calcFeatures();
+
+    // TASK:startTrackingLoop
+    do{
+      
+      int pnum1 = 8; // 15; // * 2;
+      data = getImage();
+      rows = getRows();
+      cols = getCols();
+      range = rows / pnum1;
+      
+      IXLM ixlm = new IXLM(pnum1, data, rows, cols);
+      IYLM iylm = new IYLM(pnum1, data, rows, cols);
+      for (int i = 0; i < pnum1; i++) {
+        IXL ixl = new IXL(i, range, data, rows, cols);
+        ixl.calcSobel_dX();
+        ixlm.addCalcSobelResult(ixl);
+        IYL iyl = new IYL(i, range, data, rows, cols);
+        iyl.calcSobel_dY();
+        iylm.addCalcSobelResult(iyl);
+      }
+      ixlm.calcSobel_dX();
+      iylm.calcSobel_dY();
+  
+      data = getImageR();
+      rows = getRowsR();
+      cols = getColsR();
+      range = rows / pnum1;
+      IXLMR ixlmr = new IXLMR(pnum1, data, rows, cols);
+      IYLMR iylmr = new IYLMR(pnum1, data, rows, cols);
+  
+      for (int i = 0; i < pnum1; i++) {
+        IXLR ixl = new IXLR(i, range, data, rows, cols);
+        ixl.calcSobel_dX();
+        ixlmr.addCalcSobelResult(ixl);
+        IYLR imy = new IYLR(i, range, data, rows, cols);
+        imy.calcSobel_dY();
+        iylmr.addCalcSobelResult(imy);
+      }
+      ixlmr.calcSobel_dX();
+      iylmr.calcSobel_dY();
+  
+      int pnum2 = 32; // 60; // * 2;
+//      input = getInput(true);
+      input = imageReader.readImage("1.bmp");
+      this.m_count++;
+      
+      
+//      float ip1[]=new float[getRows()*getCols()];
+//      for(int ip1idx=0;ip1idx<getRows()*getCols();ip1idx++){
+//        ip1[ip1idx]=(float)input[ip1idx+4];
+//      }
+//      float[] ip2=resize(ip1);
+//      
+      
+      range = (input[0]) / pnum2;
+      BlurPieceL bplArray[]=new BlurPieceL[pnum2];
+      for (int i = 0; i < pnum2; i++) {
+        BlurPieceL bpl = new BlurPieceL(i, range, input);
+        bpl.blur();
+        bplArray[i]=bpl;
+      }
+      setBPLNum(pnum2);
+      startTrackingLoop();
+      
+      //task addBPL
+      for(int i=0;i<pnum2;i++){
+        addBPL( bplArray[i]);
+      }
+      postBlur();
+      
+      resize();
+      
+      //task calcTrack
+   
+      calcTrack(ixlm, iylm, ixlmr, iylmr);
+    
+    }while(!isFinish());
+    
+    printFeatures();
+  }
+
+}
diff --git a/Robust/src/Benchmarks/oooJava/tracking/TrackingBench.java b/Robust/src/Benchmarks/oooJava/tracking/TrackingBench.java
new file mode 100644
index 00000000..2dc50c23
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/TrackingBench.java
@@ -0,0 +1,8 @@
+public class TrackingBench {
+
+  public static void main(String args[]) {
+    int nump = 32; // 60;
+    TrackDemo tdmo = new TrackDemo(nump);
+    tdmo.run();
+  }
+}
diff --git a/Robust/src/Benchmarks/oooJava/tracking/TrackingBench_task.java b/Robust/src/Benchmarks/oooJava/tracking/TrackingBench_task.java
new file mode 100644
index 00000000..6b5c8358
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/TrackingBench_task.java
@@ -0,0 +1,440 @@
+package Benchmarks.oooJava.tracking;
+/** Bamboo version
+ *  Ported form SD_VBS 1.0
+ * 
+ * @author jzhou
+ *
+ */
+
+task startup(StartupObject s{initialstate}) {
+  //System.printString("task startup\n");
+ 
+  int nump = 32; //60;
+  TrackDemo tdmo = new TrackDemo(nump){toaddBP};
+  
+  int[] input = tdmo.getInput(false);
+  int pnum = 32; //60;
+  int range = (input[0]) / pnum;
+  for(int i = 0; i < pnum; i++) {
+    BlurPiece bp = new BlurPiece(i,
+                                 range,
+                                 input){toblur};
+  }
+  tdmo.setBPNum(pnum);
+  
+  taskexit(s{!initialstate});
+}
+
+task blur(BlurPiece bp{toblur}) {
+  //System.printString("task blur\n");
+  
+  //bp.printImage();
+  bp.blur();
+  
+  taskexit(bp{!toblur, toaddBP});
+}
+
+task addBP(TrackDemo tdmo{toaddBP},
+           BlurPiece bp{toaddBP}) {
+  //System.printString("task addBP\n");
+  
+  boolean isfinished = tdmo.addBP(bp);
+  
+  if(isfinished) {
+    tdmo.postBlur();
+    //tdmo.printImage();
+    taskexit(tdmo{!toaddBP, topreresize},
+             bp{!toaddBP, finish});
+  } else {
+    taskexit(bp{!toaddBP, finish});
+  }
+}
+
+task preresize(TrackDemo tdmo{topreresize}) {
+//System.printString("task preresize\n");
+
+  float[] Icur = tdmo.getImage();
+
+  int pnum = 16; //30;
+  int range = (tdmo.getRows()) / pnum;
+  int rows = tdmo.getRows();
+  int cols = tdmo.getCols();
+//create ImageX to calc Sobel_dX
+  for(int i = 0; i < pnum; i++) {
+    ImageX imageX = new ImageX(i,
+                               range,
+                               Icur, 
+                               rows, 
+                               cols){toprocess};
+  }
+  ImageXM imageXM = new ImageXM(pnum,
+                                rows,
+                                cols){tomergeX};
+// create ImageY to calc Sobel_dY
+  for(int i = 0; i < pnum; i++) {
+    ImageY imageY = new ImageY(i,
+                               range,
+                               Icur, 
+                               rows, 
+                               cols){toprocess};
+  }
+  ImageYM imageYM = new ImageYM(pnum,
+                                rows,
+                                cols){tomergeY};
+//create a Lambda to aggregate results from the ImageXs
+  Lambda lda = new Lambda(tdmo.WINSZ,
+                          tdmo.N_FEA,
+                          pnum,
+                          tdmo.getNumP()){tocalcGF};
+
+  taskexit(tdmo{!topreresize, toresize});
+}
+
+task resize(TrackDemo tdmo{toresize}) {
+  //System.printString("task resize\n");
+  
+  tdmo.resize();
+  
+  taskexit(tdmo{!toresize, tomergeIDX});
+}
+
+task processImageX(ImageX imx{toprocess}) {
+//System.printString("task processImageX\n");
+  
+  imx.calcSobel_dX();
+  //imx.printResult();
+  
+  taskexit(imx{!toprocess, tomergeX});
+}
+
+task processImageY(ImageY imy{toprocess}) {
+//System.printString("task processImageY\n");
+  
+  imy.calcSobel_dY();
+  //imy.printResult();
+  
+  taskexit(imy{!toprocess, tomergeY});
+}
+
+task mergeX(ImageXM imxm{tomergeX}, 
+            ImageX imx{tomergeX}) {
+//System.printString("task mergeX\n");
+
+  boolean isfinished = imxm.addCalcSobelResult(imx);
+
+  if(isfinished) {
+    imxm.calcSobel_dX();
+    taskexit(imxm{!tomergeX, tocalcGF}, 
+             imx{!tomergeX, finish});
+  } else {
+    taskexit(imx{!tomergeX, finish});
+  }
+}
+
+task mergeY(ImageYM imym{tomergeY}, 
+            ImageY imy{tomergeY}) {
+//System.printString("task mergeY\n");
+
+  boolean isfinished = imym.addCalcSobelResult(imy);
+
+  if(isfinished) {
+    imym.calcSobel_dY();
+    taskexit(imym{!tomergeY, tocalcGF}, 
+             imy{!tomergeY, finish});
+  } else {
+    taskexit(imy{!tomergeY, finish});
+  }
+}
+
+task calcGoodFeatureTask(Lambda lda{tocalcGF},
+                         ImageXM imxm{tocalcGF},
+                         ImageYM imym{tocalcGF}) {
+//System.printString("task calcGoodFeature\n");
+  
+  lda.calcGoodFeature(imxm, imym);
+  // validation
+  //lda.printImage();
+  lda.reshape();
+  // validation
+  //lda.printImage();
+  
+  taskexit(lda{!tocalcGF, tocalcInd},
+           imxm{!tocalcGF, finish},
+           imym{!tocalcGF, finish});
+} 
+
+task calcInd(Lambda lda{tocalcInd}) {
+//System.printString("task calcInd\n");
+  
+  int r = lda.getR();
+  float[] data = lda.getImage();
+  int rows = lda.getRows();
+  int cols = lda.getCols();
+  int pnum = lda.getNumP();
+  int range = rows / pnum;
+  for(int i = 0; i < pnum; i++) {
+    IDX idx = new IDX(lda.N_FEA,
+                      i,
+                      range,                 
+                      data,
+                      rows,
+                      cols,
+                      r){toprocess};
+  }
+                    
+  taskexit(lda{!tocalcInd, finish});
+}
+
+task processIDX(IDX idx{toprocess}) {
+//System.printString("task processIDX\n");
+  
+  idx.fSortIndices();
+  // validation
+  //idx.printInd();
+  
+  taskexit(idx{!toprocess, tomergeIDX});
+}
+
+task addIDX(TrackDemo tdmo{tomergeIDX}, 
+            IDX idx{tomergeIDX}) {
+//System.printString("task addIDX\n");
+
+  boolean isfinished = tdmo.addIDX(idx);
+  //validation
+  //idx.printInd();tdmo.print3f();
+
+  if(isfinished) {
+    //tdmo.print3f();
+    taskexit(tdmo{!tomergeIDX, tocalcF},
+             idx{!tomergeIDX, finish});
+  } else {
+    taskexit(idx{!tomergeIDX, finish});
+  }
+}
+
+task calcFeatures(TrackDemo tdmo{tocalcF}) {
+//System.printString("task calcFeatures\n");
+
+  tdmo.calcFeatures();
+
+  taskexit(tdmo{!tocalcF, tostartL});
+}
+
+task startTrackingLoop(TrackDemo tdmo{tostartL}) {
+//System.printString("task startTrackingLoop\n");
+
+  int pnum1 = 8; //15; // * 2;
+  float[] data = tdmo.getImage();
+  int rows = tdmo.getRows();
+  int cols = tdmo.getCols();
+  int range = rows / pnum1;
+  
+  for(int i = 0; i < pnum1; i++) {
+    IXL ixl = new IXL(i,
+                      range,
+                      data,
+                      rows,
+                      cols){toprocess};
+    IYL iyl = new IYL(i,
+                      range,
+                      data,
+                      rows,
+                      cols){toprocess};
+  }
+  IXLM ixlm1 = new IXLM(pnum1,
+                        data,
+                        rows,
+                        cols){tomergeIXL};
+  IYLM iylm1 = new IYLM(pnum1,
+                        data,
+                        rows,
+                        cols){tomergeIYL};
+           
+  data = tdmo.getImageR();
+  rows = tdmo.getRowsR();
+  cols = tdmo.getColsR(); 
+  range = rows / pnum1;
+  for(int i = 0; i < pnum1; i++) {
+    IXLR ixl = new IXLR(i,
+                        range,
+                        data,
+                        rows,
+                        cols){toprocess};
+    IYLR imy = new IYLR(i,
+                        range,
+                        data,
+                        rows,
+                        cols){toprocess};
+  }
+  IXLMR ixlm2 = new IXLMR(pnum1,
+                          data,
+                          rows,
+                          cols){tomergeIXLR};
+  IYLMR iylm2 = new IYLMR(pnum1,
+                          data,
+                          rows,
+                          cols){tomergeIYLR};
+                                 
+  int pnum2 = 32; //60; // * 2;
+  int[] input = tdmo.getInput(true);
+  range = (input[0]) / pnum2;
+  for(int i = 0; i < pnum2; i++) {
+    BlurPieceL bpl = new BlurPieceL(i,
+                                    range,
+                                    input){toblur};
+  }
+  tdmo.setBPLNum(pnum2);  
+  tdmo.startTrackingLoop();
+  
+  taskexit(tdmo{!tostartL, toaddBP2});
+}
+
+task blurL(BlurPieceL bpl{toblur}) {
+  //System.printString("task blurL\n");
+  
+  //bpl.printImage();
+  bpl.blur();
+  
+  taskexit(bpl{!toblur, toaddBP});
+}
+
+task addBPL(TrackDemo tdmo{toaddBP2},
+            BlurPieceL bpl{toaddBP}) {
+//System.printString("task addBPL\n");
+  
+  boolean isfinished = tdmo.addBPL(bpl);
+
+  if(isfinished) {
+    tdmo.postBlur();
+    taskexit(tdmo{!toaddBP2, toresize2},
+             bpl{!toaddBP, finish});
+  } else {
+    taskexit(bpl{!toaddBP, finish});
+  }
+}
+
+task resizeL(TrackDemo tdmo{toresize2}) {
+//System.printString("task resizeL\n");
+  
+  tdmo.resize();
+  
+  taskexit(tdmo{!toresize2, tocalcT});
+}
+
+task processIXL(IXL ixl{toprocess}) {
+//System.printString("task processIXL\n");
+  
+  ixl.calcSobel_dX();
+  
+  taskexit(ixl{!toprocess, tomergeIXL});
+}
+
+task processIYL(IYL iyl{toprocess}) {
+//System.printString("task processIYL\n");
+  
+  iyl.calcSobel_dY();
+  
+  taskexit(iyl{!toprocess, tomergeIYL});
+}
+
+task mergeIXL(IXLM ixlm{tomergeIXL}, 
+              IXL ixl{tomergeIXL}) {
+//System.printString("task mergeIXL\n");
+
+  boolean isfinished = ixlm.addCalcSobelResult(ixl);
+
+  if(isfinished) {
+    ixlm.calcSobel_dX();
+    taskexit(ixlm{!tomergeIXL, tocalcT}, 
+             ixl{!tomergeIXL, finish});
+  } else {
+    taskexit(ixl{!tomergeIXL, finish});
+  }
+}
+
+task mergeIYL(IYLM iylm{tomergeIYL}, 
+              IYL iyl{tomergeIYL}) {
+//System.printString("task mergeIYL\n");
+
+  boolean isfinished = iylm.addCalcSobelResult(iyl);
+
+  if(isfinished) {
+    iylm.calcSobel_dY();
+    taskexit(iylm{!tomergeIYL, tocalcT}, 
+             iyl{!tomergeIYL, finish});
+  } else {
+    taskexit(iyl{!tomergeIYL, finish});
+  }
+}
+
+task processIXLR(IXLR ixl{toprocess}) {
+//System.printString("task processIXLR\n");
+  
+  ixl.calcSobel_dX();
+  
+  taskexit(ixl{!toprocess, tomergeIXLR});
+}
+
+task processIYLR(IYLR iyl{toprocess}) {
+//System.printString("task processIYLR\n");
+  
+  iyl.calcSobel_dY();
+  
+  taskexit(iyl{!toprocess, tomergeIYLR});
+}
+
+task mergeIXLR(IXLMR ixlm{tomergeIXLR}, 
+               IXLR ixl{tomergeIXLR}) {
+//System.printString("task mergeIXLR\n");
+
+  boolean isfinished = ixlm.addCalcSobelResult(ixl);
+
+  if(isfinished) {
+    ixlm.calcSobel_dX();
+    taskexit(ixlm{!tomergeIXLR, tocalcT}, 
+             ixl{!tomergeIXLR, finish});
+  } else {
+    taskexit(ixl{!tomergeIXLR, finish});
+  }
+}
+
+task mergeIYLR(IYLMR iylm{tomergeIYLR}, 
+               IYLR iyl{tomergeIYLR}) {
+//System.printString("task mergeIYLR\n");
+
+  boolean isfinished = iylm.addCalcSobelResult(iyl);
+
+  if(isfinished) {
+    iylm.calcSobel_dY();
+    taskexit(iylm{!tomergeIYLR, tocalcT}, 
+             iyl{!tomergeIYLR, finish});
+  } else {
+    taskexit(iyl{!tomergeIYLR, finish});
+  }
+}
+
+task calcTrack(TrackDemo tdmo{tocalcT},
+               IXLM ixlm{tocalcT},
+               IYLM iylm{tocalcT},
+               IXLMR ixlmr{tocalcT},
+               IYLMR iylmr{tocalcT}) {
+//System.printString("task calcTrack()\n");
+
+  tdmo.calcTrack(ixlm, iylm, ixlmr, iylmr);
+
+  if(tdmo.isFinish()) {
+    //tdmo.printFeatures();
+    // finished
+    taskexit(tdmo{!tocalcT, finish},
+             ixlm{!tocalcT, finish},
+             iylm{!tocalcT, finish},
+             ixlmr{!tocalcT, finish},
+             iylmr{!tocalcT, finish});
+  } else {
+    taskexit(tdmo{!tocalcT, tostartL},
+             ixlm{!tocalcT, finish},
+             iylm{!tocalcT, finish},
+             ixlmr{!tocalcT, finish},
+             iylmr{!tocalcT, finish});
+  }
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/tracking/makefile b/Robust/src/Benchmarks/oooJava/tracking/makefile
new file mode 100644
index 00000000..93779f27
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/tracking/makefile
@@ -0,0 +1,32 @@
+PROGRAM=TrackingBench
+
+SOURCE_FILES=TrackingBench.java
+
+BUILDSCRIPT=../../../buildscript
+
+#USEOOO= -ooojava 24 2  -ooodebug  
+#BSFLAGS= -64bit -mainclass $(PROGRAM) -garbagestats #-joptimize -noloop -optimize
+USEOOO= -ooojava 8 2  -ooodebug 
+BSFLAGS= -64bit -nooptimize -mainclass $(PROGRAM) -debug -garbagestats 
+-joptimize
+DISJOINT= -disjoint -disjoint-k 1 -enable-assertions 
+
+default:
+	$(BUILDSCRIPT) -nojava $(USEOOO) $(BSFLAGS) $(DISJOINT) -o $(PROGRAM)p $(SOURCE_FILES) -builddir par
+
+single:
+	$(BUILDSCRIPT) $(BSFLAGS) -thread -o $(PROGRAM)s -builddir sing $(SOURCE_FILES) 
+
+ooo:
+	$(BUILDSCRIPT) $(USEOOO) $(BSFLAGS) $(DISJOINT) -o $(PROGRAM)p -builddir par $(SOURCE_FILES) 
+
+clean:
+	rm -f  $(PROGRAM)p.bin $(PROGRAM)s.bin
+	rm -fr par sing
+	rm -f  *~
+	rm -f  *.dot
+	rm -f  *.png
+	rm -f  *.txt
+	rm -f  aliases.txt
+	rm -f  mlpReport*txt
+	rm -f  results*txt