void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
int img, orient, c;
mxArray *f;
c = 0;
numImage = ROUND(mxGetScalar(prhs[c++]));
allSizex = mxGetPr(prhs[c++]);
allSizey = mxGetPr(prhs[c++]);
numOrient = ROUND(mxGetScalar(prhs[c++]));
locationShiftLimit = ROUND(mxGetScalar(prhs[c++]));
orientShiftLimit = ROUND(mxGetScalar(prhs[c++]));
subsample = ROUND(mxGetScalar(prhs[c++]));
SUM1map = mxCalloc(numImage*numOrient, sizeof(float*));
for (img=0; img<numImage; img++)
for (orient=0; orient<numOrient; orient++)
{
f = mxGetCell(prhs[c], orient*numImage+img);
SUM1map[orient*numImage+img] = mxGetPr(f);
}
c++;
MAX1map = mxCalloc(numImage*numOrient, sizeof(float*));
for (img=0; img<numImage; img++)
{
for (orient=0; orient<numOrient; orient++)
{
f = mxGetCell(prhs[c], orient*numImage+img);
MAX1map[orient*numImage+img] = mxGetPr(f);
}
}
c++;
StoreShift();
for (img=0; img<numImage; img++)
{
sizex = ROUND(allSizex[img]);
sizey = ROUND(allSizey[img]);
sizexSubsample = floor((double)sizex/subsample);
sizeySubsample = floor((double)sizey/subsample);
ComputeMAX1map(img);
}
free_matrix(xShift, numOrient, numShift);
free_matrix(yShift, numOrient, numShift);
free_matrix(orientShifted, numOrient, numShift);
}
/* entry point */
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
int ind, i, x, y, o, dataDim, j, bytes_to_copy, nGaborFilter;
const mxArray *f;
const mxArray *pAS1Map;
mxArray *outPA;
mwSize ndim;
const mwSize* dims;
mwSize dimsOutput[2];
void* start_of_pr;
mxClassID datatype;
/*
* input variable 0: nGaborOri
*/
nGaborOri = (int)mxGetScalar(prhs[0]);
/*
* input variable 1: S1 maps
*/
pAS1Map = prhs[1];
dims = mxGetDimensions(pAS1Map);
nGaborFilter = dims[0] * dims[1];
nGaborScale = nGaborFilter / nGaborOri;
S1Map = (const float**)mxCalloc( nGaborFilter, sizeof(*S1Map) ); /* SUM1 maps */
for (i=0; i<nGaborFilter; ++i)
{
f = mxGetCell(pAS1Map, i);
datatype = mxGetClassID(f);
if (datatype != mxSINGLE_CLASS)
mexErrMsgTxt("warning !! single precision required.");
S1Map[i] = (const float*)mxGetPr(f); /* get the pointer to cell content */
height = mxGetM(f); /* overwriting is ok, since it is constant */
width = mxGetN(f);
}
/*
* input variable 2: location shift radius
*/
locationPerturb = (int)mxGetScalar(prhs[2]);
/*
* input variable 3: orientation shift radius
*/
orientationPerturb = (int)mxGetScalar(prhs[3]);
/*
* input variable 4: sub sample step length
*/
subsample = (int)mxGetScalar(prhs[4]);
StoreShift();
Compute();
/* =============================================
* Handle output variables.
* =============================================
*/
/*
* output variable 0: M1 map
*/
dimsOutput[0] = 1; dimsOutput[1] = nGaborScale * nGaborOri;
plhs[0] = mxCreateCellArray( 2, dimsOutput );
dimsOutput[0] = sizexSubsample; dimsOutput[1] = sizeySubsample;
for( i = 0; i < nGaborOri * nGaborScale; ++i )
{
outPA = mxCreateNumericArray( 2, dimsOutput, mxSINGLE_CLASS, mxREAL );
/* populate the real part of the created array */
start_of_pr = (float*)mxGetData(outPA);
bytes_to_copy = dimsOutput[0] * dimsOutput[1] * mxGetElementSize(outPA);
memcpy( start_of_pr, M1Map[i], bytes_to_copy );
mxSetCell( plhs[0], i, outPA );
}
/*
* output variable 1: M1 trace
*/
dimsOutput[0] = 1; dimsOutput[1] = nGaborScale * nGaborOri;
plhs[1] = mxCreateCellArray( 2, dimsOutput );
dimsOutput[0] = sizexSubsample; dimsOutput[1] = sizeySubsample;
for( i = 0; i < nGaborOri * nGaborScale; ++i )
{
outPA = mxCreateNumericArray( 2, dimsOutput, mxINT32_CLASS, mxREAL );
/* populate the real part of the created array */
start_of_pr = (int*)mxGetData(outPA);
bytes_to_copy = dimsOutput[0] * dimsOutput[1] * mxGetElementSize(outPA);
memcpy( start_of_pr, M1Trace[i], bytes_to_copy );
mxSetCell( plhs[1], i, outPA );
}
/*
* output variable 2: stored Gabor shifts : row shifts
*/
dimsOutput[0] = nGaborScale * nGaborOri; dimsOutput[1] = 1;
plhs[2] = mxCreateCellArray( 2, dimsOutput );
for( i = 0; i < nGaborScale*nGaborOri; ++i )
{
dimsOutput[0] = numShift; dimsOutput[1] = 1;
outPA = mxCreateNumericArray( 2, dimsOutput, mxINT32_CLASS, mxREAL );
start_of_pr = (int*)mxGetData(outPA);
bytes_to_copy = dimsOutput[0] * dimsOutput[1] * mxGetElementSize(outPA);
memcpy( start_of_pr, rowShift[i], bytes_to_copy );
mxSetCell( plhs[2], i, outPA );
}
/*
* output variable 3: stored Gabor shifts : col shifts
*/
dimsOutput[0] = nGaborScale * nGaborOri; dimsOutput[1] = 1;
plhs[3] = mxCreateCellArray( 2, dimsOutput );
for( i = 0; i < nGaborScale*nGaborOri; ++i )
{
dimsOutput[0] = numShift; dimsOutput[1] = 1;
outPA = mxCreateNumericArray( 2, dimsOutput, mxINT32_CLASS, mxREAL );
start_of_pr = (int*)mxGetData(outPA);
bytes_to_copy = dimsOutput[0] * dimsOutput[1] * mxGetElementSize(outPA);
memcpy( start_of_pr, colShift[i], bytes_to_copy );
mxSetCell( plhs[3], i, outPA );
}
/*
* output variable 4: stored Gabor shifts : orientation shifts
*/
dimsOutput[0] = nGaborScale * nGaborOri; dimsOutput[1] = 1;
plhs[4] = mxCreateCellArray( 2, dimsOutput );
for( i = 0; i < nGaborScale*nGaborOri; ++i )
{
dimsOutput[0] = numShift; dimsOutput[1] = 1;
outPA = mxCreateNumericArray( 2, dimsOutput, mxINT32_CLASS, mxREAL );
start_of_pr = (int*)mxGetData(outPA);
bytes_to_copy = dimsOutput[0] * dimsOutput[1] * mxGetElementSize(outPA);
memcpy( start_of_pr, orientShift[i], bytes_to_copy );
mxSetCell( plhs[4], i, outPA );
}
}
/* read in input variables and run the algorithm */
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
int orient, img, i, j, c, x, y;
mxArray *f;
c = 0;
/* about active basis */
numOrient = ROUND(mxGetScalar(prhs[c++]));
locationShiftLimit = ROUND(mxGetScalar(prhs[c++]));
orientShiftLimit = ROUND(mxGetScalar(prhs[c++]));
subsample = ROUND(mxGetScalar(prhs[c++]));
numElement = ROUND(mxGetScalar(prhs[c++]));
/* about input images */
numImage = ROUND(mxGetScalar(prhs[c++]));
sizex = ROUND(mxGetScalar(prhs[c++]));
sizey = ROUND(mxGetScalar(prhs[c++]));
SUM1map = mxCalloc(numImage*numOrient, sizeof(float*));
for (img=0; img<numImage; img++)
for (orient=0; orient<numOrient; orient++)
{
i = orient*numImage+img;
f = mxGetCell(prhs[c], i);
SUM1map[i] = mxGetPr(f);
}
c++;
/* about Gabor filters */
halfFilterSize = ROUND(mxGetScalar(prhs[c++]));
Correlation = mxCalloc(numOrient*numOrient, sizeof(double*));
for (orient=0; orient<numOrient; orient++)
{
for (j=0; j<numOrient; j++)
{
f = mxGetCell(prhs[c], j*numOrient+orient);
Correlation[j*numOrient+orient] = mxGetPr(f);
}
}
c++;
allSymbol = mxCalloc(numOrient, sizeof(double*));
for (orient=0; orient<numOrient; orient++)
{
f = mxGetCell(prhs[c], orient);
allSymbol[orient] = mxGetPr(f);
}
c++;
/* about exponential model */
numStoredPoint = ROUND(mxGetScalar(prhs[c++]));
storedlambda = mxGetPr(prhs[c++]);
storedExpectation = mxGetPr(prhs[c++]);
storedLogZ = mxGetPr(prhs[c++]);
/* learned parameters of active basis */
selectedOrient = mxGetPr(prhs[c++]);
selectedx = mxGetPr(prhs[c++]);
selectedy = mxGetPr(prhs[c++]);
selectedlambda = mxGetPr(prhs[c++]);
selectedLogZ = mxGetPr(prhs[c++]);
/* templates of images */
commonTemplate = mxGetPr(prhs[c++]);
deformedTemplate = mxCalloc(numImage, sizeof(float*));
for (img=0; img<numImage; img++)
{
f = mxGetCell(prhs[c], img);
deformedTemplate[img] = mxGetPr(f);
}
c++;
for (x=1; x<=sizex; x++)
for (y=1; y<=sizey; y++)
commonTemplate[px(x, y, sizex, sizey)] = 0.;
for (img=0; img<numImage; img++)
{
for (x=1; x<=sizex; x++)
for (y=1; y<=sizey; y++)
deformedTemplate[img][px(x, y, sizex, sizey)] = 0.;
}
/* MAX1 maps are smaller than SUM1 maps */
sizexSubsample = floor((double)sizex/subsample);
sizeySubsample = floor((double)sizey/subsample);
/* run the shared sketch algorithm */
StoreShift();
InitializeMAX1map();
PursueElement();
/* free matrices to avoid memory leak */
free_matrix(pooledMax1map, numOrient, sizexSubsample*sizeySubsample);
free_matrix(MAX1map, numImage*numOrient, sizexSubsample*sizeySubsample);
free_matrix(trackMap, numImage*numOrient, sizexSubsample*sizeySubsample);
free_matrix(xShift, numOrient, numShift);
free_matrix(yShift, numOrient, numShift);
free_matrix(orientShifted, numOrient, numShift);
}
