/* SUM-MAX MAPS FOR TEMPLATE MATCHING INFERENCE */
# include <stdio.h>
# include <stdlib.h>
# include "mex.h"        
# include "math.h"
# define PI 3.1415926
# define ROUND(x) (floor((x)+.5))
# define NEGMAX -1e10
int *int_vector(int n)
{
    int *v; 
    v = (int*) mxCalloc (n, sizeof(int));
    return v; 
}
/* Generating integer matrix */
int **int_matrix(int m, int n)
{
    int **mat; 
    int i; 
    mat = (int**) mxCalloc(m, sizeof(int*)); 
    for (i=0; i<m; i++)
        mat[i] = int_vector(n); 
    return mat; 
}
/* Free matrix space */
void free_matrix(void **mat, int m, int n)
{
        int i;
        for (i=0; i<m; i++)
              mxFree(mat[i]);
        mxFree(mat);
}
/* Compute pixel index in the vector that stores image */
int px(int x, int y, int lengthx, int lengthy)  /* the image is lengthx*lengthy */
{            
   return (x + (y-1)*lengthx - 1); 
 }
 /* variables */
int numOrient, locationShiftLimit, orientShiftLimit; /* key parameters */
int numResolution, numElement; /* number of resolutions and number of Gabors */   
double *allSizex, *allSizey;  /* sizes of images at multiple resolutions */
float **SUM1map, **MAX1map, **trackMap, **SUM2map, *MAX2score, **averageMap;
int halfFilterSize; /* filter size = 2*halfFilterSize + 1 */ 
double **allSymbol; /* symbols of Gabors */  
int numShift, **xShift, **yShift, **orientShifted; /* stored shifts in x and y, and the shifted orientations */      
int sizex, sizey, subsample, sizexSubsample, sizeySubsample; /* MAX1 maps are smaller than SUM1 maps by subsample */ 
int sizeTemplatex, sizeTemplatey, sizeTemplatexSubsample, sizeTemplateySubsample, halfTemplatexSubsample, halfTemplateySubsample, sizexEnlarge, sizeyEnlarge;
double *selectedOrient, *selectedx, *selectedy, *selectedlambda, *selectedLogZ; /* parameters of learned active basis */  
float **translatedTemplate; /* templates at the maximum likelihood location */    
double *allFx, *allFy; /* detected location over multiple resolutions */
double saturation; /* for sigmoid transformation */
/* store all the shifts or perturbations in local maximum pooling */
void StoreShift()  
{
    int orient, i, j, shift, ci, cj, si, sj, os;
    double alpha; 
    /* store all the possible shifts for all orientations */
    numShift = (locationShiftLimit*2+1)*(orientShiftLimit*2+1); 
    xShift = int_matrix(numOrient, numShift); 
    yShift = int_matrix(numOrient, numShift); 
    orientShifted = int_matrix(numOrient, numShift);
    /* order the shifts from small to large */
    for (orient=0; orient<numOrient; orient++)        
    {
        alpha = PI*orient/numOrient;
        ci = 0; 
        for (i=0; i<=locationShiftLimit; i++)
           for (si=0; si<=1; si++)
           {
             cj = 0;    
             for (j = 0; j<=orientShiftLimit; j++)
                 for (sj=0; sj<=1; sj++)
                  {
                    shift = ci*(2*orientShiftLimit+1) + cj; 
                    xShift[orient][shift] = ROUND(i*(si*2-1)*subsample*cos(alpha)); 
                    yShift[orient][shift] = ROUND(i*(si*2-1)*subsample*sin(alpha)); 
                    os = orient + j*(sj*2-1);
                    if (os<0)
                        os += numOrient; 
                    else if (os>=numOrient)
                        os -= numOrient; 
                    orientShifted[orient][shift] = os; 
                    
                    if (j>0) 
                        cj ++; 
                    else if (sj==1)
                        cj++; 
                 }
             if (i>0)
                 ci ++; 
             else if (si==1)
                 ci++;                     
             }
    }
}
/* plot the bar for Gabor at (mx, my, mo) */
void DrawElement(float *Template, int mo, int mx, int my, double w) 
{
  int x, y, here; 
  float a; 
          
  for (x=mx-halfFilterSize; x<=mx+halfFilterSize; x++)
     for (y=my-halfFilterSize; y<=my+halfFilterSize; y++)
        if ((x>=1)&&(x<=sizex)&&(y>=1)&&(y<=sizey))
        {
         a = allSymbol[mo][px(x-mx+halfFilterSize+1, y-my+halfFilterSize+1, 
                              2*halfFilterSize+1, 2*halfFilterSize+1)]*w; 
         here = px(x, y, sizex, sizey); 
         if (Template[here]<a)
             Template[here] = a;
        }
}
/* sigmoid transformation */
float Sigmoid(float r)
{
   return(saturation*(2./(1.+exp(-2.*r/saturation))-1.)); 
}
/* compute SUM2 maps for image img, the size of SUM2 is the same as that of MAX1 */
void ComputeSUM2map(int resolution)
{
   int t, x, y, here, x1, y1, besto, bestx, besty, x2, y2; 
   double bestlambda, bestLogZ;
   float averageHere; 
   
   for (x=1; x<=sizex; x++)
      for (y=1; y<=sizey; y++)
         {  
           here = px(x, y, sizex, sizey);            
           translatedTemplate[resolution][here] = 0.; 
         }  
   for (x=1; x<=sizexEnlarge; x++)
      for (y=1; y<=sizeyEnlarge; y++)
         {  
           here = px(x, y, sizexEnlarge, sizeyEnlarge);            
           SUM2map[resolution][here] = 0.; 
         }  

   t = 0; 
   do  
   {
     besto = ROUND(selectedOrient[t]); bestx = ROUND(selectedx[t]); besty = ROUND(selectedy[t]);  
     bestlambda = selectedlambda[t]; bestLogZ = selectedLogZ[t]; 
     for (x=-sizeTemplatexSubsample+1; x<=sizexSubsample; x++)
         for (y=-sizeTemplateySubsample+1; y<=sizeySubsample; y++)   
          {  
              x1 = x+bestx; y1 = y+besty; 
              if ((x1>=1)&&(x1<=sizexSubsample)&&(y1>=1)&&(y1<=sizeySubsample))
              {
                 x2 = (x+halfTemplatexSubsample)*subsample; y2 = (y+halfTemplateySubsample)*subsample; 
                 if ((x2>=1)&&(x2<=sizex)&&(y2>=1)&&(y2<=sizey))
                    averageHere = averageMap[resolution][px(x2, y2, sizex, sizey)];  
                 else
                     averageHere = 1.; 
                 SUM2map[resolution][px(x+sizeTemplatexSubsample, y+sizeTemplateySubsample, sizexEnlarge, sizeyEnlarge)] +=  
                   (bestlambda*Sigmoid(MAX1map[besto*numResolution+resolution][px(x1, y1, sizexSubsample, sizeySubsample)]/averageHere) - bestLogZ);  
              }
              else 
                 SUM2map[resolution][px(x+sizeTemplatexSubsample, y+sizeTemplateySubsample, sizexEnlarge, sizeyEnlarge)] -= bestLogZ; 
         }
     t++; 
     }
  while (t<numElement);   
}
/* compute the MAX2 score for each resolution */
void ComputeMAX2score(int resolution)
{
   int x, y, Fx, Fy, t, besto, bestx, besty, shift, i, here, Fbx, Fby;  
   float F, r, maxResponse; 

   F = NEGMAX; 
   for (x=-sizeTemplatexSubsample+1; x<=sizexSubsample; x++)
         for (y=-sizeTemplateySubsample+1; y<=sizeySubsample; y++) 
          {       
             r = SUM2map[resolution][px(x+sizeTemplatexSubsample, y+sizeTemplateySubsample, sizexEnlarge, sizeyEnlarge)]; 
             if (F<r) 
             {
                 F = r; Fx = x; Fy = y; 
             }
          }  
   MAX2score[resolution] = F; allFx[resolution] = Fx*subsample; allFy[resolution] = Fy*subsample; 
   /* plot the translated and deformed template */ 
   t = 0; 
   do  
     {
       besto = ROUND(selectedOrient[t]); bestx = ROUND(selectedx[t]); besty = ROUND(selectedy[t]);  
       i = besto*numResolution+resolution; 
       Fbx = Fx+bestx; Fby = Fy+besty; 
       if ((Fbx>=1)&&(Fbx<=sizexSubsample)&&(Fby>=1)&&(Fby<=sizeySubsample))
       {
         here = px(Fbx, Fby, sizexSubsample, sizeySubsample); 
         shift = ROUND(trackMap[i][here]);
         DrawElement(translatedTemplate[resolution], orientShifted[besto][shift], 
            (Fx+bestx)*subsample+xShift[besto][shift], (Fy+besty)*subsample+yShift[besto][shift], sqrt(Sigmoid(MAX1map[i][here]))); 
       }
     t++; 
     }
   while (t<numElement); 
} 
           
/* read in the input and output variables */
void mexFunction(int nlhs, mxArray *plhs[], 
                 int nrhs, const mxArray *prhs[])                
{
 int resolution, orient, c; 
 mxArray *f;  
 
 c = 0; 
 numResolution = 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++]));
 sizeTemplatex = ROUND(mxGetScalar(prhs[c++]));  
 sizeTemplatey = ROUND(mxGetScalar(prhs[c++])); 
 halfFilterSize = ROUND(mxGetScalar(prhs[c++]));    
 allSymbol = mxCalloc(numOrient, sizeof(double*));    
 for (orient=0; orient<numOrient; orient++)
     {  
       f = mxGetCell(prhs[c], orient); 
       allSymbol[orient] = mxGetPr(f);       
     }
 c++; 
 numElement = ROUND(mxGetScalar(prhs[c++])); 
 selectedOrient = mxGetPr(prhs[c++]);              
 selectedx = mxGetPr(prhs[c++]);         
 selectedy = mxGetPr(prhs[c++]);   
 selectedlambda = mxGetPr(prhs[c++]);  
 selectedLogZ = mxGetPr(prhs[c++]);  
 
 MAX1map = mxCalloc(numResolution*numOrient, sizeof(float*));   
 for (resolution=0; resolution<numResolution; resolution++)
     for (orient=0; orient<numOrient; orient++)
      {  
       f = mxGetCell(prhs[c], orient*numResolution+resolution); 
       MAX1map[orient*numResolution+resolution] = mxGetPr(f);         
      }
 c++;
 trackMap = mxCalloc(numResolution*numOrient, sizeof(float*));   
 for (resolution=0; resolution<numResolution; resolution++)
     for (orient=0; orient<numOrient; orient++)
      {  
       f = mxGetCell(prhs[c], orient*numResolution+resolution); 
       trackMap[orient*numResolution+resolution] = mxGetPr(f);         
      }
 c++;
 SUM2map = mxCalloc(numResolution, sizeof(float*)); 
 for (resolution=0; resolution<numResolution; resolution++)
   {
     f = mxGetCell(prhs[c], resolution); 
     SUM2map[resolution] = mxGetPr(f);  
  } 
 c++; 
 translatedTemplate = mxCalloc(numResolution, sizeof(float*)); 
 for (resolution=0; resolution<numResolution; resolution++)
   {
     f = mxGetCell(prhs[c], resolution); 
     translatedTemplate[resolution] = mxGetPr(f);  
  } 
 c++; 
 MAX2score = mxGetPr(prhs[c++]);
 allFx =  mxGetPr(prhs[c++]);
 allFy =  mxGetPr(prhs[c++]);
 
 averageMap = mxCalloc(numResolution, sizeof(float*));   
 for (resolution=0; resolution<numResolution; resolution++)
      {  
       f = mxGetCell(prhs[c], resolution);  
       averageMap[resolution] = mxGetPr(f);       
      }
 c++;
 saturation = mxGetScalar(prhs[c++]);
 
 StoreShift();  
 sizeTemplatexSubsample = floor((double)sizeTemplatex/subsample); 
 sizeTemplateySubsample = floor((double)sizeTemplatey/subsample); 
 halfTemplatexSubsample = floor((double)sizeTemplatex/2./subsample); 
 halfTemplateySubsample = floor((double)sizeTemplatey/2./subsample); 
 for (resolution=0; resolution<numResolution; resolution++)
 {
 sizex = ROUND(allSizex[resolution]); 
 sizey = ROUND(allSizey[resolution]); 
 sizexSubsample = floor((double)sizex/subsample); 
 sizeySubsample = floor((double)sizey/subsample); 
 sizexEnlarge = floor((double)(sizeTemplatex+sizex)/subsample); 
 sizeyEnlarge = floor((double)(sizeTemplatey+sizey)/subsample); 
 ComputeSUM2map(resolution);    
 ComputeMAX2score(resolution);  
 }
 free_matrix(xShift, numOrient, numShift); 
 free_matrix(yShift, numOrient, numShift); 
 free_matrix(orientShifted, numOrient, numShift);
}

     



 

                    