Beispiel #1
0
Datei: mi.c Projekt: cran/rsgcc
//for pearson correlation
coord_t c_pcc(mi_t* const m, const coord_t* const xs, const coord_t* const ys) {
  
  int i;
  make_grid(&m->grid, xs, ys, m->n, m->k);

  coord_t meanx = 0.0;
  coord_t meany = 0.0;
  coord_t sum1 = 0.0;
  coord_t sum2 = 0.0;
  coord_t sum3 = 0.0;
 
  const int len = m->n;
  for( i = 0; i < len; i++ ) {
      meanx += xs[i];
      meany += ys[i];
   }
   meanx = 1.0*meanx/len;
   meany = 1.0*meany/len;

   for( i = 0; i < len; i++ ) {
       sum1 += (xs[i] - meanx)*(ys[i] - meany);
       sum2 += (xs[i] - meanx)*(xs[i] - meanx);
       sum3 += (ys[i] - meany)*(ys[i] - meany);
    }
    
  destroy_grid(&m->grid);

   if( sum2 == 0.0 || sum3 == 0.0 ) return(0.0);
   else                             return( 1.0*sum1/(sqrt(sum2)*sqrt(sum3)) );

}
Beispiel #2
0
Datei: mi.c Projekt: cran/rsgcc
coord_t mutual_information(mi_t* const m, const coord_t* const xs, const coord_t* const ys) {
  const coord_t* pxs;
  const coord_t* pys;
  make_grid(&m->grid, xs, ys, m->n, m->k);
  ordered_points(&m->grid, &pxs, &pys);

  sort_coords(pxs, m->sxs, m->xiis, m->n);
  sort_coords(pys, m->sys, m->yiis, m->n);

  int i;
  coord_t accum = 0;
  for (i = 0; i < m->n; i++) {
    int kis[m->k];
    search_knn(&m->grid, pxs[i], pys[i], kis);

    const dist_t mdx = find_range(pxs, i, kis, m->k);
    const int nx = region_count(m->sxs, m->n, m->xiis[i], mdx);

    const dist_t mdy = find_range(pys, i, kis, m->k);
    const int ny = region_count(m->sys, m->n, m->yiis[i], mdy);

    accum += get_psi(m, nx) + get_psi(m, ny);
  }

  destroy_grid(&m->grid);

  return get_psi(m, m->k) + get_psi(m, m->n) - (1.0/m->k) - (accum/m->n);
}
Beispiel #3
0
Datei: mi.c Projekt: cran/rsgcc
//for spearman correlation
coord_t c_scc(mi_t* const m, const coord_t* const xs, const coord_t* const ys, const int* const xsix, const int* const ysix ) {
   make_grid(&m->grid, xs, ys, m->n, m->k);
  
  const int len = m->n;
  int i, j;
  
  //sort y by the rank of x
  int xorder, yorder;
  coord_t vecx_x[len], vecix_x[len], vecy_x[len], vecixy_x[len];
  for(i = 0; i < len; i++ ) {
     xorder = xsix[i];
     vecx_x[xorder-1] = xs[i];
     vecix_x[xorder-1] = xorder;
     vecy_x[xorder-1] = ys[i];
     vecixy_x[xorder-1] = ysix[i];
  }
  //mask the rank of x
  maskrankforSCC( vecx_x, vecix_x, len );
/*
  for( i = 0; i < len; i++ ) {
     printf("%f, %f, %f, %f\n", vecx_x[i], vecix_x[i], vecy_x[i], vecixy_x[i] );
  }
  printf("\n\n");
*/
  //sort x by the rank of y
  coord_t vecy_y[len], vecixy_y[len], vecixx_y[len];
  for( i = 0; i < len; i++ ) {
     yorder = vecixy_x[i];
     vecy_y[yorder-1] = vecy_x[i];
     vecixy_y[yorder-1] = yorder;
     vecixx_y[yorder-1] = vecix_x[i];
  }
  //mask the rank of y
  maskrankforSCC( vecy_y, vecixy_y, len );
/*
   for( i = 0; i < len; i++ ) {
     printf("%f, %f, %f\n", vecy_y[i], vecixy_y[i], vecixx_y[i] );
  }
  printf("\n\n");
*/
  coord_t tmp = 0;
  for( i = 0; i < len; i++ ) {
     tmp += (vecixy_y[i] - vecixx_y[i])*(vecixy_y[i] - vecixx_y[i]);
  }
//  printf("%d, %f\n", len, 1.0 - 6.0*tmp/(len*len*len - len) );
 
  destroy_grid(&m->grid);

  return( 1.0 - 6.0*tmp/(len*len*len - len) );
}
Beispiel #4
0
Datei: mi.c Projekt: cran/rsgcc
//for spearman correlation
coord_t c_kcc(mi_t* const m, const coord_t* const xs, const coord_t* const ys ) {
   make_grid(&m->grid, xs, ys, m->n, m->k);
  
  const int len = m->n;
  int i, j, num;
  num = 0;
  for( i = 1; i < len; i++ ) {
     for( j = 0; j < i; j++ ) {
         num += (xs[i] - xs[j])*(ys[i] - ys[j]) > 0 ? 1 : -1;
     }//end for j
  }//end for i

 
  destroy_grid(&m->grid);

  return( 2.0*num/(len*len - len) );
}
Beispiel #5
0
Datei: mi.c Projekt: cran/rsgcc
//for euclidean distance
coord_t c_eudist( mi_t* const m, const coord_t* const xs, const coord_t* const ys) {
  int i;
  make_grid(&m->grid, xs, ys, m->n, m->k);

  coord_t sum1 = 0.0;
  coord_t t_tmp = 0.0;
  const int len = m->n;
  for( i = 0; i < len; i++ ) {
      t_tmp = xs[i] - ys[i];
      sum1 += t_tmp*t_tmp;
   }
    
  destroy_grid(&m->grid);

   if( sum1 == 0.0 ) return(0.0);
   else              return( sqrt(sum1) );
}
Beispiel #6
0
Datei: mi.c Projekt: cran/rsgcc
//for gini correlation
coord_t c_gcc(mi_t* const m, const coord_t* const xs, const coord_t* const ys, const int* const xsix, const int* const ysix ) {
  
  make_grid(&m->grid, xs, ys, m->n, m->k);
  
  const int len = m->n;
  int xorder, yorder;
  coord_t vecx_x[len], vecx_y[len], vecy_y[len], vecy_x[len];
  for (int i = 0; i < len; i++ ) {
  	xorder = xsix[i];
  	vecx_x[xorder-1] = xs[i];
  	vecy_x[xorder-1] = ys[i];
  	
  	yorder = ysix[i];
  	vecy_y[yorder-1] = ys[i];
  	vecx_y[yorder-1] = xs[i];
  }
  	

  coord_t accumx_x = 0;
  coord_t accumx_y = 0;
  coord_t accumy_y = 0;
  coord_t accumy_x = 0;
  for (int i = 0; i < len; i++) {
     //for order x
     coord_t weight = 2.0*(i+1)- m->n -1.0;
     accumx_x += weight*vecx_x[i];
     accumx_y += weight*vecx_y[i];
     
     accumy_y += weight*vecy_y[i];
     accumy_x += weight*vecy_x[i];
  }//for i

  coord_t gccx_y = accumx_y/accumx_x;
  coord_t gccy_x = accumy_x/accumy_y;
  coord_t final_gcc = gccx_y*gccx_y > gccy_x*gccy_x ? gccx_y : gccy_x;

  destroy_grid(&m->grid);

  return final_gcc;

}
Beispiel #7
0
//for NVIEWSHEDS small, the resulting map is basically all empty;
//the interpolate function extends each non-empty output viewshed
//value to a ball centered at that point
void interpolate_raster(Grid* outgrid, char* output_name) {
  
  assert(outgrid);
  printf("\n-----\n");
  printf("Multiviewshed done, interpolating result grid."); 
  printf("total  %d viewsheds: ", nvp); 

  /*create the interpolated output raster */
  Grid* intgrid = create_empty_grid(); 
  assert(intgrid); 
  copy_header(intgrid->hd, outgrid->hd); 
  alloc_grid_data(intgrid); 

  int nrows, ncols, row, col;
  nrows = intgrid->hd->nrows; 
  ncols = intgrid->hd->ncols; 
  
  int nvis; 
  for(row = 0; row < nrows; row++) {
    for(col = 0; col < ncols; col++) {  
      
      nvis = findClosestViewpoint(row,col);
      //printf("%d %d :%d\n", row, col, nvis); 
      set(intgrid, row, col,  nvis); 
    }//for col
  } //for row 
  
  /* write grid to file */
  char* interp_name = (char*)malloc((strlen(output_name+8))*sizeof(char)); 
  assert(interp_name); 
  strcpy(interp_name,output_name);
  strcat(interp_name, "-interp"); 
  printf("creating interpolated raster: %s\n", interp_name); 
  save_grid_to_arcascii_file(intgrid, interp_name); 

  destroy_grid(intgrid);
}
Beispiel #8
0
 /// Destructor.
 GridManager::~GridManager()
 {
     destroy_grid(ug_);
 }
Beispiel #9
0
int main(int argc, char* argv[]) {

 //this variable collects all user options
  MultiviewOptions options;

  parse_args(argc, argv, &options); 
  record_args(options);

#ifdef INTERPOLATE_RESULT 
  viewsheds = (Nvis*) malloc((options->NVIEWSHEDS+10)*sizeof(Nvis)); 
  assert(viewsheds);
#endif 


  //read input raster 
  printf("reading input grid %s ", options.input_name); 
  Grid *ingrid = read_grid_from_arcascii_file(options.input_name);
  assert(ingrid); 
  printf("..done\n");

  //number of rows and columns in the grid 
  int nrows, ncols;  
  nrows = ingrid->hd->nrows; 
  ncols = ingrid->hd->ncols; 
  printf("grid: rows = %d, cols = %d\n", nrows, ncols);

  if (options.NVIEWSHEDS ==0) 
    options.NVIEWSHEDS = nrows * ncols; 

  //create an output grid 
  Grid* outgrid = create_empty_grid(); 
  assert(outgrid);
  //outgrid->hd = create_empty_header(); 
  //the header is allocated in create_empty_grid()
  copy_header(outgrid->hd, *(ingrid->hd)); 
  alloc_grid_data(outgrid); 


  /* **************************************** */
  /* INITIALIZE EVENT LIST */
  /* **************************************** */

  /*allocate the eventlist to hold the maximum number of events possible*/
  Event* eventList;
  eventList = (Event*) malloc(ncols * nrows * 3 * sizeof(Event));
  assert(eventList);
  
  /*initialize the eventList with the info common to all viewpoints */
  long  nevents;
  Rtimer initTime; 
  rt_start(initTime);
  nevents  = init_event_list(eventList, ingrid );
  printf("nb events = %ld\n", nevents);
  rt_stop(initTime); 
  print_init_timings(initTime); 
  
 

  /* ****************************** */   
  /* compute the viewshed of the i % DO_EVERY point  */
  /* ****************************** */   
  
  assert(options.NVIEWSHEDS > 0);
  int DO_EVERY = nrows * ncols/ options.NVIEWSHEDS; 
  /* start going through the data and considering each point, in turn,
     as a viewshed */
 
  if (options.SWEEP_MODE == SWEEP_DISTRIBUTE)  {
    assert(options.BASECASE_THRESHOLD >0 && options.NUM_SECTORS >0);
    compute_multiviewshed_distribution(options, DO_EVERY,
				       ingrid, outgrid,  nevents, eventList); 
  }
  else { 
    compute_multiviewshed_radial(options, DO_EVERY, ingrid, outgrid, 
				 nevents, eventList);
  }


  /* ****************************** */
  /*all sweeping and computing done - clean up */
  free(eventList);

  //write output grid to file 
  save_grid_to_arcascii_file(outgrid, options.output_name); 

  //clean up 
  destroy_grid(ingrid); 
  destroy_grid(outgrid); 


#ifdef INTERPOLATE_RESULT
  //for NVIEWSHEDS small, the resulting map is basically all empty;
  //the interpolate function extends each non-empty output viewshed
  //value to a ball centered at that point
  interpolate_raster(outgrid, output_name); 
#endif

  exit(0); 
}
Beispiel #10
0
CFUNC void
F77_FUNC_(fdestroy_grid,FDESTROY_GRID)
  (NUgrid **grid)
{
  destroy_grid (*grid);
}