From 509363ab4ecdd344f28f5972f308362403afcca2 Mon Sep 17 00:00:00 2001 From: yeom Date: Sun, 1 Aug 2010 03:48:36 +0000 Subject: [PATCH] add tracking benchmark --- Robust/src/Benchmarks/oooJava/tracking/1.bmp | Bin 0 -> 36918 bytes .../oooJava/tracking/BlurPiece.java | 138 ++ .../oooJava/tracking/BlurPieceL.java | 138 ++ .../src/Benchmarks/oooJava/tracking/IDX.java | 125 ++ .../src/Benchmarks/oooJava/tracking/IXL.java | 126 ++ .../src/Benchmarks/oooJava/tracking/IXLM.java | 143 ++ .../Benchmarks/oooJava/tracking/IXLMR.java | 143 ++ .../src/Benchmarks/oooJava/tracking/IXLR.java | 130 ++ .../src/Benchmarks/oooJava/tracking/IYL.java | 126 ++ .../src/Benchmarks/oooJava/tracking/IYLM.java | 145 ++ .../Benchmarks/oooJava/tracking/IYLMR.java | 146 ++ .../src/Benchmarks/oooJava/tracking/IYLR.java | 126 ++ .../oooJava/tracking/ImageReader.java | 170 +++ .../Benchmarks/oooJava/tracking/ImageX.java | 129 ++ .../Benchmarks/oooJava/tracking/ImageXM.java | 115 ++ .../Benchmarks/oooJava/tracking/ImageY.java | 125 ++ .../Benchmarks/oooJava/tracking/ImageYM.java | 117 ++ .../Benchmarks/oooJava/tracking/Lambda.java | 201 +++ .../oooJava/tracking/TrackDemo.java | 1315 +++++++++++++++++ .../oooJava/tracking/TrackingBench.java | 8 + .../oooJava/tracking/TrackingBench_task.java | 440 ++++++ .../src/Benchmarks/oooJava/tracking/makefile | 32 + 22 files changed, 4138 insertions(+) create mode 100644 Robust/src/Benchmarks/oooJava/tracking/1.bmp create mode 100644 Robust/src/Benchmarks/oooJava/tracking/BlurPiece.java create mode 100644 Robust/src/Benchmarks/oooJava/tracking/BlurPieceL.java create mode 100644 Robust/src/Benchmarks/oooJava/tracking/IDX.java create mode 100644 Robust/src/Benchmarks/oooJava/tracking/IXL.java create mode 100644 Robust/src/Benchmarks/oooJava/tracking/IXLM.java create mode 100644 Robust/src/Benchmarks/oooJava/tracking/IXLMR.java create mode 100644 Robust/src/Benchmarks/oooJava/tracking/IXLR.java create mode 100644 Robust/src/Benchmarks/oooJava/tracking/IYL.java create mode 100644 Robust/src/Benchmarks/oooJava/tracking/IYLM.java create mode 100644 Robust/src/Benchmarks/oooJava/tracking/IYLMR.java create mode 100644 Robust/src/Benchmarks/oooJava/tracking/IYLR.java create mode 100644 Robust/src/Benchmarks/oooJava/tracking/ImageReader.java create mode 100644 Robust/src/Benchmarks/oooJava/tracking/ImageX.java create mode 100644 Robust/src/Benchmarks/oooJava/tracking/ImageXM.java create mode 100644 Robust/src/Benchmarks/oooJava/tracking/ImageY.java create mode 100644 Robust/src/Benchmarks/oooJava/tracking/ImageYM.java create mode 100644 Robust/src/Benchmarks/oooJava/tracking/Lambda.java create mode 100644 Robust/src/Benchmarks/oooJava/tracking/TrackDemo.java create mode 100644 Robust/src/Benchmarks/oooJava/tracking/TrackingBench.java create mode 100644 Robust/src/Benchmarks/oooJava/tracking/TrackingBench_task.java create mode 100644 Robust/src/Benchmarks/oooJava/tracking/makefile diff --git a/Robust/src/Benchmarks/oooJava/tracking/1.bmp b/Robust/src/Benchmarks/oooJava/tracking/1.bmp new file mode 100644 index 0000000000000000000000000000000000000000..06a8c3d93a7664f1b63d9e6c98eb349f05074006 GIT binary patch literal 36918 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 literal 0 HcmV?d00001 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)= rows - 2)) { + return; + } + startRow = (2>this.m_rows_rs)?2:(this.m_rows_rs); //(kernelSize)/2; + endRow = ((rows-2) 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 rows - 1)) { + return; + } + startRow = (1>this.m_rows_rs)?1:(this.m_rows_rs); //(kernelSize)/2; + endRow = ((rows-1) rows - 1)) { + return; + } + startRow = (1>this.m_rows_rs)?1:(this.m_rows_rs); //(kernelSize)/2; + endRow = ((rows-1) rows - 1)) { + return; + } + startRow = (1>this.m_rows_rs)?1:(this.m_rows_rs); //(kernelSize)/2; + endRow = ((rows-1) 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) rows - 1)) { + return; + } + startRow = (1>this.m_rows_rs)?1:(this.m_rows_rs); //(kernelSize)/2; + endRow = ((rows-1) 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= 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