I2D* getDisparity(I2D* Ileft, I2D* Iright, int win_sz, int max_shift)
{
I2D* retDisp;
int nr, nc, k;
I2D *halfWin;
int half_win_sz, rows, cols;
F2D *retSAD, *minSAD, *SAD, *integralImg;
I2D* IrightPadded, *IleftPadded, *Iright_moved;
nr = Ileft->height;
nc = Ileft->width;
half_win_sz=win_sz/2;
minSAD = fSetArray(nr, nc, 255.0*255.0);
retDisp = iSetArray(nr, nc,max_shift);
halfWin = iSetArray(1,2,half_win_sz);
if(win_sz > 1)
{
IleftPadded = padarray2(Ileft, halfWin);
IrightPadded = padarray2(Iright, halfWin);
}
else
{
IleftPadded = Ileft;
IrightPadded = Iright;
}
rows = IleftPadded->height;
cols = IleftPadded->width;
SAD = fSetArray(rows, cols,255);
integralImg = fSetArray(rows, cols,0);
retSAD = fMallocHandle(rows-win_sz, cols-win_sz);
Iright_moved = iSetArray(rows, cols, 0);
for( k=0; k<max_shift; k++)
{
correlateSAD_2D(IleftPadded, IrightPadded, Iright_moved, win_sz, k, SAD, integralImg, retSAD);
findDisparity(retSAD, minSAD, retDisp, k, nr, nc);
}
fFreeHandle(retSAD);
fFreeHandle(minSAD);
fFreeHandle(SAD);
fFreeHandle(integralImg);
iFreeHandle(halfWin);
iFreeHandle(IrightPadded);
iFreeHandle(IleftPadded);
iFreeHandle(Iright_moved);
return retDisp;
}
F2D* readFile(unsigned char* fileName)
{
FILE* fp;
F2D *fill;
float temp;
int rows, cols;
int i, j;
fp = fopen((const char*)fileName, "r");
if(fp == NULL)
{
printf("Error in file %s\n", fileName);
return NULL;
}
fscanf(fp, "%d", &cols);
fscanf(fp, "%d", &rows);
fill = fSetArray(rows, cols, 0);
for(i=0; i<rows; i++)
{
for(j=0; j<cols; j++)
{
fscanf(fp, "%f", &(subsref(fill,i,j)) );
}
}
fclose(fp);
return fill;
}
F2D * convertI2DtoF2D(I2D * in)
{
F2D * out = fSetArray(in->height, in->width, 0);
int i, j;
for (i = 0; i < in->height; i++)
for (j = 0; j < in->width; j++)
subsref(out, i, j) = (float) subsref(in, i, j);
return out;
}
F2D* quatRot(F2D* vec, F2D* rQuat)
{
F2D *ret;
int nr, i, j, k, rows, cols;
F2D *tv, *vQuat, *temp, *temp1;
F2D *retVec;
nr = vec->height;
tv = fSetArray(nr, 1, 0);
vQuat = fHorzcat(tv, vec);
temp = quatMul(rQuat, vQuat);
temp1 = quatConj(rQuat);
retVec = quatMul(temp, temp1);
rows = retVec->height;
cols = retVec->width;
ret = fSetArray(rows, 3, 0);
for(i=0; i<rows; i++)
{
k = 0;
for(j=1; j<4; j++)
{
subsref(ret,i,k) = subsref(retVec,i,j);
k++;
}
}
fFreeHandle(tv);
fFreeHandle(vQuat);
fFreeHandle(temp);
fFreeHandle(temp1);
fFreeHandle(retVec);
return ret;
}
alphaRet* getAlphaFromTrainSet(int N, F2D* trn1, F2D* trn2, int iterations)
{
float tolerance, C, eps, *b;
F2D *a_result, *b_result;
int NumChanged, r, ExamineAll, cnt, d, dim, ret, iter, i;
F2D *X, *Y;
F2D *a, *e;
b = malloc(sizeof(float));
alphaRet* alpha;
alpha = (alphaRet*)malloc(sizeof(alphaRet));
tolerance = 0.001;
C = 0.05;
d = -1;
dim = 256;
eps = 0.001;
a_result = fSetArray(iterations, N, 0);
b_result = fSetArray(iterations, 1, 0);
ret = 0;
X = usps_read_partial( trn1, trn2, 0, 1, (N/iterations), iterations);
for(iter=0; iter<iterations; iter++)
{
Y = usps_read_partial( trn1, trn2, iter, 0, N/iterations, iterations);
a = fSetArray(N, 1, 0);
arrayref(b,0) = 0; /** check if ptr **/
e = fSetArray(N, 1, 0);
ExamineAll = 1;
cnt = 0;
NumChanged = 0;
while(NumChanged>0 || ExamineAll == 1)
{
cnt = cnt + 1;
NumChanged = 0;
if(ExamineAll == 1)
{
for(i=0; i<N; i++)
{
ret = examineExample(i, a, b, C, e, X, Y, tolerance, N, eps, dim);
NumChanged = NumChanged + ret;
}
}
else
{
for(i=0; i<N; i++)
{
if( asubsref(a,i) > 0 && asubsref(a,i) <C )
{
ret = examineExample(i, a, b, C, e, X, Y, tolerance, N, eps, dim);
NumChanged = NumChanged + ret;
}
}
}
if(ExamineAll == 1)
ExamineAll = 0;
else if(NumChanged == 0)
ExamineAll = 1;
}
for(r=0; r<N; r++)
subsref(a_result,iter,r) = asubsref(a,r); /** a_result has size iteration,N .. Check **/
asubsref(b_result,iter) = arrayref(b,0);
fFreeHandle(Y);
fFreeHandle(e);
fFreeHandle(a);
}
alpha->C = C;
alpha->d = d;
alpha->dim = dim;
alpha->eps = eps;
alpha->a_result = a_result;
alpha->b_result = b_result;
alpha->a = a;
alpha->b = arrayref(b,0);
alpha->X = X;
alpha->tolerance = tolerance;
alpha->ret;
free(b);
return alpha;
}
F2D* usps_read_partial(F2D* dcell1, F2D* dcell2, int idx, int opt, int dim, int iterations)
{
F2D *ret, *X, *Y;
F2D *ADD;
int i, j, k, m, n;
F2D *temp, *temp1;
if(opt == 1)
{
for(i=0; i<iterations; i++)
{
if(i==0)
{
X = fMallocHandle(dim, dcell1->width);
for(m=0; m<dim; m++)
{
for(n=0; n<dcell1->width; n++)
{
subsref(X,m,n) = subsref(dcell1,m,n);
}
}
}
else
{
temp = fDeepCopy(X);
fFreeHandle(X);
temp1 = fMallocHandle(dim, dcell2->width);
for(m=0; m<dim; m++)
{
for(n=0; n<dcell2->width; n++)
{
subsref(temp1,m,n) = subsref(dcell2,m,n);
}
}
X = ffVertcat(temp, temp1);
fFreeHandle(temp);
fFreeHandle(temp1);
}
}
ret = fDeepCopy(X);
fFreeHandle(X);
}
else
{
for(i=0; i<iterations; i++)
{
if(idx == -1)
ADD = fSetArray(dim, 1, i+1);
else
{
if( i!= idx)
ADD = fSetArray(dim, 1, -1);
else
ADD = fSetArray(dim, 1, 1);
}
if(i==0)
{
Y = fDeepCopy(ADD);
}
else
{
F2D* t = fDeepCopy(Y);
fFreeHandle(Y);
Y = ffVertcat(t, ADD);
fFreeHandle(t);
}
fFreeHandle(ADD);
}
ret = fDeepCopy(Y);
fFreeHandle(Y);
}
return ret;
}
F2D* harris(I2D* im)
{
F2D *img1;
F2D *g1, *g2, *g;
F2D *Ix, *Iy;
F2D *Ix2, *Iy2, *IxIy;
F2D *v, *R, *Rmax, *Rnm;
float eps;
F2D *sobel, *sob, *temp, *temp1;
I2D *win, *x, *y;
int i;
g1 = fSetArray(5,5,0);
g2 = fSetArray(3,3,0);
asubsref(g1,0) = 1;
asubsref(g1,1) = 4;
asubsref(g1,2) = 6;
asubsref(g1,3) = 4;
asubsref(g1,4) = 1;
asubsref(g1,5) = 4;
asubsref(g1,6) = 16;
asubsref(g1,7) = 24;
asubsref(g1,8) = 16;
asubsref(g1,9) = 4;
asubsref(g1,10) = 6;
asubsref(g1,11) = 24;
asubsref(g1,12) = 36;
asubsref(g1,13) = 24;
asubsref(g1,14) = 6;
asubsref(g1,15) = 4;
asubsref(g1,16) = 16;
asubsref(g1,17) = 24;
asubsref(g1,18) = 16;
asubsref(g1,19) = 4;
asubsref(g1,20) = 1;
asubsref(g1,21) = 4;
asubsref(g1,22) = 6;
asubsref(g1,23) = 4;
asubsref(g1,24) = 1;
asubsref(g2,0) = 1;
asubsref(g2,1) = 2;
asubsref(g2,2) = 1;
asubsref(g2,3) = 2;
asubsref(g2,4) = 4;
asubsref(g2,5) = 2;
asubsref(g2,6) = 1;
asubsref(g2,7) = 2;
asubsref(g2,8) = 1;
g = fDivide(g1, 256);
sob = fMallocHandle(1,3);
asubsref(sob,0) = -0.5;
asubsref(sob,1) = 0;
asubsref(sob,2) = 0.5;
{
F2D* imf;
imf = fiDeepCopy(im);
img1 = ffConv2(imf, g);
fFreeHandle(imf);
}
Ix = ffConv2(img1, sob);
fFreeHandle(sob);
sob = fMallocHandle(3,1);
asubsref(sob,0) = -0.5;
asubsref(sob,1) = 0;
asubsref(sob,2) = 0.5;
Iy = ffConv2(img1, sob);
fFreeHandle(g);
g = fDivide(g2, 16);
eps = 2.2204e-16;
sobel = fTimes(Ix, Ix);
Ix2 = ffConv2(sobel, g);
fFreeHandle(sobel);
sobel = fTimes(Iy, Iy);
Iy2 = ffConv2(sobel, g);
fFreeHandle(sobel);
sobel = fTimes(Ix, Iy);
IxIy = ffConv2(sobel, g);
fFreeHandle(sobel);
temp = fTimes(Ix2, Iy2);
temp1 = fTimes(IxIy, IxIy);
sobel = fMinus(temp, temp1);
fFreeHandle(temp);
temp = fPlus(Ix2, Iy2);
for(i=0; i<(temp->height*temp->width); i++)
asubsref(temp,i) += eps;
R = ffDivide(sobel, temp);
win = iSetArray(1,2,3);
Rmax = maxWindow(R, win);
Rnm = supress(R, Rmax);
v = fFind3(Rnm);
iFreeHandle(win);
fFreeHandle(Rmax);
fFreeHandle(Rnm);
fFreeHandle(R);
fFreeHandle(img1);
fFreeHandle(g1);
fFreeHandle(g2);
fFreeHandle(g);
fFreeHandle(Ix);
fFreeHandle(Iy);
fFreeHandle(Ix2);
fFreeHandle(Iy2);
fFreeHandle(IxIy);
fFreeHandle(sobel);
fFreeHandle(sob);
fFreeHandle(temp);
fFreeHandle(temp1);
// iFreeHandle(x);
// iFreeHandle(y);
return v;
}
F2D* imageResize(F2D* imageIn)
{
int m, k, rows, cols;
F2D *imageOut;
I2D *kernel;
float tempVal;
int kernelSize, startCol, endCol, halfKernel, startRow, endRow, i, j, kernelSum;
int outputRows, outputCols;
F2D *temp;
rows = imageIn->height;
cols = imageIn->width;
// level 1 is the base image.
outputRows = floor((rows+1)/2);
outputCols = floor((cols+1)/2);
temp = fSetArray(rows, outputCols, 0);
imageOut = fSetArray(outputRows, outputCols, 0);
kernel = iMallocHandle(1, 5);
asubsref(kernel,0) = 1;
asubsref(kernel,1) = 4;
asubsref(kernel,2) = 6;
asubsref(kernel,3) = 4;
asubsref(kernel,4) = 1;
kernelSize = 5;
kernelSum = 16;
startCol = 2;
endCol = cols - 2;
halfKernel = 2;
startRow = 2;
endRow = rows - 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 += subsref(imageIn,i,j+k) * asubsref(kernel,k+halfKernel);
}
subsref(temp,i,m) = 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 += subsref(temp,(i+k),j) * asubsref(kernel,k+halfKernel);
}
subsref(imageOut,m,j) = (tempVal/kernelSum);
}
m = m+1;
}
fFreeHandle(temp);
iFreeHandle(kernel);
return imageOut;
}
F2D* calcSobel_dX(F2D* imageIn)
{
int rows, cols;
F2D *kernel_1, *kernel_2;
APPROX float temp;
int kernelSize, startCol, endCol, halfKernel, startRow, endRow, i, j, kernelSum;
int k, kernelSum_1, kernelSum_2;
F2D *imageOut, *tempOut;
rows = imageIn->height;
cols = imageIn->width;
imageOut = fSetArray(rows, cols, 0);
tempOut = fSetArray(rows, cols, 0);
kernel_1 = fMallocHandle(1, 3);
kernel_2 = fMallocHandle(1, 3);
asubsref(kernel_1,0) = 1;
asubsref(kernel_1,1) = 2;
asubsref(kernel_1,2) = 1;
kernelSize = 3;
kernelSum_1 = 4;
asubsref(kernel_2,0) = 1;
asubsref(kernel_2,1) = 0;
asubsref(kernel_2,2) = -1;
kernelSum_2 = 2;
startCol = 1;
endCol = cols - 1;
halfKernel = 1;
startRow = 1;
endRow = rows - 1;
for(i=startRow; i<endRow; i++)
{
for(j=startCol; j<endCol; j++)
{
temp = 0;
for(k=-halfKernel; k<=halfKernel; k++)
{
temp += subsref(imageIn,i,j+k) * asubsref(kernel_2,k+halfKernel);
}
subsref(tempOut,i,j) = temp/kernelSum_2;
}
}
for(i=startRow; i<endRow; i++)
{
for(j=startCol; j<endCol; j++)
{
temp = 0;
for(k=-halfKernel; k<=halfKernel; k++)
{
temp += subsref(tempOut,(i+k),j) * asubsref(kernel_1,k+halfKernel);
}
subsref(imageOut,i,j) = temp/(float)kernelSum_1;
}
}
fFreeHandle(tempOut);
fFreeHandle(kernel_1);
fFreeHandle(kernel_2);
return imageOut;
}
int main(int argc, char* argv[])
{
int iter, N, Ntst, i, j, k, n;
F2D* trn1, *tst1, *trn2, *tst2, *Yoffset;
alphaRet* alpha;
F2D *a_result, *result;
F2D *s;
F2D *b_result;
F2D *Xtst, *Ytst;
unsigned int* start, *stop, *elapsed;
char im1[256];
int dim = 256;
N = 100;
Ntst = 100;
iter = 10;
#ifdef test
N = 4;
Ntst = 4;
iter = 2;
#endif
#ifdef sim_fast
N = 20;
Ntst = 20;
iter = 2;
#endif
#ifdef sim
N = 16;
Ntst = 16;
iter = 8;
#endif
#ifdef sqcif
N = 60;
Ntst = 60;
iter = 6;
#endif
#ifdef qcif
N = 72;
Ntst = 72;
iter = 8;
#endif
#ifdef vga
N = 450;
Ntst = 450;
iter = 15;
#endif
#ifdef wuxga
N = 1000;
Ntst = 1000;
iter = 20;
#endif
printf("Input size\t\t- (%dx%dx%d)\n", N, Ntst, iter);
if(argc < 2)
{
printf("We need input image path\n");
return -1;
}
sprintf(im1, "%s/d16trn_1.txt", argv[1]);
trn1 = readFile(im1);
sprintf(im1, "%s/d16trn_2.txt", argv[1]);
trn2 = readFile(im1);
sprintf(im1, "%s/d16tst_1.txt", argv[1]);
tst1 = readFile(im1);
sprintf(im1, "%s/d16tst_2.txt", argv[1]);
tst2 = readFile(im1);
/** Start timing **/
start = photonStartTiming();
alpha = getAlphaFromTrainSet(N, trn1, trn2, iter);
a_result = alpha->a_result;
b_result = alpha->b_result;
Yoffset = fSetArray(iter, N, 0);
Xtst = usps_read_partial(tst1, tst2, -1, 1, Ntst/iter, iter);
Ytst = usps_read_partial(tst1, tst2, -1, 0, Ntst/iter, iter);
for(i=0; i<iter; i++)
{
F2D *temp;
temp = usps_read_partial(trn1, trn2, i, 0, N/iter, iter);
for(j=0; j<N; j++)
subsref(Yoffset,i,j) = asubsref(temp,j);
fFreeHandle(temp);
}
result = fSetArray(Ntst,1,0);
for( n=0; n<Ntst; n++)
{
float maxs=0;
s=fSetArray(iter,1,0);
for( i=0; i<iter; i++)
{
for (j=0; j<N; j++)
{
if (subsref(a_result,i,j) > 0)
{
F2D *Xtemp, *XtstTemp, *X;
X = alpha->X;
Xtemp = fDeepCopyRange(X,j,1,0,X->width);
XtstTemp = fDeepCopyRange(Xtst, n,1,0,Xtst->width);
asubsref(s,i) = asubsref(s,i) + subsref(a_result,i,j) * subsref(Yoffset,i,j) * polynomial(3,Xtemp,XtstTemp, dim);
fFreeHandle(Xtemp);
fFreeHandle(XtstTemp);
}
}
asubsref(s,i) = asubsref(s,i) - asubsref(b_result,i);
if( asubsref(s,i) > maxs)
maxs = asubsref(s,i);
}
fFreeHandle(s);
asubsref(result,n) = maxs;
}
/** Timing utils */
stop = photonEndTiming();
#ifdef CHECK
/** Self checking - use expected.txt from data directory **/
{
int ret=0;
float tol = 0.5;
#ifdef GENERATE_OUTPUT
fWriteMatrix(result, argv[1]);
#endif
ret = fSelfCheck(result, argv[1], tol);
if (ret == -1)
printf("Error in SVM\n");
}
/** Self checking done **/
#endif
fFreeHandle(trn1);
fFreeHandle(tst1);
fFreeHandle(trn2);
fFreeHandle(tst2);
fFreeHandle(Yoffset);
fFreeHandle(result);
fFreeHandle(alpha->a_result);
fFreeHandle(alpha->b_result);
fFreeHandle(alpha->X);
free(alpha);
fFreeHandle(Xtst);
fFreeHandle(Ytst);
elapsed = photonReportTiming(start, stop);
photonPrintTiming(elapsed);
free(start);
free(stop);
free(elapsed);
return 0;
}
F2D* calcSobel_dY(F2D* imageIn)
{
int rows, cols;
I2D *kernel_1, *kernel_2;
float temp;
int kernelSize, startCol, endCol, halfKernel, startRow, endRow, i, j, kernelSum;
int k, kernelSum_2, outputRows, outputCols;
F2D *imageOut, *tempOut;
float kernelSum_1;
rows = imageIn->height;
cols = imageIn->width;
// level 1 is the base image.
outputRows = rows;
outputCols = cols;
imageOut = fSetArray(outputRows, outputCols, 0);
tempOut = fSetArray(outputRows, outputCols, 0);
kernel_1 = iMallocHandle(1, 3);
kernel_2 = iMallocHandle(1, 3);
asubsref(kernel_1,0) = 1;
asubsref(kernel_1,1) = 0;
asubsref(kernel_1,2) = -1;
kernelSize = 3;
kernelSum_1 = 2.0;
asubsref(kernel_2,0) = 1;
asubsref(kernel_2,1) = 2;
asubsref(kernel_2,2) = 1;
kernelSum_2 = 4;
startCol = 1;
endCol = cols - 1;
halfKernel = 1;
startRow = 1;
endRow = rows - 1;
for(i=startRow; i<endRow; i++)
{
for(j=startCol; j<endCol; j++)
{
temp = 0;
for(k=-halfKernel; k<=halfKernel; k++)
{
temp += subsref(imageIn,(i+k),j) * asubsref(kernel_1,k+halfKernel);
}
subsref(tempOut,i,j) = temp/kernelSum_1;
}
}
for(i=startRow; i<endRow; i++)
{
for(j=startCol; j<endCol; j++)
{
temp = 0;
for(k=-halfKernel; k<=halfKernel; k++)
{
temp += subsref(tempOut,i,j+k) * asubsref(kernel_2,k+halfKernel);
}
subsref(imageOut,i,j) = temp/(float)kernelSum_2;
}
}
fFreeHandle(tempOut);
iFreeHandle(kernel_1);
iFreeHandle(kernel_2);
return imageOut;
}
