void array2raster(const void* data, const char* name,
const RASTER_MAP_TYPE type, const int maxr, const int maxc) {
void* rast = G_allocate_raster_buf(type);
int fd;
if ((fd = G_open_raster_new(name, type)) < 0) {
G_fatal_error("Unable to create raster map <%s>", name);
}
int row, col;
for (row = 0; row < maxr; ++row) {
for (col = 0; col < maxc; ++col) {
int i = row * maxc + col;
switch (type) {
case CELL_TYPE:
((int*) rast)[col] = ((int*) data)[i];
break;
case FCELL_TYPE:
((float*) rast)[col] = ((float*) data)[i];
break;
case DCELL_TYPE:
((double*) rast)[col] = ((double*) data)[i];
break;
}
}
if (G_put_raster_row(fd, rast, type) < 0) {
G_fatal_error("Failed writing raster map <%s>", name);
}
}
G_free(rast);
G_close_cell(fd);
return;
}
/* useful to create randomised samples for statistical tests */
void do_split_sample ( char *input, char *output, int in_types, double percentage, char *map,
int all, int processing_mode, int quiet) {
CELL *cellbuf;
DCELL *dcellbuf;
GT_Row_cache_t *cache;
int fd;
int i,j,k,l;
int no_sites;
int sites_tried = 0;
struct Cell_head region;
int error;
char *mapset, errmsg [200];
unsigned int *taken; /* this is an array of 0/1 which signals, if
a certain site has already been 'drawn' */
long row_idx, col_idx;
struct Map_info in_vect_map;
struct Map_info out_vect_map;
struct line_pnts *vect_points;
struct line_cats *vect_cats;
double x,y,z;
int n_points = 1;
int cur_type;
cellbuf = NULL;
dcellbuf = NULL;
cache = NULL;
/* get current region */
G_get_window (®ion);
/* attempt to create new file for output */
Vect_set_open_level (2);
if (0 > Vect_open_new (&out_vect_map, output, 0) ) {
G_fatal_error ("Could not open output vector map.\n");
}
/* open input vector map */
if ((mapset = G_find_vector2 (input, "")) == NULL) {
sprintf (errmsg, "Could not find input %s\n", input);
G_fatal_error ("%s",errmsg);
}
if (1 > Vect_open_old (&in_vect_map, input, "")) {
sprintf (errmsg, "Could not open input map %s.\n", input);
G_fatal_error ("%s",errmsg);
}
vect_points = Vect_new_line_struct ();
vect_cats = Vect_new_cats_struct ();
/* set constraints specified */
if (in_types != 0) {
Vect_set_constraint_type (&in_vect_map, in_types);
}
if (all != 1) {
Vect_set_constraint_region (&in_vect_map, region.north, region.south,
region.east, region.west, 0.0, 0.0);
}
/* get total number of objects with constraints */
i = 0;
while ((cur_type = Vect_read_next_line (&in_vect_map, vect_points, vect_cats) > 0)) {
i ++;
}
k = ( ((float) i/100)) * percentage; /* k now has the number of objects wanted */
if ( quiet != 1 ) {
fprintf (stderr,"Creating randomised sample of size n = %i.\n",k);
}
/* now, we need to acquire exactly 'k' random objects that fall in NON-NULL */
/* coverage raster cells. */
taken = G_calloc (i, sizeof (unsigned int));
for ( l = 0; l < k; l ++ ) {
taken[l] = 0;
}
no_sites = i; /* store this for later use */
/* does user want to filter objects through a raster map? */
if ( map != NULL) {
/* open raster map */
fd = G_open_cell_old (map, G_find_cell (map, ""));
if (fd < 0)
{
G_fatal_error ("Could not open raster map for reading!\n");
}
/* allocate cache and buffer, according to type of coverage */
if ( processing_mode == CELL_TYPE) {
/* INT coverage */
cache = (GT_Row_cache_t *) G_malloc (sizeof (GT_Row_cache_t));
/* TODO: check error value */
error = GT_RC_open (cache, cachesize, fd, CELL_TYPE);
cellbuf = G_allocate_raster_buf (CELL_TYPE);
}
if ( (processing_mode == FCELL_TYPE) || (processing_mode == DCELL_TYPE) ) {
/* FP coverage */
cache = (GT_Row_cache_t *) G_malloc (sizeof (GT_Row_cache_t));
/* TODO: check error value */
error = GT_RC_open (cache, cachesize, fd, DCELL_TYPE);
dcellbuf = G_allocate_raster_buf (DCELL_TYPE);
}
}
srand ( ((unsigned int) time (NULL)) + getpid()); /* set seed for random number generator from system time and process ID*/
i = 0;
/* MAIN LOOP */
while ( i < k ) {
/* get a random index, but one that was not taken already */
l = 0;
while ( l == 0 ) {
j = rand () % ( no_sites - 1 + 1) + 1; /* j now has the random position to try */
if ( taken[j-1] == 0 ) {
l = 1; /* exit loop */
}
}
taken [j-1] = 1; /* mark this index as 'taken' */
sites_tried ++; /* keep track of this so we do not enter an infinite loop */
if ( sites_tried > no_sites ) {
/* could not create a large enough sample */
G_fatal_error ("Could not find enough objects for split sampling.\nDecrease split sample size.\n");
}
/* get next vector object */
cur_type = Vect_read_line (&in_vect_map, vect_points, vect_cats, j);
if (cur_type < 0 ) {
G_fatal_error ("Error reading vector map: premature EOF.\n");
}
/* now, check if coverage under site is NON-NULL and within region */
/* convert site northing to row! */
/* for this check, we use only the first pair of coordinates! */
Vect_copy_pnts_to_xyz (vect_points, &x, &y, &z, &n_points);
row_idx =
(long) G_northing_to_row (y,
®ion);
col_idx =
(long) G_easting_to_col (x,
®ion);
/* do region check, first... OBSOLETE */
/* read row from cache and check for NULL */
/* if required */
if ( map != NULL ) {
if ( processing_mode == CELL_TYPE ) {
cellbuf = GT_RC_get (cache, row_idx);
if (!G_is_c_null_value(&cellbuf[col_idx])) {
i ++;
Vect_write_line (&out_vect_map, cur_type,
vect_points, vect_cats );
fflush (stdout);
}
}
if ( (processing_mode == FCELL_TYPE) || (processing_mode == DCELL_TYPE) ) {
dcellbuf = GT_RC_get (cache, row_idx);
if (!G_is_d_null_value(&dcellbuf[col_idx])) {
i ++;
Vect_write_line (&out_vect_map, cur_type,
vect_points, vect_cats );
fflush (stdout);
}
}
} else {
i ++;
Vect_write_line (&out_vect_map, GV_POINT,
vect_points, vect_cats );
fflush (stdout);
}
/* disregard region setting and map, if -a flag is given */
if ( all == 1 ) {
i ++;
Vect_write_line (&out_vect_map, cur_type,
vect_points, vect_cats );
fflush (stdout);
}
if ( quiet != 1 ) {
G_percent(i,k,1);
}
}
/* END OF MAIN LOOP */
Vect_copy_head_data (&in_vect_map, &out_vect_map);
fprintf (stdout, "Building topology information for output map.\n");
Vect_build (&out_vect_map);
Vect_close (&in_vect_map);
Vect_close (&out_vect_map);
if ( map != NULL ) {
/* close cache, free buffers! */
GT_RC_close (cache);
if ( processing_mode == CELL_TYPE ) {
G_free (cellbuf);
}
if ( (processing_mode == FCELL_TYPE) || (processing_mode == DCELL_TYPE) ) {
G_free (dcellbuf);
}
G_free (cache);
}
}
int main(int argc, char *argv[])
{
int out_fd;
CELL *result, *rp;
int nrows, ncols;
int row, col;
struct GModule *module;
struct Option *in_opt, *out_opt;
struct Option *method_opt, *size_opt;
char *mapset;
struct Map_info In;
double radius;
struct ilist *List;
struct Cell_head region;
BOUND_BOX box;
struct line_pnts *Points;
struct line_cats *Cats;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("vector, raster, aggregation");
module->description = "Makes each cell value a "
"function of the attribute values assigned to the vector points or centroids "
"around it, and stores new cell values in an output raster map layer.";
in_opt = G_define_standard_option(G_OPT_V_INPUT);
out_opt = G_define_standard_option(G_OPT_R_OUTPUT);
method_opt = G_define_option();
method_opt->key = "method";
method_opt->type = TYPE_STRING;
method_opt->required = YES;
method_opt->options = "count";
method_opt->answer = "count";
method_opt->description = "Neighborhood operation";
size_opt = G_define_option();
size_opt->key = "size";
size_opt->type = TYPE_DOUBLE;
size_opt->required = YES;
size_opt->description = "Neighborhood diameter in map units";
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
radius = atof(size_opt->answer) / 2;
/* open input vector */
if ((mapset = G_find_vector2(in_opt->answer, "")) == NULL) {
G_fatal_error(_("Vector map <%s> not found in the current mapset"),
in_opt->answer);
}
Vect_set_open_level(2);
Vect_open_old(&In, in_opt->answer, mapset);
G_get_set_window(®ion);
nrows = G_window_rows();
ncols = G_window_cols();
result = G_allocate_raster_buf(CELL_TYPE);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
List = Vect_new_list();
/*open the new cellfile */
out_fd = G_open_raster_new(out_opt->answer, CELL_TYPE);
if (out_fd < 0)
G_fatal_error(_("Unable to create raster map <%s>"), out_opt->answer);
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
for (row = 0; row < nrows; row++) {
double x, y;
G_percent(row, nrows, 1);
y = G_row_to_northing(row + 0.5, ®ion);
box.N = y + radius;
box.S = y - radius;
G_set_null_value(result, ncols, CELL_TYPE);
rp = result;
for (col = 0; col < ncols; col++) {
int i, count;
CELL value;
x = G_col_to_easting(col + 0.5, ®ion);
box.E = x + radius;
box.W = x - radius;
Vect_select_lines_by_box(&In, &box, GV_POINTS, List);
G_debug(3, " %d lines in box", List->n_values);
count = 0;
for (i = 0; i < List->n_values; i++) {
double distance;
Vect_read_line(&In, Points, Cats, List->value[i]);
distance =
Vect_points_distance(x, y, 0.0, Points->x[0],
Points->y[0], 0.0, 0);
if (distance <= radius) {
count++;
}
}
if (count > 0) {
value = count;
G_set_raster_value_d(rp, value, CELL_TYPE);
}
rp = G_incr_void_ptr(rp, G_raster_size(CELL_TYPE));
}
G_put_raster_row(out_fd, result, CELL_TYPE);
}
G_percent(row, nrows, 1);
Vect_close(&In);
G_close_cell(out_fd);
exit(EXIT_SUCCESS);
}
static int cell_draw( char *name,
char *mapset,
struct Colors *colors,
RASTER_MAP_TYPE data_type,
char *format )
{
int cellfile;
void *xarray;
int row;
int ncols, nrows;
static unsigned char *red, *grn, *blu, *set;
int i;
void *ptr;
int big_endian;
long one = 1;
FILE *fo;
int raster_size;
big_endian = !( *(( char * )( &one ) ) );
ncols = G_window_cols();
nrows = G_window_rows();
/* Make sure map is available */
if (( cellfile = G_open_cell_old( name, mapset ) ) == -1 )
G_fatal_error(( "Unable to open raster map <%s>" ), name );
/* Allocate space for cell buffer */
xarray = G_allocate_raster_buf( data_type );
red = G_malloc( ncols );
grn = G_malloc( ncols );
blu = G_malloc( ncols );
set = G_malloc( ncols );
/* some buggy C libraries require BOTH setmode() and fdopen(bin) */
#ifdef WIN32
if ( _setmode( _fileno( stdout ), _O_BINARY ) == -1 )
G_fatal_error( "Cannot set stdout mode" );
#endif
// Unfortunately this is not sufficient on Windows to switch stdout to binary mode
fo = fdopen( fileno( stdout ), "wb" );
raster_size = G_raster_size( data_type );
//fprintf( fo, "%d %d", data_type, raster_size );
//exit(0);
/* loop for array rows */
for ( row = 0; row < nrows; row++ )
{
G_get_raster_row( cellfile, xarray, row, data_type );
ptr = xarray;
G_lookup_raster_colors( xarray, red, grn, blu, set, ncols, colors,
data_type );
for ( i = 0; i < ncols; i++ )
{
unsigned char alpha = 255;
//G_debug ( 0, "row = %d col = %d", row, i );
if ( G_is_null_value( ptr, data_type ) )
{
alpha = 0;
}
if ( strcmp( format, "color" ) == 0 )
{
// We need data suitable for QImage 32-bpp
// the data are stored in QImage as QRgb which is unsigned int.
// Because it depends on byte order of the platform we have to
// consider byte order (well, middle endian ignored)
if ( big_endian )
{
// I have never tested this
fprintf( fo, "%c%c%c%c", alpha, red[i], grn[i], blu[i] );
}
else
{
fprintf( fo, "%c%c%c%c", blu[i], grn[i], red[i], alpha );
}
}
else
{
if ( data_type == CELL_TYPE )
{
//G_debug ( 0, "valx = %d", *((CELL *) ptr));
}
if ( G_is_null_value( ptr, data_type ) )
{
if ( data_type == CELL_TYPE )
{
int nul = -2147483647;
fwrite( &nul , 4, 1, fo );
}
else if ( data_type == DCELL_TYPE )
{
double nul = 2.2250738585072014e-308;
fwrite( &nul , 8, 1, fo );
}
else if ( data_type == FCELL_TYPE )
{
double nul = 1.17549435e-38F;
fwrite( &nul , 4, 1, fo );
}
}
else
{
fwrite( ptr, raster_size, 1, fo );
}
}
ptr = G_incr_void_ptr( ptr, raster_size );
}
}
G_close_cell( cellfile );
return ( 0 );
}
/*
* main function
*/
int main(int argc, char *argv[])
{
/* struct Cell_head window; database window */
struct Cell_head cellhd; /* it stores region information,
and header information of rasters */
char *name, *name2; /* input raster name */
char *result; /* output raster name */
char *mapset; /* mapset name */
void *inrast; /* input buffer */
unsigned char *outrast; /* output buffer */
int nrows, ncols;
int row, col;
int infd, outfd; /* file descriptor */
int verbose;
struct History history; /* holds meta-data (title, comments,..) */
struct GModule *module; /* GRASS module for parsing arguments */
struct Option *input, *output, *input2; /* options */
FILE *in; /*file for Path loss factors*/
struct Flag *flag1; /* flags */
char buffer_out[1000];
strcpy(buffer_out,getenv("GISBASE"));
strcat(buffer_out,"/etc/radio_coverage/lossfactors_new.txt");
/*G_message(_("1!! Pot1: %s, Pot2: %s"), buffer_path, buffer_path1);
buffer_out=strcat(buffer_path,buffer_path1);
G_message(_("Pot1: %s, Pot2: %s"), buffer_path, buffer_path1);*/
/* initialize GIS environment */
G_gisinit(argv[0]); /* reads grass env, stores program name to G_program_name() */
/* initialize module */
module = G_define_module();
module->keywords = _("raster, clutter");
module->description = _("Clutter convert module");
/* Define the different options as defined in gis.h */
input = G_define_standard_option(G_OPT_R_INPUT);
input2 = G_define_standard_option(G_OPT_F_INPUT);
input2->key = "Path_loss_values";
input2->type = TYPE_STRING;
input2->required = YES;
input2->answer = buffer_out;//getenv("GISBASE"); //strcat(buffer_path1,(char *)getenv("GISBASE"));//,"/etc/radio_coverage");
input2->gisprompt = "old_file,file,input";
input2->description = _("Path loss factors for land usage");
/* Define the different flags */
flag1 = G_define_flag();
flag1->key = 'o';
flag1->description = _("Old_Cipher");
output = G_define_standard_option(G_OPT_R_OUTPUT);
/* options and flags parser */
if (G_parser(argc, argv))
{
exit(EXIT_FAILURE);
}
/*G_message(_("1!! Pot1: %s, Pot2: %s"), buffer_path, buffer_path1);
strcat(buffer_path,buffer_path1);
G_message(_("Pot1: %s, Pot2: %s"), buffer_path, buffer_path1);
input2->answer = buffer_path;//getenv("GISBASE"); //strcat(buffer_path1,(char *)getenv("GISBASE"));//,"/etc/radio_coverage");*/
/* stores options and flags to variables */
name = input->answer;
name2 = input2->answer;
result = output->answer;
verbose = (flag1->answer);
G_message(_("Verbose: %d"),verbose);
/* returns NULL if the map was not found in any mapset,
* mapset name otherwise */
//G_message(_("3_START"));
mapset = G_find_cell2(name, "");
if (mapset == NULL)
G_fatal_error(_("Raster map <%s> not found"), name);
if (G_legal_filename(result) < 0)
G_fatal_error(_("<%s> is an illegal file name"), result);
/* G_open_cell_old - returns file destriptor (>0) */
if ((infd = G_open_cell_old(name, mapset)) < 0)
G_fatal_error(_("Unable to open raster map <%s>"), name);
/* controlling, if we can open input raster */
if (G_get_cellhd(name, mapset, &cellhd) < 0)
G_fatal_error(_("Unable to read file header of <%s>"), name);
G_debug(3, "number of rows %d", cellhd.rows);
G_set_window(&cellhd);
G_get_set_window(&cellhd);
/* Allocate input buffer */
inrast = G_allocate_raster_buf(FCELL_TYPE);
/* Allocate output buffer, use input map data_type */
nrows = G_window_rows();
ncols = G_window_cols();
outrast = G_allocate_raster_buf(FCELL_TYPE);
G_message(_("nrows %d and ncols %d"),nrows,ncols);
/* controlling, if we can write the raster */
if ((outfd = G_open_raster_new(result, FCELL_TYPE)) < 0)
G_fatal_error(_("Unable to create raster map <%s>"), result);
/* do Clutter Convert */
/* open file for model tuning parameters*/
char fileName[150];
strcpy (fileName, name2);
//G_message(_("Path: %s"),name2);
if( (in = fopen(fileName,"r")) == NULL )
G_fatal_error(_("Unable to open file <%s>"), fileName);
char buffer[256];
double terr_path_loss[100];
int counter=0;
fgets (buffer, 250, in);
while(fgets(buffer,250,in)!=NULL){
sscanf(buffer,"%lf %lf", &terr_path_loss[counter]);
counter++;
}
int cipher_cont=0;
/* old or new clutter */
if (verbose == 1)
{
cipher_cont=1;
G_message(_("Parameter UR: %f, GP: %f, RP: %f, GI: %f, GL: %f, GM: %f, GR: %f, VO: %f, KM: %f, OD: %f"), terr_path_loss[0], terr_path_loss[1], terr_path_loss[2], terr_path_loss[3], terr_path_loss[4], terr_path_loss[5], terr_path_loss[6], terr_path_loss[7], terr_path_loss[8], terr_path_loss[9]);
}
else if (verbose == 0)
{
cipher_cont=11;
G_message(_("Parameter UR1: %f, UR2: %f, UR3: %f, UR4: %f, UR5: %f, GI: %f, GL: %f, GM: %f, GR: %f, VO: %f, KM: %f, OD: %f"), terr_path_loss[0], terr_path_loss[1], terr_path_loss[2], terr_path_loss[3], terr_path_loss[4], terr_path_loss[5], terr_path_loss[6], terr_path_loss[7], terr_path_loss[8], terr_path_loss[9], terr_path_loss[10], terr_path_loss[11]);
}
G_message(_("Counter: %d"),counter);
G_message(_("cipher_cont: %d"),cipher_cont);
G_message(_("START"));
/* for each row */
for (row = 0; row < nrows; row++)
{
FCELL f_in, f_out;
/* read input map */
if (G_get_raster_row(infd, inrast, row, FCELL_TYPE) < 0)
G_fatal_error(_("Unable to read raster map <%s> row %d"), name, row);
/* process the data */
for (col = 0; col < ncols; col++)
{
f_in = ((FCELL *) inrast)[col];
//G_message(_("Input data: %d"),(int)f_in);
f_out = terr_path_loss[(int)f_in-cipher_cont];
//G_message(_("Output data: %f"),(double)f_out);
((FCELL *) outrast)[col] = f_out;
}
/* write raster row to output raster map */
if (G_put_raster_row(outfd, outrast, FCELL_TYPE) < 0)
G_fatal_error(_("Failed writing raster map <%s>"), result);
}
//G_message(_("END_clutconvert_test"));
G_message(_("END"));
/* memory cleanup */
G_free(inrast);
G_free(outrast);
/* closing raster maps */
G_close_cell(infd);
G_close_cell(outfd);
/* add command line incantation to history file */
G_short_history(result, "raster", &history);
G_command_history(&history);
G_write_history(result, &history);
exit(EXIT_SUCCESS);
}
static int cell_draw( char *name,
char *mapset,
struct Colors *colors,
RASTER_MAP_TYPE data_type,
char *format )
{
int cellfile;
void *xarray = 0;
int row;
int ncols, nrows;
static unsigned char *red, *grn, *blu, *set;
int i;
void *ptr = 0;
int big_endian;
long one = 1;
FILE *fo = 0;
size_t raster_size;
#ifdef NAN
double dnul = NAN;
float fnul = ( float )( NAN );
#else
double dnul = strtod( "NAN", 0 );
float fnul = strtof( "NAN", 0 );
// another possibility would be nan()/nanf() - C99
// and 0./0. if all fails
#endif
assert( dnul != dnul );
assert( fnul != fnul );
big_endian = !( *( ( char * )( &one ) ) );
ncols = G_window_cols();
nrows = G_window_rows();
/* Make sure map is available */
if ( ( cellfile = G_open_cell_old( name, mapset ) ) == -1 )
G_fatal_error( ( "Unable to open raster map <%s>" ), name );
/* Allocate space for cell buffer */
xarray = G_allocate_raster_buf( data_type );
red = G_malloc( ncols );
grn = G_malloc( ncols );
blu = G_malloc( ncols );
set = G_malloc( ncols );
/* some buggy C libraries require BOTH setmode() and fdopen(bin) */
// Do not use Q_OS_WIN, we are in C file, no Qt headers
#ifdef WIN32
if ( _setmode( _fileno( stdout ), _O_BINARY ) == -1 )
G_fatal_error( "Cannot set stdout mode" );
#endif
// Unfortunately this is not sufficient on Windows to switch stdout to binary mode
fo = fdopen( fileno( stdout ), "wb" );
raster_size = G_raster_size( data_type );
//fprintf( fo, "%d %d", data_type, raster_size );
//exit(0);
/* loop for array rows */
for ( row = 0; row < nrows; row++ )
{
G_get_raster_row( cellfile, xarray, row, data_type );
ptr = xarray;
G_lookup_raster_colors( xarray, red, grn, blu, set, ncols, colors,
data_type );
for ( i = 0; i < ncols; i++ )
{
unsigned char alpha = 255;
//G_debug ( 0, "row = %d col = %d", row, i );
if ( G_is_null_value( ptr, data_type ) )
{
alpha = 0;
}
if ( strcmp( format, "color" ) == 0 )
{
// We need data suitable for QImage 32-bpp
// the data are stored in QImage as QRgb which is unsigned int.
// Because it depends on byte order of the platform we have to
// consider byte order (well, middle endian ignored)
if ( big_endian )
{
// I have never tested this
fprintf( fo, "%c%c%c%c", alpha, red[i], grn[i], blu[i] );
}
else
{
fprintf( fo, "%c%c%c%c", blu[i], grn[i], red[i], alpha );
}
}
else
{
if ( data_type == CELL_TYPE )
{
//G_debug ( 0, "valx = %d", *((CELL *) ptr));
}
if ( G_is_null_value( ptr, data_type ) )
{
// see comments in QgsGrassRasterProvider::noDataValue()
if ( data_type == CELL_TYPE )
{
//int nul = -2000000000;
int nul = INT_MIN;
fwrite( &nul, 4, 1, fo );
}
else if ( data_type == DCELL_TYPE )
{
//double nul = -1e+300;
fwrite( &dnul, 8, 1, fo );
}
else if ( data_type == FCELL_TYPE )
{
//double nul = -1e+30;
fwrite( &fnul, 4, 1, fo );
}
}
else
{
fwrite( ptr, raster_size, 1, fo );
}
}
ptr = G_incr_void_ptr( ptr, raster_size );
}
}
G_close_cell( cellfile );
fclose( fo );
return ( 0 );
}
void cell_clip(DCELL ** buf, DCELL ** null_buf, int row0, int col0, int nrows,
int ncols, int index, float radius)
{
CELL *tmp, *tmp1;
FCELL *ftmp;
DCELL *dtmp;
char *tmpname, *nulltmp;
int fr;
register int i, j;
double center_row = 0.0, center_col = 0.0;
double dist;
RASTER_MAP_TYPE data_type;
/*
Variables:
IN:
buf = pointer to array containing only the pixels inside the area
that was specified to be clipped, so a smaller array than the
original raster map
null_buf = pointer to array containing the corresponding null values
row0 = starting row for the area to be clipped out of the raster map
col0 = starting col for the area to be clipped out of the raster map
nrows = total number of rows in the area to be clipped
ncols = total number of cols in the area to be clipped
index = number of the region to be clipped, if there's a region map
INTERNAL:
tmp = pointer to a temporary array to store a row of the raster map
tmp1 = pointer to a temporary array to store a row of the region map
fr = return value from attempting to open the region map
i, j = indices to rows and cols of the arrays
*/
data_type = G_raster_map_type(choice->fn, G_mapset());
/* if sampling by region was chosen, check
for the region map and make sure it is
an integer (CELL_TYPE) map */
if (choice->wrum == 'r') {
if (0 > (fr = G_open_cell_old(choice->reg, G_mapset()))) {
fprintf(stderr, "\n");
fprintf(stderr,
" *******************************************************\n");
fprintf(stderr,
" You specified sam=r to request sampling by region, \n");
fprintf(stderr,
" but the region map specified with the 'reg=' parameter\n");
fprintf(stderr,
" cannot be found in the current mapset. \n");
fprintf(stderr,
" *******************************************************\n");
exit(1);
}
if (G_raster_map_type(choice->reg, G_mapset()) > 0) {
fprintf(stderr, "\n");
fprintf(stderr,
" *******************************************************\n");
fprintf(stderr,
" You specified sam=r to request sampling by region, \n");
fprintf(stderr,
" but the region map specified with the 'reg=' parameter\n");
fprintf(stderr,
" must be an integer map, and it is floating point or \n");
fprintf(stderr,
" double instead. \n");
fprintf(stderr,
" *******************************************************\n");
exit(1);
}
tmp1 = G_allocate_raster_buf(CELL_TYPE);
G_zero_raster_buf(tmp1, CELL_TYPE);
fprintf(stderr, "Analyzing region number %d...\n", index);
}
/* allocate memory to store a row of the
raster map, depending on the type of
input raster map; keep track of the
name of the buffer for each raster type */
switch (data_type) {
case CELL_TYPE:
tmp = G_allocate_raster_buf(CELL_TYPE);
tmpname = "tmp";
break;
case FCELL_TYPE:
ftmp = G_allocate_raster_buf(FCELL_TYPE);
tmpname = "ftmp";
break;
case DCELL_TYPE:
dtmp = G_allocate_raster_buf(DCELL_TYPE);
tmpname = "dtmp";
break;
}
/* allocate memory to store a row of the
null values corresponding to the raster
map */
nulltmp = G_allocate_null_buf();
/* if circles are used for sampling, then
calculate the center of the area to be
clipped, in pixels */
if ((int)radius) {
center_row = ((double)row0 + ((double)nrows - 1) / 2);
center_col = ((double)col0 + ((double)ncols - 1) / 2);
}
/* for each row of the area to be clipped */
for (i = row0; i < row0 + nrows; i++) {
/* if region, read in the corresponding
map row in the region file */
if (choice->wrum == 'r')
G_get_raster_row_nomask(fr, tmp1, i, CELL_TYPE);
/* initialize each element of the
row buffer to 0; this row buffer
will hold one row of the clipped
raster map. Then read row i of the
map and the corresponding null values
into tmp and nulltmp buffers */
switch (data_type) {
case CELL_TYPE:
G_zero_raster_buf(tmp, data_type);
G_get_raster_row(finput, tmp, i, CELL_TYPE);
break;
case FCELL_TYPE:
G_zero_raster_buf(ftmp, data_type);
G_get_raster_row(finput, ftmp, i, FCELL_TYPE);
break;
case DCELL_TYPE:
G_zero_raster_buf(dtmp, data_type);
G_get_raster_row(finput, dtmp, i, DCELL_TYPE);
break;
}
G_get_null_value_row(finput, nulltmp, i);
/* for all the columns one by one */
for (j = col0; j < col0 + ncols; j++) {
/* if circles are used for sampling */
if ((int)radius) {
dist = sqrt(((double)i - center_row) *
((double)i - center_row) +
((double)j - center_col) *
((double)j - center_col));
/* copy the contents of tmp into the
appropriate cell in buf */
if (dist < radius) {
switch (data_type) {
case CELL_TYPE:
*(*(buf + i + 1 - row0) + j + 1 - col0) = *(tmp + j);
break;
case FCELL_TYPE:
*(*(buf + i + 1 - row0) + j + 1 - col0) = *(ftmp + j);
break;
case DCELL_TYPE:
*(*(buf + i + 1 - row0) + j + 1 - col0) = *(dtmp + j);
break;
}
*(*(null_buf + i + 1 - row0) + j + 1 - col0) =
*(nulltmp + j);
}
}
/* if circles are not used and
if the choice is not "by region" or
if this column is in region "index" */
else if (choice->wrum != 'r' || *(tmp1 + j) == index) {
/* copy the contents of the correct tmp
into the appropriate cell in the buf
and the corresponding null values into
the appropriate cell in null_buf */
switch (data_type) {
case CELL_TYPE:
*(*(buf + i + 1 - row0) + j + 1 - col0) = *(tmp + j);
break;
case FCELL_TYPE:
*(*(buf + i + 1 - row0) + j + 1 - col0) = *(ftmp + j);
break;
case DCELL_TYPE:
*(*(buf + i + 1 - row0) + j + 1 - col0) = *(dtmp + j);
break;
}
*(*(null_buf + i + 1 - row0) + j + 1 - col0) = *(nulltmp + j);
}
}
}
switch (data_type) {
case CELL_TYPE:
G_free(tmp);
break;
case FCELL_TYPE:
G_free(ftmp);
break;
case DCELL_TYPE:
G_free(dtmp);
break;
}
if (choice->wrum == 'r') {
G_free(tmp1);
G_close_cell(fr);
}
G_free(nulltmp);
return;
}
/* create the actual report */
void do_report_CELL ( char *map, char *mapset, char *sites,
int precision, int null_flag, int uncat_flag,
int all_flag, int quiet_flag, int skip_flag,
char *logfile, int background, int gain, int show_progress) {
CELL *cellbuf;
struct Cell_head region;
GT_Row_cache_t *cache;
unsigned long row_idx, col_idx;
int fd;
unsigned long i,j,k;
unsigned long no_sites;
FILE *lp;
unsigned long nrows, ncols;
unsigned long *share_smp = NULL; /* array that keeps percentage of sites */
double total = 0;
double map_total = 0;
double kvamme_gain;
long null_count = 0; /* keeps count of sites on NULL cells */
long nocat_count = 0;
/* category counts and descriptions */
int cats;
char **cats_description; /* category labels */
long *cat_count; /* category counts */
long null_count_map; /* number of NULL cells in input map */
long nocat_count_map; /* number of cells that do not fall into the category range [0 .. n] */
int debug_mode = 0; /* 1 to enable writing additional output to logfile */
time_t systime;
char errmsg [200];
struct Map_info in_vect_map;
struct line_pnts *vect_points;
double x,y,z;
int n_points = 1;
int cur_type;
/* get current region */
G_get_window (®ion);
nrows = G_window_rows ();
ncols = G_window_cols ();
/* check logfile */
if (logfile != NULL) {
debug_mode = 1;
if ( !G_legal_filename (logfile) ) {
delete_tmpfile (map);
G_fatal_error ("Please specify a legal filename for the logfile.\n");
}
/* attempt to write to logfile */
if ( (lp = fopen ( logfile, "w+" ) ) == NULL ) {
delete_tmpfile (map);
G_fatal_error ("Could not create logfile.\n");
}
/* we want unbuffered output for the logfile */
setvbuf (lp,NULL,_IONBF,0);
fprintf (lp,"This is %s, version %.2f\n",PROGNAME, PROGVERSION);
systime = time (NULL);
fprintf (lp,"Started on %s",ctime(&systime));
fprintf (lp,"\tlocation = %s\n",G_location());
fprintf (lp,"\tmapset = %s\n",G_mapset());
fprintf (lp,"\tinput map = %s\n",map);
fprintf (lp,"\tsample file = %s\n",sites);
} else {
/* log output to stderr by default */
lp = stderr;
}
if (1 > Vect_open_old (&in_vect_map, sites, "")) {
delete_tmpfile (map);
sprintf (errmsg, "Could not open input map %s.\n", sites);
G_fatal_error (errmsg);
}
vect_points = Vect_new_line_struct ();
if (all_flag != 1) {
Vect_set_constraint_region (&in_vect_map, region.north, region.south,
region.east, region.west, 0.0, 0.0);
}
/* get total number of sampling points */
i = 0;
while ((cur_type = Vect_read_next_line (&in_vect_map, vect_points, NULL) > 0)) {
i ++;
}
no_sites = i; /* store this for later use */
/* open raster map */
fd = G_open_cell_old (map, G_find_cell (map, ""));
if (fd < 0)
{
delete_tmpfile (map);
G_fatal_error ("Could not open raster map for reading!\n");
}
/* allocate a cache and a raster buffer */
cache = (GT_Row_cache_t *) G_malloc (sizeof (GT_Row_cache_t));
GT_RC_open (cache, CACHESIZE, fd, CELL_TYPE);
cellbuf = G_allocate_raster_buf (CELL_TYPE);
cats = GT_get_stats (map,mapset,&null_count_map, &nocat_count_map, show_progress);
if ( cats < 2 ) {
delete_tmpfile (map);
G_fatal_error ("Input map must have at least two categories.");
}
/* get category labels and counts */
cats_description = GT_get_labels (map,mapset);
if (cats_description == NULL) {
delete_tmpfile (map);
G_fatal_error ("Could not read category labels from input map.");
}
cat_count = GT_get_c_counts (map,mapset, show_progress);
if (cat_count == NULL) {
delete_tmpfile (map);
G_fatal_error ("Could not count categories in input map.");
}
/* allocate a double array to hold statistics */
share_smp = (unsigned long *) G_malloc ((signed)(cats * sizeof (unsigned long)));
for (i = 0; i < cats; i++)
{
share_smp[i] = 0;
}
/* count raster values under sampling points */
i = 0;
k = 0; /* progress counter for status display */
Vect_rewind (&in_vect_map);
if ( !quiet_flag ) {
fprintf (stdout, "Counting sample: \n");
fflush (stdout);
}
/* we MUST not set constraints so that no raster values outside the current region are
accessed, which would give an "illegal cache request" error */
Vect_set_constraint_region (&in_vect_map, region.north, region.south,
region.east, region.west, 0.0, 0.0);
while ((cur_type = Vect_read_next_line (&in_vect_map, vect_points, NULL) > 0)) {
Vect_copy_pnts_to_xyz (vect_points, &x, &y, &z, &n_points);
k ++;
if ( !quiet_flag ) {
G_percent ((signed) k, (signed) no_sites, 1);
}
/* get raster row with same northing as sample and perform
quantification */
row_idx = (long) G_northing_to_row (y, ®ion);
col_idx = (long) G_easting_to_col (x, ®ion);
cellbuf = GT_RC_get (cache, (signed) row_idx);
/* now read the raster value under the current site */
if (G_is_c_null_value (&cellbuf[col_idx]) == 0) {
/* site on cell within category range [0..cats] ? */
if ( (cellbuf[col_idx] > -1) && (cellbuf[col_idx] <= cats) ) {
share_smp [cellbuf[col_idx] ] ++;
/* i keeps track of samples on non-null coverage only */
/* inside the current region */
i ++;
} else {
if ( uncat_flag ) {
/* also keep count of sites on uncategorised cells? */
i ++;
nocat_count++;
}
}
}
if (G_is_c_null_value (&cellbuf[col_idx]) == 1) {
/* got a NULL value under this site */
if (null_flag) { /* only count this, if null flag is set */
null_count ++;
i ++;
}
}
}
Vect_close (&in_vect_map);
fprintf (lp,"\n");
if ( background ) {
fprintf (lp,"Distribution of categories under %lu points (%lu in region) and in input map:\n",i,no_sites);
} else {
fprintf (lp,"Distribution of categories under %lu points (%lu in region):\n",i,no_sites);
}
/* determine starting value for total of sites analysed */
total = 0;
for ( j=0; j < cats; j ++) {
total = total + share_smp[j];
map_total = map_total + cat_count[j];
}
if (null_flag) { /* add NULL values to total */
total = total + null_count;
map_total = map_total + null_count_map;
}
if (uncat_flag) { /* add uncategorised cells to total */
total = total + nocat_count;
map_total = map_total + nocat_count_map;
}
/* Now display those values which the user has chosen */
if ( (background) && (gain) ) {
fprintf (lp,"Cat.\tPts.\t(%%)\tMap\t(%%)\tGain\tDescription\n");
}
if ( (background) && (!gain) ) {
fprintf (lp,"Cat.\tPts.\t(%%)\tMap\t(%%)\tDescription\n");
}
if ( (!background) && (gain) ) {
fprintf (lp,"Cat.\tPts.\t(%%)\tGain\tDescription\n");
}
if ( (!background) && (!gain) ) {
fprintf (lp,"Cat.\tPts.\t(%%)\tDescription\n");
}
for ( j = 0; j < cats; j ++) {
/* if skip_flag is not set: only show categories that have count > 0 */
if ((skip_flag == 1) || ((skip_flag == 0) && (share_smp[j] > 0))) {
if ( (background) && (gain) ) {
/* Kvamme's Gain = 1 - (%area/%sites) */
kvamme_gain = gstats_gain_K(((double) share_smp[j]*(100/total)),
((double) cat_count[j]*(100/map_total)));
fprintf (lp, "%lu\t%6lu\t%6.2f\t%8lu %6.2f\t%6.2f\t%s\n", j, share_smp[j], (float) share_smp[j]*(100/total),
cat_count[j], (float) cat_count[j]*(100/map_total),
kvamme_gain, cats_description[j]);
}
if ( (background) && (!gain) ) {
fprintf (lp, "%lu\t%6lu\t%6.2f\t%8lu %6.2f\t%s\n", j, share_smp[j], (float) share_smp[j]*(100/total),
cat_count[j], (float) cat_count[j]*(100/map_total),
cats_description[j]);
}
if ( (!background) && (gain) ) {
kvamme_gain = 1-( (float) cat_count[j]*(100/map_total) / (float) share_smp[j]*(100/total) );
fprintf (lp, "%lu\t%6lu\t%6.2f\t%6.2f\t%s\n", j, share_smp[j], (float) share_smp[j]*(100/total),
kvamme_gain, cats_description[j]);
}
if ( (!background) && (!gain) ) {
fprintf (lp, "%lu\t%6lu\t%6.2f\t%s\n", j, share_smp[j], (float) share_smp[j]*(100/total),
cats_description[j]);
}
}
}
if (null_flag) {
if ( background ) {
fprintf (lp,"NULL\t%6lu\t%6.2f\t%8lu %6.2f\n",null_count, (float) null_count * 100 / total
,null_count_map, (float) null_count_map * 100 / map_total);
} else {
fprintf (lp,"NULL\t%6lu\t%6.2f\n",null_count, (float) null_count * 100 / total);
}
}
if (uncat_flag) {
if ( background ) {
fprintf (lp,"NOCAT\t%6lu\t%6.2f\t%8lu %6.2f\n",nocat_count, (float) nocat_count * 100 / total
,nocat_count_map, (float) nocat_count_map * 100 / map_total);
} else {
fprintf (lp,"NOCAT\t%6lu\t%6.2f\n",nocat_count, (float) nocat_count * 100 / total);
}
}
if ( background) {
fprintf (lp,"TOTAL\t%6lu\t%6.2f\t%8lu %6.2f\n",(long) total, (float) 100, (long) map_total, (float) 100);
} else {
fprintf (lp,"TOTAL\t%6lu\t%6.2f\n",(long) total, (float) 100);
}
/* close cache and sites file; free buffers. */
GT_RC_close (cache);
G_free (cellbuf);
G_free (cache);
}
int main(int argc, char *argv[])
{
FILE *in_fp;
int out_fd;
char *infile, *outmap;
int xcol, ycol, zcol, max_col, percent;
int do_zfilter;
int method = -1;
int bin_n, bin_min, bin_max, bin_sum, bin_sumsq, bin_index;
double zrange_min, zrange_max, d_tmp;
char *fs; /* field delim */
off_t filesize;
int linesize;
long estimated_lines;
int from_stdin;
int can_seek;
RASTER_MAP_TYPE rtype;
struct History history;
char title[64];
void *n_array, *min_array, *max_array, *sum_array, *sumsq_array,
*index_array;
void *raster_row, *ptr;
struct Cell_head region;
int rows, cols; /* scan box size */
int row, col; /* counters */
int pass, npasses;
unsigned long line;
char buff[BUFFSIZE];
double x, y, z;
char **tokens;
int ntokens; /* number of tokens */
double pass_north, pass_south;
int arr_row, arr_col;
unsigned long count, count_total;
double min = 0.0 / 0.0; /* init as nan */
double max = 0.0 / 0.0; /* init as nan */
double zscale = 1.0;
size_t offset, n_offset;
int n = 0;
double sum = 0.;
double sumsq = 0.;
double variance, mean, skew, sumdev;
int pth = 0;
double trim = 0.0;
int j, k;
int head_id, node_id;
int r_low, r_up;
struct GModule *module;
struct Option *input_opt, *output_opt, *delim_opt, *percent_opt,
*type_opt;
struct Option *method_opt, *xcol_opt, *ycol_opt, *zcol_opt, *zrange_opt,
*zscale_opt;
struct Option *trim_opt, *pth_opt;
struct Flag *scan_flag, *shell_style, *skipline;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("raster, import, LIDAR");
module->description =
_("Create a raster map from an assemblage of many coordinates using univariate statistics.");
input_opt = G_define_standard_option(G_OPT_F_INPUT);
input_opt->description =
_("ASCII file containing input data (or \"-\" to read from stdin)");
output_opt = G_define_standard_option(G_OPT_R_OUTPUT);
method_opt = G_define_option();
method_opt->key = "method";
method_opt->type = TYPE_STRING;
method_opt->required = NO;
method_opt->description = _("Statistic to use for raster values");
method_opt->options =
"n,min,max,range,sum,mean,stddev,variance,coeff_var,median,percentile,skewness,trimmean";
method_opt->answer = "mean";
method_opt->guisection = _("Statistic");
type_opt = G_define_option();
type_opt->key = "type";
type_opt->type = TYPE_STRING;
type_opt->required = NO;
type_opt->options = "CELL,FCELL,DCELL";
type_opt->answer = "FCELL";
type_opt->description = _("Storage type for resultant raster map");
delim_opt = G_define_standard_option(G_OPT_F_SEP);
delim_opt->guisection = _("Input");
xcol_opt = G_define_option();
xcol_opt->key = "x";
xcol_opt->type = TYPE_INTEGER;
xcol_opt->required = NO;
xcol_opt->answer = "1";
xcol_opt->description =
_("Column number of x coordinates in input file (first column is 1)");
xcol_opt->guisection = _("Input");
ycol_opt = G_define_option();
ycol_opt->key = "y";
ycol_opt->type = TYPE_INTEGER;
ycol_opt->required = NO;
ycol_opt->answer = "2";
ycol_opt->description = _("Column number of y coordinates in input file");
ycol_opt->guisection = _("Input");
zcol_opt = G_define_option();
zcol_opt->key = "z";
zcol_opt->type = TYPE_INTEGER;
zcol_opt->required = NO;
zcol_opt->answer = "3";
zcol_opt->description = _("Column number of data values in input file");
zcol_opt->guisection = _("Input");
zrange_opt = G_define_option();
zrange_opt->key = "zrange";
zrange_opt->type = TYPE_DOUBLE;
zrange_opt->required = NO;
zrange_opt->key_desc = "min,max";
zrange_opt->description = _("Filter range for z data (min,max)");
zscale_opt = G_define_option();
zscale_opt->key = "zscale";
zscale_opt->type = TYPE_DOUBLE;
zscale_opt->required = NO;
zscale_opt->answer = "1.0";
zscale_opt->description = _("Scale to apply to z data");
percent_opt = G_define_option();
percent_opt->key = "percent";
percent_opt->type = TYPE_INTEGER;
percent_opt->required = NO;
percent_opt->answer = "100";
percent_opt->options = "1-100";
percent_opt->description = _("Percent of map to keep in memory");
pth_opt = G_define_option();
pth_opt->key = "pth";
pth_opt->type = TYPE_INTEGER;
pth_opt->required = NO;
pth_opt->options = "1-100";
pth_opt->description = _("pth percentile of the values");
pth_opt->guisection = _("Statistic");
trim_opt = G_define_option();
trim_opt->key = "trim";
trim_opt->type = TYPE_DOUBLE;
trim_opt->required = NO;
trim_opt->options = "0-50";
trim_opt->description =
_("Discard <trim> percent of the smallest and <trim> percent of the largest observations");
trim_opt->guisection = _("Statistic");
scan_flag = G_define_flag();
scan_flag->key = 's';
scan_flag->description = _("Scan data file for extent then exit");
shell_style = G_define_flag();
shell_style->key = 'g';
shell_style->description =
_("In scan mode, print using shell script style");
skipline = G_define_flag();
skipline->key = 'i';
skipline->description = _("Ignore broken lines");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* parse input values */
infile = input_opt->answer;
outmap = output_opt->answer;
if (shell_style->answer && !scan_flag->answer) {
scan_flag->answer = 1;
}
fs = delim_opt->answer;
if (strcmp(fs, "\\t") == 0)
fs = "\t";
if (strcmp(fs, "tab") == 0)
fs = "\t";
if (strcmp(fs, "space") == 0)
fs = " ";
xcol = atoi(xcol_opt->answer);
ycol = atoi(ycol_opt->answer);
zcol = atoi(zcol_opt->answer);
if ((xcol < 0) || (ycol < 0) || (zcol < 0))
G_fatal_error(_("Please specify a reasonable column number."));
max_col = (xcol > ycol) ? xcol : ycol;
max_col = (zcol > max_col) ? zcol : max_col;
percent = atoi(percent_opt->answer);
zscale = atof(zscale_opt->answer);
/* parse zrange */
do_zfilter = FALSE;
if (zrange_opt->answer != NULL) {
if (zrange_opt->answers[0] == NULL)
G_fatal_error(_("Invalid zrange"));
sscanf(zrange_opt->answers[0], "%lf", &zrange_min);
sscanf(zrange_opt->answers[1], "%lf", &zrange_max);
do_zfilter = TRUE;
if (zrange_min > zrange_max) {
d_tmp = zrange_max;
zrange_max = zrange_min;
zrange_min = d_tmp;
}
}
/* figure out what maps we need in memory */
/* n n
min min
max max
range min max max - min
sum sum
mean sum n sum/n
stddev sum sumsq n sqrt((sumsq - sum*sum/n)/n)
variance sum sumsq n (sumsq - sum*sum/n)/n
coeff_var sum sumsq n sqrt((sumsq - sum*sum/n)/n) / (sum/n)
median n array index to linked list
percentile n array index to linked list
skewness n array index to linked list
trimmean n array index to linked list
*/
bin_n = FALSE;
bin_min = FALSE;
bin_max = FALSE;
bin_sum = FALSE;
bin_sumsq = FALSE;
bin_index = FALSE;
if (strcmp(method_opt->answer, "n") == 0) {
method = METHOD_N;
bin_n = TRUE;
}
if (strcmp(method_opt->answer, "min") == 0) {
method = METHOD_MIN;
bin_min = TRUE;
}
if (strcmp(method_opt->answer, "max") == 0) {
method = METHOD_MAX;
bin_max = TRUE;
}
if (strcmp(method_opt->answer, "range") == 0) {
method = METHOD_RANGE;
bin_min = TRUE;
bin_max = TRUE;
}
if (strcmp(method_opt->answer, "sum") == 0) {
method = METHOD_SUM;
bin_sum = TRUE;
}
if (strcmp(method_opt->answer, "mean") == 0) {
method = METHOD_MEAN;
bin_sum = TRUE;
bin_n = TRUE;
}
if (strcmp(method_opt->answer, "stddev") == 0) {
method = METHOD_STDDEV;
bin_sum = TRUE;
bin_sumsq = TRUE;
bin_n = TRUE;
}
if (strcmp(method_opt->answer, "variance") == 0) {
method = METHOD_VARIANCE;
bin_sum = TRUE;
bin_sumsq = TRUE;
bin_n = TRUE;
}
if (strcmp(method_opt->answer, "coeff_var") == 0) {
method = METHOD_COEFF_VAR;
bin_sum = TRUE;
bin_sumsq = TRUE;
bin_n = TRUE;
}
if (strcmp(method_opt->answer, "median") == 0) {
method = METHOD_MEDIAN;
bin_index = TRUE;
}
if (strcmp(method_opt->answer, "percentile") == 0) {
if (pth_opt->answer != NULL)
pth = atoi(pth_opt->answer);
else
G_fatal_error(_("Unable to calculate percentile without the pth option specified!"));
method = METHOD_PERCENTILE;
bin_index = TRUE;
}
if (strcmp(method_opt->answer, "skewness") == 0) {
method = METHOD_SKEWNESS;
bin_index = TRUE;
}
if (strcmp(method_opt->answer, "trimmean") == 0) {
if (trim_opt->answer != NULL)
trim = atof(trim_opt->answer) / 100.0;
else
G_fatal_error(_("Unable to calculate trimmed mean without the trim option specified!"));
method = METHOD_TRIMMEAN;
bin_index = TRUE;
}
if (strcmp("CELL", type_opt->answer) == 0)
rtype = CELL_TYPE;
else if (strcmp("DCELL", type_opt->answer) == 0)
rtype = DCELL_TYPE;
else
rtype = FCELL_TYPE;
if (method == METHOD_N)
rtype = CELL_TYPE;
G_get_window(®ion);
rows = (int)(region.rows * (percent / 100.0));
cols = region.cols;
G_debug(2, "region.n=%f region.s=%f region.ns_res=%f", region.north,
region.south, region.ns_res);
G_debug(2, "region.rows=%d [box_rows=%d] region.cols=%d", region.rows,
rows, region.cols);
npasses = (int)ceil(1.0 * region.rows / rows);
if (!scan_flag->answer) {
/* allocate memory (test for enough before we start) */
if (bin_n)
n_array = G_calloc(rows * (cols + 1), G_raster_size(CELL_TYPE));
if (bin_min)
min_array = G_calloc(rows * (cols + 1), G_raster_size(rtype));
if (bin_max)
max_array = G_calloc(rows * (cols + 1), G_raster_size(rtype));
if (bin_sum)
sum_array = G_calloc(rows * (cols + 1), G_raster_size(rtype));
if (bin_sumsq)
sumsq_array = G_calloc(rows * (cols + 1), G_raster_size(rtype));
if (bin_index)
index_array =
G_calloc(rows * (cols + 1), G_raster_size(CELL_TYPE));
/* and then free it again */
if (bin_n)
G_free(n_array);
if (bin_min)
G_free(min_array);
if (bin_max)
G_free(max_array);
if (bin_sum)
G_free(sum_array);
if (bin_sumsq)
G_free(sumsq_array);
if (bin_index)
G_free(index_array);
/** end memory test **/
}
/* open input file */
if (strcmp("-", infile) == 0) {
from_stdin = TRUE;
in_fp = stdin;
infile = G_store("stdin"); /* filename for history metadata */
}
else {
if ((in_fp = fopen(infile, "r")) == NULL)
G_fatal_error(_("Unable to open input file <%s>"), infile);
}
can_seek = fseek(in_fp, 0, SEEK_SET) == 0;
/* can't rewind() non-files */
if (!can_seek && npasses != 1) {
G_warning(_("If input is not from a file it is only possible to perform a single pass."));
npasses = 1;
}
if (scan_flag->answer) {
if (zrange_opt->answer)
G_warning(_("zrange will not be taken into account during scan"));
scan_bounds(in_fp, xcol, ycol, zcol, fs, shell_style->answer,
skipline->answer, zscale);
if (!from_stdin)
fclose(in_fp);
exit(EXIT_SUCCESS);
}
/* open output map */
out_fd = G_open_raster_new(outmap, rtype);
if (out_fd < 0)
G_fatal_error(_("Unable to create raster map <%s>"), outmap);
if (can_seek) {
/* guess at number of lines in the file without actually reading it all in */
for (line = 0; line < 10; line++) { /* arbitrarily use 10th line for guess */
if (0 == G_getl2(buff, BUFFSIZE - 1, in_fp))
break;
linesize = strlen(buff) + 1;
}
fseek(in_fp, 0L, SEEK_END);
filesize = ftell(in_fp);
rewind(in_fp);
if (linesize < 6) /* min possible: "0,0,0\n" */
linesize = 6;
estimated_lines = filesize / linesize;
G_debug(2, "estimated number of lines in file: %ld", estimated_lines);
}
else
estimated_lines = -1;
/* allocate memory for a single row of output data */
raster_row = G_allocate_raster_buf(rtype);
G_message(_("Reading data ..."));
count_total = 0;
/* main binning loop(s) */
for (pass = 1; pass <= npasses; pass++) {
if (npasses > 1)
G_message(_("Pass #%d (of %d) ..."), pass, npasses);
if (can_seek)
rewind(in_fp);
/* figure out segmentation */
pass_north = region.north - (pass - 1) * rows * region.ns_res;
if (pass == npasses)
rows = region.rows - (pass - 1) * rows;
pass_south = pass_north - rows * region.ns_res;
G_debug(2, "pass=%d/%d pass_n=%f pass_s=%f rows=%d",
pass, npasses, pass_north, pass_south, rows);
if (bin_n) {
G_debug(2, "allocating n_array");
n_array = G_calloc(rows * (cols + 1), G_raster_size(CELL_TYPE));
blank_array(n_array, rows, cols, CELL_TYPE, 0);
}
if (bin_min) {
G_debug(2, "allocating min_array");
min_array = G_calloc(rows * (cols + 1), G_raster_size(rtype));
blank_array(min_array, rows, cols, rtype, -1); /* fill with NULLs */
}
if (bin_max) {
G_debug(2, "allocating max_array");
max_array = G_calloc(rows * (cols + 1), G_raster_size(rtype));
blank_array(max_array, rows, cols, rtype, -1); /* fill with NULLs */
}
if (bin_sum) {
G_debug(2, "allocating sum_array");
sum_array = G_calloc(rows * (cols + 1), G_raster_size(rtype));
blank_array(sum_array, rows, cols, rtype, 0);
}
if (bin_sumsq) {
G_debug(2, "allocating sumsq_array");
sumsq_array = G_calloc(rows * (cols + 1), G_raster_size(rtype));
blank_array(sumsq_array, rows, cols, rtype, 0);
}
if (bin_index) {
G_debug(2, "allocating index_array");
index_array =
G_calloc(rows * (cols + 1), G_raster_size(CELL_TYPE));
blank_array(index_array, rows, cols, CELL_TYPE, -1); /* fill with NULLs */
}
line = 0;
count = 0;
G_percent_reset();
while (0 != G_getl2(buff, BUFFSIZE - 1, in_fp)) {
line++;
if (line % 10000 == 0) { /* mod for speed */
if (!can_seek)
G_clicker();
else if (line < estimated_lines)
G_percent(line, estimated_lines, 3);
}
if ((buff[0] == '#') || (buff[0] == '\0')) {
continue; /* line is a comment or blank */
}
G_chop(buff); /* remove leading and trailing whitespace from the string. unneded?? */
tokens = G_tokenize(buff, fs);
ntokens = G_number_of_tokens(tokens);
if ((ntokens < 3) || (max_col > ntokens)) {
if (skipline->answer) {
G_warning(_("Not enough data columns. "
"Incorrect delimiter or column number? "
"Found the following character(s) in row %lu:\n[%s]"),
line, buff);
G_warning(_("Line ignored as requested"));
continue; /* line is garbage */
}
else {
G_fatal_error(_("Not enough data columns. "
"Incorrect delimiter or column number? "
"Found the following character(s) in row %lu:\n[%s]"),
line, buff);
}
}
/* too slow?
if ( G_projection() == PROJECTION_LL ) {
G_scan_easting( tokens[xcol-1], &x, region.proj);
G_scan_northing( tokens[ycol-1], &y, region.proj);
}
else {
*/
if (1 != sscanf(tokens[ycol - 1], "%lf", &y))
G_fatal_error(_("Bad y-coordinate line %lu column %d. <%s>"),
line, ycol, tokens[ycol - 1]);
if (y <= pass_south || y > pass_north) {
G_free_tokens(tokens);
continue;
}
if (1 != sscanf(tokens[xcol - 1], "%lf", &x))
G_fatal_error(_("Bad x-coordinate line %lu column %d. <%s>"),
line, xcol, tokens[xcol - 1]);
if (x < region.west || x > region.east) {
G_free_tokens(tokens);
continue;
}
if (1 != sscanf(tokens[zcol - 1], "%lf", &z))
G_fatal_error(_("Bad z-coordinate line %lu column %d. <%s>"),
line, zcol, tokens[zcol - 1]);
z = z * zscale;
if (zrange_opt->answer) {
if (z < zrange_min || z > zrange_max) {
G_free_tokens(tokens);
continue;
}
}
count++;
/* G_debug(5, "x: %f, y: %f, z: %f", x, y, z); */
G_free_tokens(tokens);
/* find the bin in the current array box */
arr_row = (int)((pass_north - y) / region.ns_res);
arr_col = (int)((x - region.west) / region.ew_res);
/* G_debug(5, "arr_row: %d arr_col: %d", arr_row, arr_col); */
/* The range should be [0,cols-1]. We use (int) to round down,
but if the point exactly on eastern edge arr_col will be /just/
on the max edge .0000000 and end up on the next row.
We could make above bounds check "if(x>=region.east) continue;"
But instead we go to all sorts of trouble so that not one single
data point is lost. GE is too small to catch them all.
We don't try to make y happy as percent segmenting will make some
points happen twice that way; so instead we use the y<= test above.
*/
if (arr_col >= cols) {
if (((x - region.west) / region.ew_res) - cols <
10 * GRASS_EPSILON)
arr_col--;
else { /* oh well, we tried. */
G_debug(3,
"skipping extraneous data point [%.3f], column %d of %d",
x, arr_col, cols);
continue;
}
}
if (bin_n)
update_n(n_array, cols, arr_row, arr_col);
if (bin_min)
update_min(min_array, cols, arr_row, arr_col, rtype, z);
if (bin_max)
update_max(max_array, cols, arr_row, arr_col, rtype, z);
if (bin_sum)
update_sum(sum_array, cols, arr_row, arr_col, rtype, z);
if (bin_sumsq)
update_sumsq(sumsq_array, cols, arr_row, arr_col, rtype, z);
if (bin_index) {
ptr = index_array;
ptr =
G_incr_void_ptr(ptr,
((arr_row * cols) +
arr_col) * G_raster_size(CELL_TYPE));
if (G_is_null_value(ptr, CELL_TYPE)) { /* first node */
head_id = new_node();
nodes[head_id].next = -1;
nodes[head_id].z = z;
G_set_raster_value_c(ptr, head_id, CELL_TYPE); /* store index to head */
}
else { /* head is already there */
head_id = G_get_raster_value_c(ptr, CELL_TYPE); /* get index to head */
head_id = add_node(head_id, z);
if (head_id != -1)
G_set_raster_value_c(ptr, head_id, CELL_TYPE); /* store index to head */
}
}
} /* while !EOF */
G_percent(1, 1, 1); /* flush */
G_debug(2, "pass %d finished, %lu coordinates in box", pass, count);
count_total += count;
/* calc stats and output */
G_message(_("Writing to map ..."));
for (row = 0; row < rows; row++) {
switch (method) {
case METHOD_N: /* n is a straight copy */
G_raster_cpy(raster_row,
n_array +
(row * cols * G_raster_size(CELL_TYPE)), cols,
CELL_TYPE);
break;
case METHOD_MIN:
G_raster_cpy(raster_row,
min_array + (row * cols * G_raster_size(rtype)),
cols, rtype);
break;
case METHOD_MAX:
G_raster_cpy(raster_row,
max_array + (row * cols * G_raster_size(rtype)),
cols, rtype);
break;
case METHOD_SUM:
G_raster_cpy(raster_row,
sum_array + (row * cols * G_raster_size(rtype)),
cols, rtype);
break;
case METHOD_RANGE: /* (max-min) */
ptr = raster_row;
for (col = 0; col < cols; col++) {
offset = (row * cols + col) * G_raster_size(rtype);
min = G_get_raster_value_d(min_array + offset, rtype);
max = G_get_raster_value_d(max_array + offset, rtype);
G_set_raster_value_d(ptr, max - min, rtype);
ptr = G_incr_void_ptr(ptr, G_raster_size(rtype));
}
break;
case METHOD_MEAN: /* (sum / n) */
ptr = raster_row;
for (col = 0; col < cols; col++) {
offset = (row * cols + col) * G_raster_size(rtype);
n_offset = (row * cols + col) * G_raster_size(CELL_TYPE);
n = G_get_raster_value_c(n_array + n_offset, CELL_TYPE);
sum = G_get_raster_value_d(sum_array + offset, rtype);
if (n == 0)
G_set_null_value(ptr, 1, rtype);
else
G_set_raster_value_d(ptr, (sum / n), rtype);
ptr = G_incr_void_ptr(ptr, G_raster_size(rtype));
}
break;
case METHOD_STDDEV: /* sqrt(variance) */
case METHOD_VARIANCE: /* (sumsq - sum*sum/n)/n */
case METHOD_COEFF_VAR: /* 100 * stdev / mean */
ptr = raster_row;
for (col = 0; col < cols; col++) {
offset = (row * cols + col) * G_raster_size(rtype);
n_offset = (row * cols + col) * G_raster_size(CELL_TYPE);
n = G_get_raster_value_c(n_array + n_offset, CELL_TYPE);
sum = G_get_raster_value_d(sum_array + offset, rtype);
sumsq = G_get_raster_value_d(sumsq_array + offset, rtype);
if (n == 0)
G_set_null_value(ptr, 1, rtype);
else {
variance = (sumsq - sum * sum / n) / n;
if (variance < GRASS_EPSILON)
variance = 0.0;
if (method == METHOD_STDDEV)
G_set_raster_value_d(ptr, sqrt(variance), rtype);
else if (method == METHOD_VARIANCE)
G_set_raster_value_d(ptr, variance, rtype);
else if (method == METHOD_COEFF_VAR)
G_set_raster_value_d(ptr,
100 * sqrt(variance) / (sum /
n),
rtype);
}
ptr = G_incr_void_ptr(ptr, G_raster_size(rtype));
}
break;
case METHOD_MEDIAN: /* median, if only one point in cell we will use that */
ptr = raster_row;
for (col = 0; col < cols; col++) {
n_offset = (row * cols + col) * G_raster_size(CELL_TYPE);
if (G_is_null_value(index_array + n_offset, CELL_TYPE)) /* no points in cell */
G_set_null_value(ptr, 1, rtype);
else { /* one or more points in cell */
head_id =
G_get_raster_value_c(index_array + n_offset,
CELL_TYPE);
node_id = head_id;
n = 0;
while (node_id != -1) { /* count number of points in cell */
n++;
node_id = nodes[node_id].next;
}
if (n == 1) /* only one point, use that */
G_set_raster_value_d(ptr, nodes[head_id].z,
rtype);
else if (n % 2 != 0) { /* odd number of points: median_i = (n + 1) / 2 */
n = (n + 1) / 2;
node_id = head_id;
for (j = 1; j < n; j++) /* get "median element" */
node_id = nodes[node_id].next;
G_set_raster_value_d(ptr, nodes[node_id].z,
rtype);
}
else { /* even number of points: median = (val_below + val_above) / 2 */
z = (n + 1) / 2.0;
n = floor(z);
node_id = head_id;
for (j = 1; j < n; j++) /* get element "below" */
node_id = nodes[node_id].next;
z = (nodes[node_id].z +
nodes[nodes[node_id].next].z) / 2;
G_set_raster_value_d(ptr, z, rtype);
}
}
ptr = G_incr_void_ptr(ptr, G_raster_size(rtype));
}
break;
case METHOD_PERCENTILE: /* rank = (pth*(n+1))/100; interpolate linearly */
ptr = raster_row;
for (col = 0; col < cols; col++) {
n_offset = (row * cols + col) * G_raster_size(CELL_TYPE);
if (G_is_null_value(index_array + n_offset, CELL_TYPE)) /* no points in cell */
G_set_null_value(ptr, 1, rtype);
else {
head_id =
G_get_raster_value_c(index_array + n_offset,
CELL_TYPE);
node_id = head_id;
n = 0;
while (node_id != -1) { /* count number of points in cell */
n++;
node_id = nodes[node_id].next;
}
z = (pth * (n + 1)) / 100.0;
r_low = floor(z); /* lower rank */
if (r_low < 1)
r_low = 1;
else if (r_low > n)
r_low = n;
r_up = ceil(z); /* upper rank */
if (r_up > n)
r_up = n;
node_id = head_id;
for (j = 1; j < r_low; j++) /* search lower value */
node_id = nodes[node_id].next;
z = nodes[node_id].z; /* save lower value */
node_id = head_id;
for (j = 1; j < r_up; j++) /* search upper value */
node_id = nodes[node_id].next;
z = (z + nodes[node_id].z) / 2;
G_set_raster_value_d(ptr, z, rtype);
}
ptr = G_incr_void_ptr(ptr, G_raster_size(rtype));
}
break;
case METHOD_SKEWNESS: /* skewness = sum(xi-mean)^3/(N-1)*s^3 */
ptr = raster_row;
for (col = 0; col < cols; col++) {
n_offset = (row * cols + col) * G_raster_size(CELL_TYPE);
if (G_is_null_value(index_array + n_offset, CELL_TYPE)) /* no points in cell */
G_set_null_value(ptr, 1, rtype);
else {
head_id =
G_get_raster_value_c(index_array + n_offset,
CELL_TYPE);
node_id = head_id;
n = 0; /* count */
sum = 0.0; /* sum */
sumsq = 0.0; /* sum of squares */
sumdev = 0.0; /* sum of (xi - mean)^3 */
skew = 0.0; /* skewness */
while (node_id != -1) {
z = nodes[node_id].z;
n++;
sum += z;
sumsq += (z * z);
node_id = nodes[node_id].next;
}
if (n > 1) { /* if n == 1, skew is "0.0" */
mean = sum / n;
node_id = head_id;
while (node_id != -1) {
z = nodes[node_id].z;
sumdev += pow((z - mean), 3);
node_id = nodes[node_id].next;
}
variance = (sumsq - sum * sum / n) / n;
if (variance < GRASS_EPSILON)
skew = 0.0;
else
skew =
sumdev / ((n - 1) *
pow(sqrt(variance), 3));
}
G_set_raster_value_d(ptr, skew, rtype);
}
ptr = G_incr_void_ptr(ptr, G_raster_size(rtype));
}
break;
case METHOD_TRIMMEAN:
ptr = raster_row;
for (col = 0; col < cols; col++) {
n_offset = (row * cols + col) * G_raster_size(CELL_TYPE);
if (G_is_null_value(index_array + n_offset, CELL_TYPE)) /* no points in cell */
G_set_null_value(ptr, 1, rtype);
else {
head_id =
G_get_raster_value_c(index_array + n_offset,
CELL_TYPE);
node_id = head_id;
n = 0;
while (node_id != -1) { /* count number of points in cell */
n++;
node_id = nodes[node_id].next;
}
if (1 == n)
mean = nodes[head_id].z;
else {
k = floor(trim * n + 0.5); /* number of ranks to discard on each tail */
if (k > 0 && (n - 2 * k) > 0) { /* enough elements to discard */
node_id = head_id;
for (j = 0; j < k; j++) /* move to first rank to consider */
node_id = nodes[node_id].next;
j = k + 1;
k = n - k;
n = 0;
sum = 0.0;
while (j <= k) { /* get values in interval */
n++;
sum += nodes[node_id].z;
node_id = nodes[node_id].next;
j++;
}
}
else {
node_id = head_id;
n = 0;
sum = 0.0;
while (node_id != -1) {
n++;
sum += nodes[node_id].z;
node_id = nodes[node_id].next;
}
}
mean = sum / n;
}
G_set_raster_value_d(ptr, mean, rtype);
}
ptr = G_incr_void_ptr(ptr, G_raster_size(rtype));
}
break;
default:
G_fatal_error("?");
}
/* write out line of raster data */
if (1 != G_put_raster_row(out_fd, raster_row, rtype)) {
G_close_cell(out_fd);
G_fatal_error(_("Writing map, row %d"),
((pass - 1) * rows) + row);
}
}
/* free memory */
if (bin_n)
G_free(n_array);
if (bin_min)
G_free(min_array);
if (bin_max)
G_free(max_array);
if (bin_sum)
G_free(sum_array);
if (bin_sumsq)
G_free(sumsq_array);
if (bin_index) {
G_free(index_array);
G_free(nodes);
num_nodes = 0;
max_nodes = 0;
nodes = NULL;
}
} /* passes loop */
G_percent(1, 1, 1); /* flush */
G_free(raster_row);
/* close input file */
if (!from_stdin)
fclose(in_fp);
/* close raster file & write history */
G_close_cell(out_fd);
sprintf(title, "Raw x,y,z data binned into a raster grid by cell %s",
method_opt->answer);
G_put_cell_title(outmap, title);
G_short_history(outmap, "raster", &history);
G_command_history(&history);
strncpy(history.datsrc_1, infile, RECORD_LEN);
history.datsrc_1[RECORD_LEN - 1] = '\0'; /* strncpy() doesn't null terminate if maxfill */
G_write_history(outmap, &history);
sprintf(buff, _("%lu points found in region."), count_total);
G_done_msg(buff);
G_debug(1, "Processed %lu lines.", line);
exit(EXIT_SUCCESS);
}
int make_new_cell_layer(void)
{
struct History hist;
void *rast;
int cellfd;
int tmpfd;
int row;
/* open the new raster map to contain the edited version of
the original cell layer. open our temporary file for read
and copy its contents to the layer */
G_set_window(&real_window);
cellfd = G_open_raster_new(new_name, map_type);
tmpfd = open(tempfile, 0);
lseek(tmpfd, 0L, 0);
rast = G_allocate_raster_buf(map_type);
fprintf(stderr, "\n +-------------------------------------------+\n");
fprintf(stderr, " | Saving new cell layer |\n");
fprintf(stderr, " +---------------------------------------");
for (row = 0; row < real_nrows; row++) {
if (read(tmpfd, rast, real_ncols * cellsize) !=
(real_ncols * cellsize))
error(1, "error writing raster map during copy");
G_put_raster_row(cellfd, rast, map_type);
G_percent(row, real_nrows, 5);
}
G_percent(100, 100, 5);
fprintf(stderr, "\n");
close(tmpfd);
G_close_cell(cellfd);
unlink(tempfile);
/* create and write cat, colr, quant, and hist support files
for the newly created layer */
if (colr_ok) {
G_write_colors(new_name, user_mapset, &colr);
G_free_colors(&colr);
colr_ok = 0;
}
if (cats_ok) {
cats.num = G_number_of_cats(new_name, user_mapset);
G_write_cats(new_name, &cats);
G_free_cats(&cats);
cats_ok = 0;
}
if (quant_ok) {
G_write_quant(new_name, G_mapset(), &quant);
G_quant_free(&quant);
cats_ok = 0;
}
/* construct some history information */
sprintf(hist.mapid, "%s", G_date());
sprintf(hist.title, "%s", new_name);
sprintf(hist.mapset, "%s", user_mapset);
sprintf(hist.creator, "%s", G_whoami());
sprintf(hist.maptype, "cell");
sprintf(hist.edhist[0],
"Generated by d.rast.edit from original raster map");
sprintf(hist.edhist[1], " %s in mapset %s ", orig_name, orig_mapset);
hist.edlinecnt = 2;
/* write history */
if (G_write_history(new_name, &hist) == -1)
error(0, "could not write history");
return 0;
}
void* raster2array(const char* name, struct Cell_head* header, int* rows,
int* cols, RASTER_MAP_TYPE out_type) {
// Open the raster map and load the dem
// for simplicity sake, the dem will be an array of
// doubles, converted from any possible GRASS CELL type.
char* mapset = G_find_cell2(name, "");
if (mapset == NULL)
G_fatal_error("Raster map <%s> not found", name);
// Find out the cell type of the DEM
RASTER_MAP_TYPE type = G_raster_map_type(name, mapset);
// Get a file descriptor for the DEM raster map
int infd;
if ((infd = G_open_cell_old(name, mapset)) < 0)
G_fatal_error("Unable to open raster map <%s>", name);
// Get header info for the DEM raster map
struct Cell_head cellhd;
if (G_get_cellhd(name, mapset, &cellhd) < 0)
G_fatal_error("Unable to open raster map <%s>", name);
// Create a GRASS buffer for the DEM raster
void* inrast = G_allocate_raster_buf(type);
// Get the max rows and max cols from the window information, since the
// header gives the values for the full raster
const int maxr = G_window_rows();
const int maxc = G_window_cols();
// Read in the raster line by line, copying it into the double array
// rast for return.
void* rast;
switch (out_type) {
case CELL_TYPE:
rast = (int*) calloc(maxr * maxc, sizeof(int));
break;
case FCELL_TYPE:
rast = (float*) calloc(maxr * maxc, sizeof(float));
break;
case DCELL_TYPE:
rast = (double*) calloc(maxr * maxc, sizeof(double));
break;
}
if (rast == NULL) {
G_fatal_error("Unable to allocate memory for raster map <%s>", name);
}
int row, col;
for (row = 0; row < maxr; ++row) {
if (G_get_raster_row(infd, inrast, row, type) < 0)
G_fatal_error("Unable to read raster map <%s> row %d", name, row);
for (col = 0; col < maxc; ++col) {
int index = col + row * maxc;
if (out_type == CELL_TYPE) {
switch (type) {
case CELL_TYPE:
((int*) rast)[index] = ((int *) inrast)[col];
break;
case FCELL_TYPE:
((int*) rast)[index] = (int) ((float *) inrast)[col];
break;
case DCELL_TYPE:
((int*) rast)[index] = (int) ((double *) inrast)[col];
break;
default:
G_fatal_error("Unknown cell type");
break;
}
}
if (out_type == FCELL_TYPE) {
switch (type) {
case CELL_TYPE:
((float*) rast)[index] = (float) ((int *) inrast)[col];
break;
case FCELL_TYPE:
((float*) rast)[index] = ((float *) inrast)[col];
break;
case DCELL_TYPE:
((float*) rast)[index] = (float) ((double *) inrast)[col];
break;
default:
G_fatal_error("Unknown cell type");
break;
}
}
if (out_type == DCELL_TYPE) {
switch (type) {
case CELL_TYPE:
((double*) rast)[index] = (double) ((int *) inrast)[col];
break;
case FCELL_TYPE:
((double*) rast)[index] = (double) ((float *) inrast)[col];
break;
case DCELL_TYPE:
((double*) rast)[index] = ((double *) inrast)[col];
break;
default:
G_fatal_error("Unknown cell type");
break;
}
}
}
}
// Return cellhd, maxr, and maxc by pointer
if (header != NULL)
*header = cellhd;
if (rows != NULL)
*rows = maxr;
if (cols != NULL)
*cols = maxc;
return rast;
}
int main(int argc, char *argv[])
{
struct Cell_head cellhd;
struct Range range;
char *name; /* input raster name */
char *result; /* output raster name */
char *mapset; /* mapset name */
DCELL *inrast; /* input buffer */
DCELL *outrast; /* output buffer */
int row,col;
int infd, outfd; /* file descriptor */
int verbose;
double *weights; /* array of weights */
DCELL **D_rows;
DCELL *tmp;
int nrows;
int ncols;
double min, max; /* raster map range */
RASTER_MAP_TYPE data_type; /* type of the map */
void *values; /* neighborhood values */
int n,i; /* number of neighborhood cells */
int size; /* matrix size */
double ssigma; /* sigma of the spatial part */
double csigma; /* sigma of the color part */
char title[1024]; /* map title */
struct GModule *module; /* GRASS module for parsing arguments */
struct
{
struct Option *input, *output;
struct Option *sigma_s, *sigma_c, *size;
struct Option *title;
} parm;
struct
{
struct Flag *quiet;
struct Flag *print_sigmas;
} flag;
/* initialize GIS environment */
G_gisinit(argv[0]); /* reads grass env,
stores program name to
G_program_name
*/
/* initialize module */
module = G_define_module();
module->description = ("Gaussian filter for raster maps.");
/* Define the different options */
parm.input = G_define_option() ;
parm.input->key = "input";
parm.input->type = TYPE_STRING;
parm.input->required = YES;
parm.input->description= ("Name of an input layer" );
parm.output = G_define_option() ;
parm.output->key = "output";
parm.output->type = TYPE_STRING;
parm.output->required = YES;
parm.output->description= ("Name of an output layer");
parm.sigma_s = G_define_option() ;
parm.sigma_s->key = "ssigma";
parm.sigma_s->type = TYPE_DOUBLE;
parm.sigma_s->required = NO;
parm.sigma_s->description= ("Sigma for space part of the filter\n\t(default: 0.465*((size-1)/2)");
parm.sigma_c = G_define_option() ;
parm.sigma_c->key = "csigma";
parm.sigma_c->type = TYPE_DOUBLE;
parm.sigma_c->required = NO;
parm.sigma_c->description= ("Sigma for color part of the filter\n(default: 0.465*((color_range)/2)");
parm.size = G_define_option() ;
parm.size->key = "size";
parm.size->type = TYPE_INTEGER;
parm.size->required = YES;
parm.size->description= ("Size of the matrix (odd number)");
flag.print_sigmas = G_define_flag() ;
flag.print_sigmas->key = 's' ;
flag.print_sigmas->description = "Print calculated values for sigmas" ;
flag.quiet = G_define_flag() ;
flag.quiet->key = 'q' ;
flag.quiet->description = "Quiet" ;
/* options and flags pareser */
if (G_parser(argc, argv))
exit (-1);
/* stores options and flags to variables */
name = parm.input->answer;
result = parm.output->answer;
verbose = (! flag.quiet->answer);
sscanf(parm.size->answer, "%d", &size);
if (!parm.sigma_s->answer)
ssigma = 0.465*((size-1)/2);
else
sscanf(parm.sigma_s->answer, "%lf", &ssigma);
/* controlling the input values */
if (size%2 == 0)
G_fatal_error("Size <%d> is not odd number", size);
/* returs NULL if the map was not found in any mapset,
* mapset name otherwise*/
mapset = G_find_cell2 (name, "");
if (mapset == NULL)
G_fatal_error ("cell file [%s] not found", name);
/* color sigma next */
if (!parm.sigma_c->answer) {
if (G_read_range(name, mapset, &range) < 0)
G_fatal_error("Could not read the raster map range");
/* for raster maps with range from 0-255 the result
* should be around 60
*/
min = (double)range.min;
max = (double)range.max;
csigma = 0.456*(max - min)/2;
}
else
sscanf(parm.sigma_c->answer, "%lf", &csigma);
/* print if appropriate */
if (flag.print_sigmas->answer)
printf("Space sigma: %f\nColor sigma: %f\n", ssigma, csigma);
if (G_legal_filename (result) < 0)
G_fatal_error ("[%s] is an illegal name", result);
/* count weights */
weights = (double *)malloc(size * size * sizeof(double));
/* stores values of gauss. bell into 'weigts'*/
count_weights(weights, size, ssigma);
/* determine the inputmap type (CELL/FCELL/DCELL) */
data_type = G_raster_map_type(name, mapset);
/* G_open_cell_old - returns file destriptor (>0) */
if ( (infd = G_open_cell_old (name, mapset)) < 0)
G_fatal_error ("Cannot open cell file [%s]", name);
/* controlling, if we can open input raster */
if (G_get_cellhd (name, mapset, &cellhd) < 0)
G_fatal_error ("Cannot read file header of [%s]", name);
/* Allocate input buffer */
inrast = G_allocate_raster_buf(data_type);
/* Allocate output buffer, use input map data_type */
nrows = G_window_rows();
ncols = G_window_cols();
outrast = G_allocate_d_raster_buf();
/* Allocate values buffers */
values = (DCELL *) malloc(size * size * sizeof(DCELL));
/* allocating memory for rows */
D_rows = (DCELL **)malloc(size * sizeof(DCELL));
for (i = 0; i < size; i++) {
D_rows[i] = G_allocate_raster_buf(DCELL_TYPE);
}
if (values == NULL)
G_fatal_error("Cannot allocate memory");
/* controlling, if we can write the raster */
if ( (outfd = G_open_raster_new (result, data_type)) < 0)
G_fatal_error ("Could not open <%s>",result);
/* write first rows as NULL values */
for (row = 0; row < size/2; row++) {
G_set_d_null_value(outrast, ncols);
if (G_put_d_raster_row (outfd, outrast) < 0)
G_fatal_error ("Cannot write to <%s>",result);
}
/* allocate first size/2 rows */
for (row = 0; row < size; row++)
if (G_get_d_raster_row(infd, D_rows[row], row) < 0)
G_fatal_error ("Could not open <%s>",result);
/****************************************************************/
/* for each row inside the region */
for ( row = size/2; row < nrows - size/2; row++) {
if (verbose)
G_percent (row, nrows, 2);
/* allocate new last row */
G_get_d_raster_row(infd, D_rows[size-1], row+(size/2));
/*process the data */
for (col=0; col < ncols; col++){
/* skip the outside columns */
if ( (col - size/2) < 0 || ncols <= (col + size/2)) {
G_set_d_null_value(outrast, 1);
}
/* work only with columns, which are inside */
else {
/* store values of the matrix into arry 'values', 'n' is
* number of elements of the matrix */
n = D_gather(infd, values, D_rows, col, row,size);
((DCELL *)outrast)[col] = D_bilateral(values, ssigma, csigma, size, weights);
}
} /* for each column */
/* write raster row to output raster file */
G_put_d_raster_row (outfd, outrast);
/* switch rows */
tmp = D_rows[0];
for (i = 0; i < size; i++){
D_rows[i] = D_rows[i + 1];
}
D_rows[size-1] = tmp;
} /* for each row */
/* write last rows as NULL values */
for (i = 0; i < size/2; i++) {
G_set_d_null_value(outrast, ncols);
G_put_d_raster_row (outfd, outrast);
}
/* memory cleaning */
G_free(outrast);
G_free(inrast);
G_free(values);
for (i = 0; i < size; i++) {
G_free(D_rows[i]);
}
free((void *) D_rows);
/* closing rastr files */
G_close_cell (infd);
G_close_cell (outfd);
/* set the map title */
sprintf(title, "Bilateral filter of %s with %dx%d matrix: ssigma %.3f, csigma %.3f", name, size, size, ssigma, csigma );
G_put_cell_title (result, title );
return 0;
}
