#define NFIELDS 20

regrid ( ldata, nl, high_res, nh, alat, alon, grid, pop, nlat, nlon, minlon,
         maxlon, minlat, maxlat, total, count, intcnt, amin, amax )
 
int     nl ;
int     high_res ;
int     nh ;
float   ldata[] ;
float   alat ;
float   alon ;
float **grid[NFIELDS] ;
short **pop[NFIELDS];
int     nlat ;
int     nlon ;
float   maxlat ;
float   minlat ;
float   maxlon ;
float   minlon ;
int     total[] ;
int     count[] ;
int     intcnt[] ;
float   amin[] ;
float   amax[] ;

/*******************/
/* local variables */
/*******************/
{
   float xlon,ylat,weight;
   int xindex,yindex,stype,istart,iend;
   int i,j,k,l,m,n;

/*************************************************************/
/* bin the data into the grid, weighting the data points in  */
/* each bin equally.                                         */
/*************************************************************/
   ylat = (maxlat - minlat)/(float)nlat;
   yindex = (int)((alat - minlat)/ylat);
   if (minlon < 0.0 && alon > 180.0) alon = alon - 360.0;
   if (minlon >= 0.0 && alon < 0.0) alon = alon + 360.0;
   if (maxlon > minlon) {
     xlon = (maxlon - minlon)/(float)nlon;
     xindex = (int)((alon - minlon)/xlon);
   }
   else {
     xlon = (360.0 + maxlon - minlon)/(float)nlon;
     if (alon < 0.0) alon += 360.0;
     xindex = (int)((alon - minlon)/xlon);
   }
   if ((xindex >= 0) && (xindex <= nlon-1) && 
       (yindex >= 0) && (yindex <= nlat-1)) {
     if (high_res == 1) {
       istart = nl;
       iend = nl+nh;
     }
     else {
       istart = 0;
       iend = nl;
     }

     /** Loop through all low- or high-resolution fields **/
 
     for (j=istart; j<iend; j++) 
       {
       if (ldata[j] == -5.0 || ldata[j] == -4.0 || ldata[j] == -3.0)
         {
         if (grid[j][yindex][xindex] == -1.0)
           grid[j][yindex][xindex]=ldata[j];
         }
       else if (ldata[j] >= 0.0) 
         {
         if (ldata[j] > amax[j]) amax[j] = ldata[j];
         if ((ldata[j] < amin[j]) && (ldata[j] >= 0.0)) amin[j] = ldata[j];
         if (grid[j][yindex][xindex] < 0.0) 
           {
           pop[j][yindex][xindex] = 1;
           grid[j][yindex][xindex] = ldata[j];
           count[j] = count[j] + 1;
           }
         else 
           {
           pop[j][yindex][xindex] = pop[j][yindex][xindex] + 1;
           weight = (float)pop[j][yindex][xindex];
           grid[j][yindex][xindex] = grid[j][yindex][xindex]*
               ((weight-1.0)/weight) + ldata[j]/weight;
           }
         }
       total[j] = total[j] + 1;
     }
   }
}


interp(grid,nlat,nlon,nband,total,count,intcnt)

int nlat,nlon,nband;
float **grid[NFIELDS];
int count[],total[],intcnt[];
{
   int i,j,k,l,m,n;
   float gp[8];
   int ncon,num,nback;
/*******************************************************/
/* interpolate the grid to get rid of individual spots */
/*******************************************************/
   for (i=0; i<nband; i++) {
     for (m=1; m<nlat-1; m++) {
       for (n=1; n<nlon-1; n++) {
         num = 0; ncon = 0; nback = 0;
         if (grid[i][m][n] == -1.0) {
           gp[0] = grid[i][m-1][n];
           gp[1] = grid[i][m+1][n];
           gp[2] = grid[i][m][n+1];
           gp[3] = grid[i][m][n-1];
           gp[4] = grid[i][m-1][n+1];
           gp[5] = grid[i][m+1][n-1];
           gp[6] = grid[i][m+1][n+1];
           gp[7] = grid[i][m-1][n-1];
           for (k=0; k<=7; k++) {
             if (gp[k] == -5.0 || gp[k] == -4.0 || gp[k] == -3.0) ncon = ncon + 1;
             if (gp[k] == -1.0) nback = nback + 1;
             if (gp[k] >= 0.0) num = num + 1;
           }
           if (num >= 5) {
             grid[i][m][n] = 0.0;
             for (k=0; k<=7; k++) {
               if (gp[k] >= 0.0) grid[i][m][n] = grid[i][m][n] + gp[k];
             }
             grid[i][m][n] = grid[i][m][n] / (float)num;
             intcnt[i] = intcnt[i] + 1;
           }
           else if ((ncon >= 1) && (nback < 4)) {
             grid[i][m][n] = -5.0;
             intcnt[i] = intcnt[i] + 1;
           }
           else if (ncon >= 5) {
             grid[i][m][n] = -5.0;
             intcnt[i] = intcnt[i] + 1;
           }
         }
       }
     }
   }
   return(1);
}