view toolboxes/FullBNT-1.0.7/KPMtools/rectintSparseLoopC.c @ 0:e9a9cd732c1e tip

first hg version after svn

/* This is based on
http://www.mathworks.com/access/helpdesk/help/techdoc/matlab_external/ch04cr12.shtml

See rectintSparse.m for the matlab version of this code.

*/

#include <math.h> /* Needed for the ceil() prototype. */
#include "mex.h"
#include <stdio.h>

/* If you are using a compiler that equates NaN to be zero, you 
 * must compile this example using the flag  -DNAN_EQUALS_ZERO.
 * For example:
 *
 *     mex -DNAN_EQUALS_ZERO fulltosparse.c
 *
 * This will correctly define the IsNonZero macro for your C
 * compiler.
 */

#if defined(NAN_EQUALS_ZERO)
#define IsNonZero(d) ((d) != 0.0 || mxIsNaN(d))
#else
#define IsNonZero(d) ((d) != 0.0)
#endif

#define MAX(x,y)  ((x)>(y) ? (x) : (y))
#define MIN(x,y)  ((x)<(y) ? (x) : (y))

void mexFunction(
        int nlhs,       mxArray *plhs[],
        int nrhs, const mxArray *prhs[]
        )
{
  /* Declare variables. */
  int j,k,m,n,nzmax,*irs,*jcs, *irs2, *jcs2;
  double *overlap, *overlap2, tmp, areaA, areaB;
  double percent_sparse;
  double *leftA, *rightA, *topA, *bottomA;
  double *leftB, *rightB, *topB, *bottomB;
  double *verbose;

  /* Get the size and pointers to input data. */
  m = MAX(mxGetM(prhs[0]), mxGetN(prhs[0]));
  n = MAX(mxGetM(prhs[4]), mxGetN(prhs[4]));
  /* printf("A=%d, B=%d\n", m, n); */

  leftA = mxGetPr(prhs[0]);
  rightA = mxGetPr(prhs[1]);
  topA = mxGetPr(prhs[2]);
  bottomA = mxGetPr(prhs[3]);

  leftB = mxGetPr(prhs[4]);
  rightB = mxGetPr(prhs[5]);
  topB = mxGetPr(prhs[6]);
  bottomB = mxGetPr(prhs[7]);

  verbose = mxGetPr(prhs[8]);

    /* Allocate space for sparse matrix. 
     * NOTE:  Assume at most 20% of the data is sparse.  Use ceil
     * to cause it to round up. 
     */

  percent_sparse = 0.01;
  nzmax = (int)ceil((double)m*(double)n*percent_sparse);

  plhs[0] = mxCreateSparse(m,n,nzmax,0);
  overlap  = mxGetPr(plhs[0]);
  irs = mxGetIr(plhs[0]);
  jcs = mxGetJc(plhs[0]);

  plhs[1] = mxCreateSparse(m,n,nzmax,0);
  overlap2  = mxGetPr(plhs[1]);
  irs2 = mxGetIr(plhs[1]);
  jcs2 = mxGetJc(plhs[1]);

    
  /* Assign nonzeros. */
  k = 0; 
  for (j = 0; (j < n); j++) {
    int i;
    jcs[j] = k; 
    jcs2[j] = k; 
    for (i = 0; (i < m); i++) {
      tmp = (MAX(0, MIN(rightA[i], rightB[j]) - MAX(leftA[i], leftB[j]) )) * 
	(MAX(0, MIN(topA[i], topB[j]) - MAX(bottomA[i], bottomB[j]) ));
      
      if (*verbose) {
	printf("j=%d,i=%d,tmp=%5.3f\n", j,i,tmp);
      }

      if (IsNonZero(tmp)) {

        /* Check to see if non-zero element will fit in 
         * allocated output array.  If not, increase
         * percent_sparse by 20%, recalculate nzmax, and augment
         * the sparse array.
         */
        if (k >= nzmax) {
          int oldnzmax = nzmax;
          percent_sparse += 0.2;
          nzmax = (int)ceil((double)m*(double)n*percent_sparse);

          /* Make sure nzmax increases atleast by 1. */
          if (oldnzmax == nzmax) 
            nzmax++;
	  printf("reallocating from %d to %d\n", oldnzmax, nzmax);

          mxSetNzmax(plhs[0], nzmax); 
          mxSetPr(plhs[0], mxRealloc(overlap, nzmax*sizeof(double)));
          mxSetIr(plhs[0], mxRealloc(irs, nzmax*sizeof(int)));
          overlap  = mxGetPr(plhs[0]);
          irs = mxGetIr(plhs[0]);

          mxSetNzmax(plhs[1], nzmax); 
          mxSetPr(plhs[1], mxRealloc(overlap2, nzmax*sizeof(double)));
          mxSetIr(plhs[1], mxRealloc(irs2, nzmax*sizeof(int)));
          overlap2  = mxGetPr(plhs[1]);
          irs2 = mxGetIr(plhs[1]);
        }

        overlap[k] = tmp;
        irs[k] = i;
	
	areaA = (rightA[i]-leftA[i])*(topA[i]-bottomA[i]);
	areaB = (rightB[j]-leftB[j])*(topB[j]-bottomB[j]);
	overlap2[k] = MIN(tmp/areaA, tmp/areaB);
	irs2[k] = i;

        k++;
      } /* IsNonZero */
    } /* for i */
  }
  jcs[n] = k;
  jcs2[n] = k;
  
}