int gaussurf(char *out, /* Name of raster maps to be opened. */
double mean, double sigma /* Distribution parameters. */
)
{
int nrows, ncols; /* Number of cell rows and columns */
DCELL *row_out; /* Buffer just large enough to hold one */
/* row of the raster map layer. */
int fd_out; /* File descriptor - used to identify */
/* open raster maps. */
struct History history; /* cmd line history metadata */
int row_count, col_count;
/****** INITIALISE RANDOM NUMBER GENERATOR ******/
G_math_rand(-1 * getpid());
/****** OPEN CELL FILES AND GET CELL DETAILS ******/
fd_out = G_open_raster_new(out, DCELL_TYPE);
nrows = G_window_rows();
ncols = G_window_cols();
row_out = G_allocate_d_raster_buf();
/****** PASS THROUGH EACH CELL ASSIGNING RANDOM VALUE ******/
for (row_count = 0; row_count < nrows; row_count++) {
for (col_count = 0; col_count < ncols; col_count++)
*(row_out + col_count) =
(DCELL) (G_math_rand_gauss(2742, sigma) + mean);
/* Write contents row by row */
G_put_d_raster_row(fd_out, (DCELL *) row_out);
}
/****** CLOSE THE CELL FILE ******/
G_close_cell(fd_out);
G_short_history(out, "raster", &history);
G_command_history(&history);
G_write_history(out, &history);
return 0;
}
int
process(char *name, char *mapset, int change_null, RASTER_MAP_TYPE map_type)
{
struct Colors colr;
struct History hist;
struct Categories cats;
struct Quant quant;
int colr_ok;
int hist_ok;
int cats_ok;
int quant_ok;
G_suppress_warnings(1);
colr_ok = G_read_colors(name, mapset, &colr) > 0;
hist_ok = G_read_history(name, mapset, &hist) >= 0;
cats_ok = G_read_raster_cats(name, mapset, &cats) >= 0;
if (map_type != CELL_TYPE) {
G_quant_init(&quant);
quant_ok = G_read_quant(name, mapset, &quant);
G_suppress_warnings(0);
}
if (doit(name, mapset, change_null, map_type))
return 1;
if (colr_ok) {
G_write_colors(name, mapset, &colr);
G_free_colors(&colr);
}
if (hist_ok)
G_write_history(name, &hist);
if (cats_ok) {
cats.num = G_number_of_cats(name, mapset);
G_write_raster_cats(name, &cats);
G_free_cats(&cats);
}
if (map_type != CELL_TYPE && quant_ok)
G_write_quant(name, mapset, &quant);
return 0;
}
static int close_new(int fd, int ok)
{
struct fileinfo *fcb = &G__.fileinfo[fd];
int stat;
struct Categories cats;
struct History hist;
char path[GPATH_MAX];
CELL cell_min, cell_max;
int row, i, open_mode;
if (ok) {
switch (fcb->open_mode) {
case OPEN_NEW_COMPRESSED:
G_debug(1, "close %s compressed", fcb->name);
break;
case OPEN_NEW_UNCOMPRESSED:
G_debug(1, "close %s uncompressed", fcb->name);
break;
case OPEN_NEW_RANDOM:
G_debug(1, "close %s random", fcb->name);
break;
}
if (fcb->open_mode != OPEN_NEW_RANDOM &&
fcb->cur_row < fcb->cellhd.rows) {
G_zero_raster_buf(fcb->data, fcb->map_type);
for (row = fcb->cur_row; row < fcb->cellhd.rows; row++)
G_put_raster_row(fd, fcb->data, fcb->map_type);
G_free(fcb->data);
fcb->data = NULL;
}
/* create path : full null file name */
G__make_mapset_element_misc("cell_misc", fcb->name);
G__file_name_misc(path, "cell_misc", NULL_FILE, fcb->name,
G_mapset());
remove(path);
if (fcb->null_cur_row > 0) {
/* if temporary NULL file exists, write it into cell_misc/name/null */
int null_fd;
null_fd = G__open_null_write(fd);
if (null_fd <= 0)
return -1;
if (null_fd < 1)
return -1;
/* first finish writing null file */
/* write out the rows stored in memory */
for (row = fcb->min_null_row; row < fcb->null_cur_row; row++)
G__write_null_bits(null_fd,
fcb->NULL_ROWS[row - fcb->min_null_row],
row, fcb->cellhd.cols, fd);
/* write missing rows */
if (fcb->open_mode != OPEN_NEW_RANDOM
&& fcb->null_cur_row < fcb->cellhd.rows) {
G__init_null_bits(fcb->null_work_buf, fcb->cellhd.cols);
for (row = fcb->null_cur_row; row < fcb->cellhd.rows; row++)
G__write_null_bits(null_fd, fcb->null_work_buf, row,
fcb->cellhd.cols, fd);
}
close(null_fd);
if (rename(fcb->null_temp_name, path)) {
G_warning(_("closecell: can't move %s\nto null file %s"),
fcb->null_temp_name, path);
stat = -1;
}
else {
remove(fcb->null_temp_name);
}
}
else {
remove(fcb->null_temp_name);
remove(path);
} /* null_cur_row > 0 */
if (fcb->open_mode == OPEN_NEW_COMPRESSED) { /* auto compression */
fcb->row_ptr[fcb->cellhd.rows] = lseek(fd, 0L, SEEK_CUR);
G__write_row_ptrs(fd);
}
if (fcb->map_type != CELL_TYPE) { /* floating point map */
int cell_fd;
if (G__write_fp_format(fd) != 0) {
G_warning(_("Error writing floating point format file for map %s"),
fcb->name);
stat = -1;
}
/* now write 0-length cell file */
G__make_mapset_element("cell");
cell_fd =
creat(G__file_name(path, "cell", fcb->name, fcb->mapset),
0666);
close(cell_fd);
strcpy(CELL_DIR, "fcell");
}
else {
/* remove fcell/name file */
G__file_name(path, "fcell", fcb->name, fcb->mapset);
remove(path);
/* remove cell_misc/name/f_format */
G__file_name_misc(path, "cell_misc", FORMAT_FILE, fcb->name,
fcb->mapset);
remove(path);
strcpy(CELL_DIR, "cell");
close(fd);
}
} /* ok */
/* NOW CLOSE THE FILE DESCRIPTOR */
close(fd);
/* remember open_mode */
open_mode = fcb->open_mode;
fcb->open_mode = -1;
if (fcb->data != NULL)
G_free(fcb->data);
if (fcb->null_temp_name != NULL) {
G_free(fcb->null_temp_name);
fcb->null_temp_name = NULL;
}
/* if the cell file was written to a temporary file
* move this temporary file into the cell file
* if the move fails, tell the user, but go ahead and create
* the support files
*/
stat = 1;
if (ok && (fcb->temp_name != NULL)) {
G__file_name(path, CELL_DIR, fcb->name, fcb->mapset);
remove(path);
if (rename(fcb->temp_name, path)) {
G_warning(_("closecell: can't move %s\nto cell file %s"),
fcb->temp_name, path);
stat = -1;
}
else {
remove(fcb->temp_name);
}
}
if (fcb->temp_name != NULL) {
G_free(fcb->temp_name);
}
if (ok) {
/* remove color table */
G_remove_colors(fcb->name, "");
/* create a history file */
G_short_history(fcb->name, "raster", &hist);
G_write_history(fcb->name, &hist);
/* write the range */
if (fcb->map_type == CELL_TYPE) {
G_write_range(fcb->name, &fcb->range);
G__remove_fp_range(fcb->name);
}
/*NOTE: int range for floating point maps is not written out */
else { /* if(fcb->map_type != CELL_TYPE) */
G_write_fp_range(fcb->name, &fcb->fp_range);
G_construct_default_range(&fcb->range);
/* this range will be used to add default rule to quant structure */
}
if (fcb->map_type != CELL_TYPE)
fcb->cellhd.format = -1;
else /* CELL map */
fcb->cellhd.format = fcb->nbytes - 1;
/* write header file */
G_put_cellhd(fcb->name, &fcb->cellhd);
/* if map is floating point write the quant rules, otherwise remove f_quant */
if (fcb->map_type != CELL_TYPE) {
/* DEFAULT RANGE QUANT
G_get_fp_range_min_max(&fcb->fp_range, &dcell_min, &dcell_max);
if(!G_is_d_null_value(&dcell_min) && !G_is_d_null_value(&dcell_max))
{
G_get_range_min_max(&fcb->range, &cell_min, &cell_max);
G_quant_add_rule(&fcb->quant, dcell_min, dcell_max,
cell_min, cell_max);
}
*/
G_quant_round(&fcb->quant);
if (G_write_quant(fcb->name, fcb->mapset, &fcb->quant) < 0)
G_warning(_("unable to write quant file!"));
}
else {
/* remove cell_misc/name/f_quant */
G__file_name_misc(path, "cell_misc", QUANT_FILE, fcb->name,
fcb->mapset);
remove(path);
}
/* create empty cats file */
G_get_range_min_max(&fcb->range, &cell_min, &cell_max);
if (G_is_c_null_value(&cell_max))
cell_max = 0;
G_init_cats(cell_max, (char *)NULL, &cats);
G_write_cats(fcb->name, &cats);
G_free_cats(&cats);
/* write the histogram */
/* only works for integer maps */
if ((fcb->map_type == CELL_TYPE)
&& (fcb->want_histogram)) {
G_write_histogram_cs(fcb->name, &fcb->statf);
G_free_cell_stats(&fcb->statf);
}
else {
G_remove_histogram(fcb->name);
}
} /* OK */
G_free(fcb->name);
G_free(fcb->mapset);
for (i = 0; i < NULL_ROWS_INMEM; i++)
G_free(fcb->NULL_ROWS[i]);
G_free(fcb->null_work_buf);
if (fcb->map_type != CELL_TYPE)
G_quant_free(&fcb->quant);
return stat;
}
int main(int argc, char *argv[])
{
char *terrainmap, *seedmap, *lakemap, *mapset;
int rows, cols, in_terran_fd, out_fd, lake_fd, row, col, pases, pass;
int lastcount, curcount, start_col = 0, start_row = 0;
double east, north, area = 0, volume = 0;
FCELL **in_terran, **out_water, water_level, max_depth = 0, min_depth = 0;
FCELL water_window[3][3];
struct Option *tmap_opt, *smap_opt, *wlvl_opt, *lake_opt, *sdxy_opt;
struct Flag *negative_flag, *overwrite_flag;
struct GModule *module;
struct Colors colr;
struct Cell_head window;
struct History history;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("raster, hydrology");
module->description = _("Fills lake at given point to given level.");
tmap_opt = G_define_option();
tmap_opt->key = "dem";
tmap_opt->key_desc = "name";
tmap_opt->description = _("Name of terrain raster map (DEM)");
tmap_opt->type = TYPE_STRING;
tmap_opt->gisprompt = "old,cell,raster";
tmap_opt->required = YES;
wlvl_opt = G_define_option();
wlvl_opt->key = "wl";
wlvl_opt->description = _("Water level");
wlvl_opt->type = TYPE_DOUBLE;
wlvl_opt->required = YES;
lake_opt = G_define_option();
lake_opt->key = "lake";
lake_opt->key_desc = "name";
lake_opt->description = _("Name for output raster map with lake");
lake_opt->type = TYPE_STRING;
lake_opt->gisprompt = "new,cell,raster";
lake_opt->required = NO;
sdxy_opt = G_define_option();
sdxy_opt->key = "xy";
sdxy_opt->description = _("Seed point coordinates");
sdxy_opt->type = TYPE_DOUBLE;
sdxy_opt->key_desc = "east,north";
sdxy_opt->required = NO;
sdxy_opt->multiple = NO;
smap_opt = G_define_option();
smap_opt->key = "seed";
smap_opt->key_desc = "name";
smap_opt->description =
_("Name of raster map with given starting point(s) (at least 1 cell > 0)");
smap_opt->type = TYPE_STRING;
smap_opt->gisprompt = "old,cell,raster";
smap_opt->required = NO;
negative_flag = G_define_flag();
negative_flag->key = 'n';
negative_flag->description =
_("Use negative depth values for lake raster map");
overwrite_flag = G_define_flag();
overwrite_flag->key = 'o';
overwrite_flag->description =
_("Overwrite seed map with result (lake) map");
if (G_parser(argc, argv)) /* Returns 0 if successful, non-zero otherwise */
exit(EXIT_FAILURE);
if (smap_opt->answer && sdxy_opt->answer)
G_fatal_error(_("Both seed map and coordinates cannot be specified"));
if (!smap_opt->answer && !sdxy_opt->answer)
G_fatal_error(_("Seed map or seed coordinates must be set!"));
if (sdxy_opt->answer && !lake_opt->answer)
G_fatal_error(_("Seed coordinates and output map lake= must be set!"));
if (lake_opt->answer && overwrite_flag->answer)
G_fatal_error(_("Both lake and overwrite cannot be specified"));
if (!lake_opt->answer && !overwrite_flag->answer)
G_fatal_error(_("Output lake map or overwrite flag must be set!"));
terrainmap = tmap_opt->answer;
seedmap = smap_opt->answer;
sscanf(wlvl_opt->answer, "%f", &water_level);
lakemap = lake_opt->answer;
/* If lakemap is set, write to it, else is set overwrite flag and we should write to seedmap. */
if (lakemap) {
lake_fd = G_open_raster_new(lakemap, 1);
if (lake_fd < 0)
G_fatal_error(_("Unable to create raster map <%s>"), lakemap);
}
rows = G_window_rows();
cols = G_window_cols();
/* If we use x,y as seed... */
if (sdxy_opt->answer) {
G_get_window(&window);
east = window.east;
north = window.north;
G_scan_easting(sdxy_opt->answers[0], &east, G_projection());
G_scan_northing(sdxy_opt->answers[1], &north, G_projection());
start_col = (int)G_easting_to_col(east, &window);
start_row = (int)G_northing_to_row(north, &window);
if (start_row < 0 || start_row > rows ||
start_col < 0 || start_col > cols)
G_fatal_error(_("Seed point outside the current region"));
}
/* Open terran map */
mapset = G_find_cell2(terrainmap, "");
if (mapset == NULL)
G_fatal_error(_("Raster map <%s> not found"), terrainmap);
in_terran_fd = G_open_cell_old(terrainmap, mapset);
if (in_terran_fd < 0)
G_fatal_error(_("Unable to open raster map <%s>"),
G_fully_qualified_name(terrainmap, mapset));
/* Open seed map */
if (smap_opt->answer) {
mapset = G_find_cell2(seedmap, "");
if (mapset == NULL)
G_fatal_error(_("Raster map <%s> not found"), seedmap);
out_fd = G_open_cell_old(seedmap, mapset);
if (out_fd < 0)
G_fatal_error(_("Unable to open raster map <%s>"),
G_fully_qualified_name(seedmap, mapset));
}
/* Pointers to rows. Row = ptr to 'col' size array. */
in_terran = (FCELL **) G_malloc(rows * sizeof(FCELL *));
out_water = (FCELL **) G_malloc(rows * sizeof(FCELL *));
if (in_terran == NULL || out_water == NULL)
G_fatal_error(_("G_malloc: out of memory"));
G_debug(1, "Loading maps...");
/* foo_rows[row] == array with data (2d array). */
for (row = 0; row < rows; row++) {
in_terran[row] = (FCELL *) G_malloc(cols * sizeof(FCELL));
out_water[row] = (FCELL *) G_calloc(cols, sizeof(FCELL));
/* In newly created space load data from file. */
if (G_get_f_raster_row(in_terran_fd, in_terran[row], row) != 1)
G_fatal_error(_("Unable to read raster map <%s> row %d"),
terrainmap, row);
if (smap_opt->answer)
if (G_get_f_raster_row(out_fd, out_water[row], row) != 1)
G_fatal_error(_("Unable to read raster map <%s> row %d"),
seedmap, row);
G_percent(row + 1, rows, 5);
}
/* Set seed point */
if (sdxy_opt->answer)
/* Check is water level higher than seed point */
if (in_terran[start_row][start_col] >= water_level)
G_fatal_error(_("Given water level at seed point is below earth surface. "
"Increase water level or move seed point."));
out_water[start_row][start_col] = 1;
/* Close seed map for reading. */
if (smap_opt->answer)
G_close_cell(out_fd);
/* Open output map for writing. */
if (lakemap) {
out_fd = lake_fd;
}
else {
out_fd = G_open_raster_new(seedmap, 1);
if (out_fd < 0)
G_fatal_error(_("Unable to create raster map <%s>"), seedmap);
}
/* More pases are renudant. Real pases count is controled by altered cell count. */
pases = (int)(rows * cols) / 2;
G_debug(1,
"Starting lake filling at level of %8.4f in %d passes. Percent done:",
water_level, pases);
lastcount = 0;
for (pass = 0; pass < pases; pass++) {
G_debug(3, "Pass: %d", pass);
curcount = 0;
/* Move from left upper corner to right lower corner. */
for (row = 0; row < rows; row++) {
for (col = 0; col < cols; col++) {
/* Loading water data into window. */
load_window_values(out_water, water_window, rows, cols, row,
col);
/* Cheking presence of water. */
if (is_near_water(water_window) == 1) {
if (in_terran[row][col] < water_level) {
out_water[row][col] =
water_level - in_terran[row][col];
curcount++;
}
else {
out_water[row][col] = 0; /* Cell is higher than water level -> NULL. */
}
}
}
}
if (curcount == lastcount)
break; /* We done. */
lastcount = curcount;
curcount = 0;
/* Move backwards - from lower right corner to upper left corner. */
for (row = rows - 1; row >= 0; row--) {
for (col = cols - 1; col >= 0; col--) {
load_window_values(out_water, water_window, rows, cols, row,
col);
if (is_near_water(water_window) == 1) {
if (in_terran[row][col] < water_level) {
out_water[row][col] =
water_level - in_terran[row][col];
curcount++;
}
else {
out_water[row][col] = 0;
}
}
}
}
G_percent(pass + 1, pases, 10);
if (curcount == lastcount)
break; /* We done. */
lastcount = curcount;
} /*pases */
G_percent(pases, pases, 10); /* Show 100%. */
save_map(out_water, out_fd, rows, cols, negative_flag->answer, &min_depth,
&max_depth, &area, &volume);
G_message(_("Lake depth from %f to %f"), min_depth, max_depth);
G_message(_("Lake area %f square meters"), area);
G_message(_("Lake volume %f cubic meters"), volume);
G_warning(_("Volume is correct only if lake depth (terrain raster map) is in meters"));
/* Close all files. Lake map gets written only now. */
G_close_cell(in_terran_fd);
G_close_cell(out_fd);
/* Add blue color gradient from light bank to dark depth */
G_init_colors(&colr);
if (negative_flag->answer == 1) {
G_add_f_raster_color_rule(&max_depth, 0, 240, 255,
&min_depth, 0, 50, 170, &colr);
}
else {
G_add_f_raster_color_rule(&min_depth, 0, 240, 255,
&max_depth, 0, 50, 170, &colr);
}
if (G_write_colors(lakemap, G_mapset(), &colr) != 1)
G_fatal_error(_("Unable to read color file of raster map <%s>"),
lakemap);
G_short_history(lakemap, "raster", &history);
G_command_history(&history);
G_write_history(lakemap, &history);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
char *input;
char *output;
char *title;
FILE *fd;
int cf;
struct Cell_head cellhd;
CELL *cell;
FCELL *fcell;
DCELL *dcell;
int row, col;
int nrows, ncols;
static int missingval;
int rtype;
double mult_fact;
double x;
struct GModule *module;
struct History history;
struct
{
struct Option *input, *output, *type, *title, *mult;
} parm;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("raster, import");
module->description =
_("Converts an ESRI ARC/INFO ascii raster file (GRID) "
"into a (binary) raster map layer.");
parm.input = G_define_option();
parm.input->key = "input";
parm.input->type = TYPE_STRING;
parm.input->required = YES;
parm.input->description =
_("ARC/INFO ASCII raster file (GRID) to be imported");
parm.input->gisprompt = "old_file,file,input";
parm.output = G_define_standard_option(G_OPT_R_OUTPUT);
parm.type = G_define_option();
parm.type->key = "type";
parm.type->type = TYPE_STRING;
parm.type->required = NO;
parm.type->options = "CELL,FCELL,DCELL";
parm.type->answer = "FCELL";
parm.type->description = _("Storage type for resultant raster map");
parm.title = G_define_option();
parm.title->key = "title";
parm.title->key_desc = "\"phrase\"";
parm.title->type = TYPE_STRING;
parm.title->required = NO;
parm.title->description = _("Title for resultant raster map");
parm.mult = G_define_option();
parm.mult->key = "mult";
parm.mult->type = TYPE_DOUBLE;
parm.mult->answer = "1.0";
parm.mult->required = NO;
parm.mult->description = _("Multiplier for ASCII data");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
input = parm.input->answer;
output = parm.output->answer;
if (title = parm.title->answer)
G_strip(title);
sscanf(parm.mult->answer, "%lf", &mult_fact);
if (strcmp("CELL", parm.type->answer) == 0)
rtype = CELL_TYPE;
else if (strcmp("DCELL", parm.type->answer) == 0)
rtype = DCELL_TYPE;
else
rtype = FCELL_TYPE;
if (strcmp("-", input) == 0) {
Tmp_file = G_tempfile();
if (NULL == (Tmp_fd = fopen(Tmp_file, "w+")))
G_fatal_error(_("Unable to open temporary file <%s>"), Tmp_file);
unlink(Tmp_file);
if (0 > file_cpy(stdin, Tmp_fd))
exit(EXIT_FAILURE);
fd = Tmp_fd;
}
else
fd = fopen(input, "r");
if (fd == NULL)
G_fatal_error(_("Unable to open input file <%s>"), input);
if (!gethead(fd, &cellhd, &missingval))
G_fatal_error(_("Can't get cell header"));
nrows = cellhd.rows;
ncols = cellhd.cols;
if (G_set_window(&cellhd) < 0)
G_fatal_error(_("Can't set window"));
if (nrows != G_window_rows())
G_fatal_error(_("OOPS: rows changed from %d to %d"), nrows,
G_window_rows());
if (ncols != G_window_cols())
G_fatal_error(_("OOPS: cols changed from %d to %d"), ncols,
G_window_cols());
switch (rtype) {
case CELL_TYPE:
cell = G_allocate_c_raster_buf();
break;
case FCELL_TYPE:
fcell = G_allocate_f_raster_buf();
break;
case DCELL_TYPE:
dcell = G_allocate_d_raster_buf();
break;
}
cf = G_open_raster_new(output, rtype);
if (cf < 0)
G_fatal_error(_("Unable to create raster map <%s>"), output);
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 5);
for (col = 0; col < ncols; col++) {
if (fscanf(fd, "%lf", &x) != 1) {
G_unopen_cell(cf);
G_fatal_error(_("Data conversion failed at row %d, col %d"),
row + 1, col + 1);
}
switch (rtype) {
case CELL_TYPE:
if ((int)x == missingval)
G_set_c_null_value(cell + col, 1);
else
cell[col] = (CELL) x *mult_fact;
break;
case FCELL_TYPE:
if ((int)x == missingval)
G_set_f_null_value(fcell + col, 1);
else
fcell[col] = (FCELL) x *mult_fact;
break;
case DCELL_TYPE:
if ((int)x == missingval)
G_set_d_null_value(dcell + col, 1);
else
dcell[col] = (DCELL) x *mult_fact;
break;
}
}
switch (rtype) {
case CELL_TYPE:
G_put_c_raster_row(cf, cell);
break;
case FCELL_TYPE:
G_put_f_raster_row(cf, fcell);
break;
case DCELL_TYPE:
G_put_d_raster_row(cf, dcell);
break;
}
}
/* G_message(_("CREATING SUPPORT FILES FOR %s"), output); */
G_close_cell(cf);
if (title)
G_put_cell_title(output, title);
G_short_history(output, "raster", &history);
G_command_history(&history);
G_write_history(output, &history);
exit(EXIT_SUCCESS);
}
/*
* 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);
}
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 main(int argc, char *argv[])
{
struct GModule *module;
struct Option *rastin, *rastout, *method;
struct History history;
char title[64];
char buf_nsres[100], buf_ewres[100];
struct Colors colors;
char *inmap;
int infile, outfile;
DCELL *outbuf;
int row, col;
struct Cell_head dst_w, src_w;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("raster, resample");
module->description =
_("Resamples raster map layers to a finer grid using interpolation.");
rastin = G_define_standard_option(G_OPT_R_INPUT);
rastout = G_define_standard_option(G_OPT_R_OUTPUT);
method = G_define_option();
method->key = "method";
method->type = TYPE_STRING;
method->required = NO;
method->description = _("Interpolation method");
method->options = "nearest,bilinear,bicubic";
method->answer = "bilinear";
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (G_strcasecmp(method->answer, "nearest") == 0)
neighbors = 1;
else if (G_strcasecmp(method->answer, "bilinear") == 0)
neighbors = 2;
else if (G_strcasecmp(method->answer, "bicubic") == 0)
neighbors = 4;
else
G_fatal_error(_("Invalid method: %s"), method->answer);
G_get_set_window(&dst_w);
inmap = G_find_cell2(rastin->answer, "");
if (!inmap)
G_fatal_error(_("Raster map <%s> not found"), rastin->answer);
/* set window to old map */
G_get_cellhd(rastin->answer, inmap, &src_w);
/* enlarge source window */
{
double north = G_row_to_northing(0.5, &dst_w);
double south = G_row_to_northing(dst_w.rows - 0.5, &dst_w);
int r0 = (int)floor(G_northing_to_row(north, &src_w) - 0.5) - 1;
int r1 = (int)floor(G_northing_to_row(south, &src_w) - 0.5) + 3;
double west = G_col_to_easting(0.5, &dst_w);
double east = G_col_to_easting(dst_w.cols - 0.5, &dst_w);
int c0 = (int)floor(G_easting_to_col(west, &src_w) - 0.5) - 1;
int c1 = (int)floor(G_easting_to_col(east, &src_w) - 0.5) + 3;
src_w.south -= src_w.ns_res * (r1 - src_w.rows);
src_w.north += src_w.ns_res * (-r0);
src_w.west -= src_w.ew_res * (-c0);
src_w.east += src_w.ew_res * (c1 - src_w.cols);
src_w.rows = r1 - r0;
src_w.cols = c1 - c0;
}
G_set_window(&src_w);
/* allocate buffers for input rows */
for (row = 0; row < neighbors; row++)
bufs[row] = G_allocate_d_raster_buf();
cur_row = -100;
/* open old map */
infile = G_open_cell_old(rastin->answer, inmap);
if (infile < 0)
G_fatal_error(_("Unable to open raster map <%s>"), rastin->answer);
/* reset window to current region */
G_set_window(&dst_w);
outbuf = G_allocate_d_raster_buf();
/* open new map */
outfile = G_open_raster_new(rastout->answer, DCELL_TYPE);
if (outfile < 0)
G_fatal_error(_("Unable to create raster map <%s>"), rastout->answer);
G_suppress_warnings(1);
/* otherwise get complaints about window changes */
switch (neighbors) {
case 1: /* nearest */
for (row = 0; row < dst_w.rows; row++) {
double north = G_row_to_northing(row + 0.5, &dst_w);
double maprow_f = G_northing_to_row(north, &src_w) - 0.5;
int maprow0 = (int)floor(maprow_f + 0.5);
G_percent(row, dst_w.rows, 2);
G_set_window(&src_w);
read_rows(infile, maprow0);
for (col = 0; col < dst_w.cols; col++) {
double east = G_col_to_easting(col + 0.5, &dst_w);
double mapcol_f = G_easting_to_col(east, &src_w) - 0.5;
int mapcol0 = (int)floor(mapcol_f + 0.5);
double c = bufs[0][mapcol0];
if (G_is_d_null_value(&c)) {
G_set_d_null_value(&outbuf[col], 1);
}
else {
outbuf[col] = c;
}
}
G_set_window(&dst_w);
G_put_d_raster_row(outfile, outbuf);
}
break;
case 2: /* bilinear */
for (row = 0; row < dst_w.rows; row++) {
double north = G_row_to_northing(row + 0.5, &dst_w);
double maprow_f = G_northing_to_row(north, &src_w) - 0.5;
int maprow0 = (int)floor(maprow_f);
double v = maprow_f - maprow0;
G_percent(row, dst_w.rows, 2);
G_set_window(&src_w);
read_rows(infile, maprow0);
for (col = 0; col < dst_w.cols; col++) {
double east = G_col_to_easting(col + 0.5, &dst_w);
double mapcol_f = G_easting_to_col(east, &src_w) - 0.5;
int mapcol0 = (int)floor(mapcol_f);
int mapcol1 = mapcol0 + 1;
double u = mapcol_f - mapcol0;
double c00 = bufs[0][mapcol0];
double c01 = bufs[0][mapcol1];
double c10 = bufs[1][mapcol0];
double c11 = bufs[1][mapcol1];
if (G_is_d_null_value(&c00) ||
G_is_d_null_value(&c01) ||
G_is_d_null_value(&c10) || G_is_d_null_value(&c11)) {
G_set_d_null_value(&outbuf[col], 1);
}
else {
outbuf[col] = G_interp_bilinear(u, v, c00, c01, c10, c11);
}
}
G_set_window(&dst_w);
G_put_d_raster_row(outfile, outbuf);
}
break;
case 4: /* bicubic */
for (row = 0; row < dst_w.rows; row++) {
double north = G_row_to_northing(row + 0.5, &dst_w);
double maprow_f = G_northing_to_row(north, &src_w) - 0.5;
int maprow1 = (int)floor(maprow_f);
int maprow0 = maprow1 - 1;
double v = maprow_f - maprow1;
G_percent(row, dst_w.rows, 2);
G_set_window(&src_w);
read_rows(infile, maprow0);
for (col = 0; col < dst_w.cols; col++) {
double east = G_col_to_easting(col + 0.5, &dst_w);
double mapcol_f = G_easting_to_col(east, &src_w) - 0.5;
int mapcol1 = (int)floor(mapcol_f);
int mapcol0 = mapcol1 - 1;
int mapcol2 = mapcol1 + 1;
int mapcol3 = mapcol1 + 2;
double u = mapcol_f - mapcol1;
double c00 = bufs[0][mapcol0];
double c01 = bufs[0][mapcol1];
double c02 = bufs[0][mapcol2];
double c03 = bufs[0][mapcol3];
double c10 = bufs[1][mapcol0];
double c11 = bufs[1][mapcol1];
double c12 = bufs[1][mapcol2];
double c13 = bufs[1][mapcol3];
double c20 = bufs[2][mapcol0];
double c21 = bufs[2][mapcol1];
double c22 = bufs[2][mapcol2];
double c23 = bufs[2][mapcol3];
double c30 = bufs[3][mapcol0];
double c31 = bufs[3][mapcol1];
double c32 = bufs[3][mapcol2];
double c33 = bufs[3][mapcol3];
if (G_is_d_null_value(&c00) ||
G_is_d_null_value(&c01) ||
G_is_d_null_value(&c02) ||
G_is_d_null_value(&c03) ||
G_is_d_null_value(&c10) ||
G_is_d_null_value(&c11) ||
G_is_d_null_value(&c12) ||
G_is_d_null_value(&c13) ||
G_is_d_null_value(&c20) ||
G_is_d_null_value(&c21) ||
G_is_d_null_value(&c22) ||
G_is_d_null_value(&c23) ||
G_is_d_null_value(&c30) ||
G_is_d_null_value(&c31) ||
G_is_d_null_value(&c32) || G_is_d_null_value(&c33)) {
G_set_d_null_value(&outbuf[col], 1);
}
else {
outbuf[col] = G_interp_bicubic(u, v,
c00, c01, c02, c03,
c10, c11, c12, c13,
c20, c21, c22, c23,
c30, c31, c32, c33);
}
}
G_set_window(&dst_w);
G_put_d_raster_row(outfile, outbuf);
}
break;
}
G_percent(dst_w.rows, dst_w.rows, 2);
G_close_cell(infile);
G_close_cell(outfile);
/* record map metadata/history info */
sprintf(title, "Resample by %s interpolation", method->answer);
G_put_cell_title(rastout->answer, title);
G_short_history(rastout->answer, "raster", &history);
strncpy(history.datsrc_1, rastin->answer, RECORD_LEN);
history.datsrc_1[RECORD_LEN - 1] = '\0'; /* strncpy() doesn't null terminate if maxfill */
G_format_resolution(src_w.ns_res, buf_nsres, src_w.proj);
G_format_resolution(src_w.ew_res, buf_ewres, src_w.proj);
sprintf(history.datsrc_2, "Source map NS res: %s EW res: %s", buf_nsres,
buf_ewres);
G_command_history(&history);
G_write_history(rastout->answer, &history);
/* copy color table from source map */
if (G_read_colors(rastin->answer, inmap, &colors) < 0)
G_fatal_error(_("Unable to read color table for %s"), rastin->answer);
G_mark_colors_as_fp(&colors);
if (G_write_colors(rastout->answer, G_mapset(), &colors) < 0)
G_fatal_error(_("Unable to write color table for %s"),
rastout->answer);
return (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;
}
int IL_resample_output_2d(struct interp_params *params, double zmin, double zmax, /* min,max input z-values */
double zminac, double zmaxac, /* min,max interpolated values */
double c1min, double c1max, double c2min, double c2max, double gmin, double gmax, double ertot, /* total interplating func. error */
char *input, /* input file name */
double *dnorm, struct Cell_head *outhd, /* Region with desired resolution */
struct Cell_head *winhd, /* Current region */
char *smooth, int n_points)
/*
* Creates output files as well as history files and color tables for
* them.
*/
{
FCELL *cell1; /* cell buffer */
int cf1 = 0, cf2 = 0, cf3 = 0, cf4 = 0, cf5 = 0, cf6 = 0; /* cell file descriptors */
int nrows, ncols; /* current region rows and columns */
int i; /* loop counter */
char *mapset;
float dat1, dat2;
struct Colors colors, colors2;
double value1, value2;
struct History hist, hist1, hist2, hist3, hist4, hist5;
struct _Color_Rule_ *rule;
char *maps, *type;
int cond1, cond2;
cond2 = ((params->pcurv != NULL) ||
(params->tcurv != NULL) || (params->mcurv != NULL));
cond1 = ((params->slope != NULL) || (params->aspect != NULL) || cond2);
/* change region to output cell file region */
fprintf(stderr,
"Temporarily changing the region to desired resolution...\n");
if (G_set_window(outhd) < 0) {
fprintf(stderr, "Cannot set region to output region!\n");
return -1;
}
mapset = G_mapset();
cell1 = G_allocate_f_raster_buf();
if (params->elev != NULL) {
cf1 = G_open_fp_cell_new(params->elev);
if (cf1 < 0) {
fprintf(stderr, "unable to create raster map %s\n", params->elev);
return -1;
}
}
if (params->slope != NULL) {
cf2 = G_open_fp_cell_new(params->slope);
if (cf2 < 0) {
fprintf(stderr, "unable to create raster map %s\n",
params->slope);
return -1;
}
}
if (params->aspect != NULL) {
cf3 = G_open_fp_cell_new(params->aspect);
if (cf3 < 0) {
fprintf(stderr, "unable to create raster map %s\n",
params->aspect);
return -1;
}
}
if (params->pcurv != NULL) {
cf4 = G_open_fp_cell_new(params->pcurv);
if (cf4 < 0) {
fprintf(stderr, "unable to create raster map %s\n",
params->pcurv);
return -1;
}
}
if (params->tcurv != NULL) {
cf5 = G_open_fp_cell_new(params->tcurv);
if (cf5 < 0) {
fprintf(stderr, "unable to create raster map %s\n",
params->tcurv);
return -1;
}
}
if (params->mcurv != NULL) {
cf6 = G_open_fp_cell_new(params->mcurv);
if (cf6 < 0) {
fprintf(stderr, "unable to create raster map %s\n",
params->mcurv);
return -1;
}
}
nrows = outhd->rows;
if (nrows != params->nsizr) {
fprintf(stderr, "first change your rows number(%d) to %d!\n",
nrows, params->nsizr);
return -1;
}
ncols = outhd->cols;
if (ncols != params->nsizc) {
fprintf(stderr, "first change your rows number(%d) to %d!\n",
ncols, params->nsizc);
return -1;
}
if (params->elev != NULL) {
fseek(params->Tmp_fd_z, 0L, 0); /* seek to the beginning */
for (i = 0; i < params->nsizr; i++) {
/* seek to the right row */
if (fseek(params->Tmp_fd_z, (long)
((params->nsizr - 1 -
i) * params->nsizc * sizeof(FCELL)), 0) == -1) {
fprintf(stderr, "cannot fseek to the right spot\n");
return -1;
}
fread(cell1, sizeof(FCELL), params->nsizc, params->Tmp_fd_z);
if (G_put_f_raster_row(cf1, cell1) < 0) {
fprintf(stderr, "cannot write file\n");
return -1;
}
}
}
if (params->slope != NULL) {
fseek(params->Tmp_fd_dx, 0L, 0); /* seek to the beginning */
for (i = 0; i < params->nsizr; i++) {
/* seek to the right row */
if (fseek(params->Tmp_fd_dx, (long)
((params->nsizr - 1 -
i) * params->nsizc * sizeof(FCELL)), 0) == -1) {
fprintf(stderr, "cannot fseek to the right spot\n");
return -1;
}
fread(cell1, sizeof(FCELL), params->nsizc, params->Tmp_fd_dx);
/*
* for (ii==0;ii<params->nsizc;ii++) { fprintf(stderr,"ii=%d ",ii);
* fprintf(stderr,"%f ",cell1[ii]); }
* fprintf(stderr,"params->nsizc=%d \n",params->nsizc);
*/
if (G_put_f_raster_row(cf2, cell1) < 0) {
fprintf(stderr, "cannot write file\n");
return -1;
}
}
}
if (params->aspect != NULL) {
fseek(params->Tmp_fd_dy, 0L, 0); /* seek to the beginning */
for (i = 0; i < params->nsizr; i++) {
/* seek to the right row */
if (fseek(params->Tmp_fd_dy, (long)
((params->nsizr - 1 -
i) * params->nsizc * sizeof(FCELL)), 0) == -1) {
fprintf(stderr, "cannot fseek to the right spot\n");
return -1;
}
fread(cell1, sizeof(FCELL), params->nsizc, params->Tmp_fd_dy);
if (G_put_f_raster_row(cf3, cell1) < 0) {
fprintf(stderr, "cannot write file\n");
return -1;
}
}
}
if (params->pcurv != NULL) {
fseek(params->Tmp_fd_xx, 0L, 0); /* seek to the beginning */
for (i = 0; i < params->nsizr; i++) {
/* seek to the right row */
if (fseek(params->Tmp_fd_xx, (long)
((params->nsizr - 1 -
i) * params->nsizc * sizeof(FCELL)), 0) == -1) {
fprintf(stderr, "cannot fseek to the right spot\n");
return -1;
}
fread(cell1, sizeof(FCELL), params->nsizc, params->Tmp_fd_xx);
if (G_put_f_raster_row(cf4, cell1) < 0) {
fprintf(stderr, "cannot write file\n");
return -1;
}
}
}
if (params->tcurv != NULL) {
fseek(params->Tmp_fd_yy, 0L, 0); /* seek to the beginning */
for (i = 0; i < params->nsizr; i++) {
/* seek to the right row */
if (fseek(params->Tmp_fd_yy, (long)
((params->nsizr - 1 -
i) * params->nsizc * sizeof(FCELL)), 0) == -1) {
fprintf(stderr, "cannot fseek to the right spot\n");
return -1;
}
fread(cell1, sizeof(FCELL), params->nsizc, params->Tmp_fd_yy);
if (G_put_f_raster_row(cf5, cell1) < 0) {
fprintf(stderr, "cannot write file\n");
return -1;
}
}
}
if (params->mcurv != NULL) {
fseek(params->Tmp_fd_xy, 0L, 0); /* seek to the beginning */
for (i = 0; i < params->nsizr; i++) {
/* seek to the right row */
if (fseek(params->Tmp_fd_xy, (long)
((params->nsizr - 1 -
i) * params->nsizc * sizeof(FCELL)), 0) == -1) {
fprintf(stderr, "cannot fseek to the right spot\n");
return -1;
}
fread(cell1, sizeof(FCELL), params->nsizc, params->Tmp_fd_xy);
if (G_put_f_raster_row(cf6, cell1) < 0) {
fprintf(stderr, "cannot write file\n");
return -1;
}
}
}
if (cf1)
G_close_cell(cf1);
if (cf2)
G_close_cell(cf2);
if (cf3)
G_close_cell(cf3);
if (cf4)
G_close_cell(cf4);
if (cf5)
G_close_cell(cf5);
if (cf6)
G_close_cell(cf6);
/* write colormaps and history for output cell files */
/* colortable for elevations */
maps = G_find_file("cell", input, "");
if (params->elev != NULL) {
if (maps == NULL) {
fprintf(stderr, "file [%s] not found\n", input);
return -1;
}
G_init_colors(&colors2);
/*
* G_mark_colors_as_fp(&colors2);
*/
if (G_read_colors(input, maps, &colors) >= 0) {
if (colors.modular.rules) {
rule = colors.modular.rules;
while (rule->next)
rule = rule->next;
for (; rule; rule = rule->prev) {
value1 = rule->low.value * params->zmult;
value2 = rule->high.value * params->zmult;
G_add_modular_d_raster_color_rule(&value1, rule->low.red,
rule->low.grn,
rule->low.blu, &value2,
rule->high.red,
rule->high.grn,
rule->high.blu,
&colors2);
}
}
if (colors.fixed.rules) {
rule = colors.fixed.rules;
while (rule->next)
rule = rule->next;
for (; rule; rule = rule->prev) {
value1 = rule->low.value * params->zmult;
value2 = rule->high.value * params->zmult;
G_add_d_raster_color_rule(&value1, rule->low.red,
rule->low.grn, rule->low.blu,
&value2, rule->high.red,
rule->high.grn, rule->high.blu,
&colors2);
}
}
maps = NULL;
maps = G_find_file("cell", params->elev, "");
if (maps == NULL) {
fprintf(stderr, "file [%s] not found\n", params->elev);
return -1;
}
if (G_write_colors(params->elev, maps, &colors2) < 0) {
fprintf(stderr, "Cannot write color table\n");
return -1;
}
G_quantize_fp_map_range(params->elev, mapset,
zminac - 0.5, zmaxac + 0.5,
(CELL) (zminac - 0.5),
(CELL) (zmaxac + 0.5));
}
else
fprintf(stderr,
"No color table for input file -- will not create color table\n");
}
/* colortable for slopes */
if (cond1 & (!params->deriv)) {
G_init_colors(&colors);
G_add_color_rule(0, 255, 255, 255, 2, 255, 255, 0, &colors);
G_add_color_rule(2, 255, 255, 0, 5, 0, 255, 0, &colors);
G_add_color_rule(5, 0, 255, 0, 10, 0, 255, 255, &colors);
G_add_color_rule(10, 0, 255, 255, 15, 0, 0, 255, &colors);
G_add_color_rule(15, 0, 0, 255, 30, 255, 0, 255, &colors);
G_add_color_rule(30, 255, 0, 255, 50, 255, 0, 0, &colors);
G_add_color_rule(50, 255, 0, 0, 90, 0, 0, 0, &colors);
if (params->slope != NULL) {
maps = NULL;
maps = G_find_file("cell", params->slope, "");
if (maps == NULL) {
fprintf(stderr, "file [%s] not found\n", params->slope);
return -1;
}
G_write_colors(params->slope, maps, &colors);
G_quantize_fp_map_range(params->slope, mapset, 0., 90., 0, 90);
type = "raster";
G_short_history(params->slope, type, &hist1);
if (params->elev != NULL)
sprintf(hist1.edhist[0], "The elevation map is %s",
params->elev);
sprintf(hist1.datsrc_1, "raster map %s", input);
hist1.edlinecnt = 1;
G_write_history(params->slope, &hist1);
}
/* colortable for aspect */
G_init_colors(&colors);
G_add_color_rule(0, 255, 255, 255, 0, 255, 255, 255, &colors);
G_add_color_rule(1, 255, 255, 0, 90, 0, 255, 0, &colors);
G_add_color_rule(90, 0, 255, 0, 180, 0, 255, 255, &colors);
G_add_color_rule(180, 0, 255, 255, 270, 255, 0, 0, &colors);
G_add_color_rule(270, 255, 0, 0, 360, 255, 255, 0, &colors);
if (params->aspect != NULL) {
maps = NULL;
maps = G_find_file("cell", params->aspect, "");
if (maps == NULL) {
fprintf(stderr, "file [%s] not found\n", params->aspect);
return -1;
}
G_write_colors(params->aspect, maps, &colors);
G_quantize_fp_map_range(params->aspect, mapset, 0., 360., 0, 360);
type = "raster";
G_short_history(params->aspect, type, &hist2);
if (params->elev != NULL)
sprintf(hist2.edhist[0], "The elevation map is %s",
params->elev);
sprintf(hist2.datsrc_1, "raster map %s", input);
hist2.edlinecnt = 1;
G_write_history(params->aspect, &hist2);
}
/* colortable for curvatures */
if (cond2) {
G_init_colors(&colors);
dat1 = (FCELL) amin1(c1min, c2min);
dat2 = (FCELL) - 0.01;
G_add_f_raster_color_rule(&dat1, 50, 0, 155,
&dat2, 0, 0, 255, &colors);
dat1 = dat2;
dat2 = (FCELL) - 0.001;
G_add_f_raster_color_rule(&dat1, 0, 0, 255,
&dat2, 0, 127, 255, &colors);
dat1 = dat2;
dat2 = (FCELL) - 0.00001;
G_add_f_raster_color_rule(&dat1, 0, 127, 255,
&dat2, 0, 255, 255, &colors);
dat1 = dat2;
dat2 = (FCELL) 0.00;
G_add_f_raster_color_rule(&dat1, 0, 255, 255,
&dat2, 200, 255, 200, &colors);
dat1 = dat2;
dat2 = (FCELL) 0.00001;
G_add_f_raster_color_rule(&dat1, 200, 255, 200,
&dat2, 255, 255, 0, &colors);
dat1 = dat2;
dat2 = (FCELL) 0.001;
G_add_f_raster_color_rule(&dat1, 255, 255, 0,
&dat2, 255, 127, 0, &colors);
dat1 = dat2;
dat2 = (FCELL) 0.01;
G_add_f_raster_color_rule(&dat1, 255, 127, 0,
&dat2, 255, 0, 0, &colors);
dat1 = dat2;
dat2 = (FCELL) amax1(c1max, c2max);
G_add_f_raster_color_rule(&dat1, 255, 0, 0,
&dat2, 155, 0, 20, &colors);
maps = NULL;
if (params->pcurv != NULL) {
maps = G_find_file("cell", params->pcurv, "");
if (maps == NULL) {
fprintf(stderr, "file [%s] not found\n", params->pcurv);
return -1;
}
G_write_colors(params->pcurv, maps, &colors);
fprintf(stderr, "color map written\n");
G_quantize_fp_map_range(params->pcurv, mapset,
dat1, dat2,
(CELL) (dat1 * MULT),
(CELL) (dat2 * MULT));
type = "raster";
G_short_history(params->pcurv, type, &hist3);
if (params->elev != NULL)
sprintf(hist3.edhist[0], "The elevation map is %s",
params->elev);
sprintf(hist3.datsrc_1, "raster map %s", input);
hist3.edlinecnt = 1;
G_write_history(params->pcurv, &hist3);
}
if (params->tcurv != NULL) {
maps = NULL;
maps = G_find_file("cell", params->tcurv, "");
if (maps == NULL) {
fprintf(stderr, "file [%s] not found\n", params->tcurv);
return -1;
}
G_write_colors(params->tcurv, maps, &colors);
G_quantize_fp_map_range(params->tcurv, mapset,
dat1, dat2, (CELL) (dat1 * MULT),
(CELL) (dat2 * MULT));
type = "raster";
G_short_history(params->tcurv, type, &hist4);
if (params->elev != NULL)
sprintf(hist4.edhist[0], "The elevation map is %s",
params->elev);
sprintf(hist4.datsrc_1, "raster map %s", input);
hist4.edlinecnt = 1;
G_write_history(params->tcurv, &hist4);
}
if (params->mcurv != NULL) {
maps = NULL;
maps = G_find_file("cell", params->mcurv, "");
if (maps == NULL) {
fprintf(stderr, "file [%s] not found\n", params->mcurv);
return -1;
}
G_write_colors(params->mcurv, maps, &colors);
G_quantize_fp_map_range(params->mcurv, mapset,
dat1, dat2,
(CELL) (dat1 * MULT),
(CELL) (dat2 * MULT));
type = "raster";
G_short_history(params->mcurv, type, &hist5);
if (params->elev != NULL)
sprintf(hist5.edhist[0], "The elevation map is %s",
params->elev);
sprintf(hist5.datsrc_1, "raster map %s", input);
hist5.edlinecnt = 1;
G_write_history(params->mcurv, &hist5);
}
}
}
if (params->elev != NULL) {
maps = G_find_file("cell", params->elev, "");
if (maps == NULL) {
fprintf(stderr, "file [%s] not found \n", params->elev);
return -1;
}
G_short_history(params->elev, "raster", &hist);
if (smooth != NULL)
sprintf(hist.edhist[0], "tension=%f, smoothing=%s",
params->fi * 1000. / (*dnorm), smooth);
else
sprintf(hist.edhist[0], "tension=%f",
params->fi * 1000. / (*dnorm));
sprintf(hist.edhist[1], "dnorm=%f, zmult=%f", *dnorm, params->zmult);
sprintf(hist.edhist[2], "KMAX=%d, KMIN=%d, errtotal=%f", params->kmax,
params->kmin, sqrt(ertot / n_points));
sprintf(hist.edhist[3], "zmin_data=%f, zmax_data=%f", zmin, zmax);
sprintf(hist.edhist[4], "zmin_int=%f, zmax_int=%f", zminac, zmaxac);
sprintf(hist.datsrc_1, "raster map %s", input);
hist.edlinecnt = 5;
G_write_history(params->elev, &hist);
}
/* change region to initial region */
fprintf(stderr, "Changing the region back to initial...\n");
if (G_set_window(winhd) < 0) {
fprintf(stderr, "Cannot set region to back to initial region!\n");
return -1;
}
return 1;
}