static void set_params()
{
param.input = G_define_standard_option(G_OPT_R3_INPUT);
param.output = G_define_standard_option(G_OPT_R3_OUTPUT);
param.method = G_define_option();
param.method->key = "method";
param.method->type = TYPE_STRING;
param.method->required = YES;
param.method->options = build_method_list();
param.method->description = _("Aggregate operation");
param.method->multiple = NO;
param.quantile = G_define_option();
param.quantile->key = "quantile";
param.quantile->type = TYPE_DOUBLE;
param.quantile->required = NO;
param.quantile->description =
_("Quantile to calculate for method=quantile");
param.quantile->options = "0.0-1.0";
param.quantile->multiple = NO;
param.window = G_define_option();
param.window->key = "window";
param.window->type = TYPE_INTEGER;
param.window->required = YES;
param.window->key_desc = "x,y,z";
param.window->description =
_("The size of the window in x, y and z direction,"
" values must be odd integer numbers, eg: 3,3,3");
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct
{
struct Option *rastin, *rastout, *method, *quantile;
} parm;
struct
{
struct Flag *nulls, *weight;
} flag;
struct History history;
char title[64];
char buf_nsres[100], buf_ewres[100];
struct Colors colors;
int row;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("resample"));
module->description =
_("Resamples raster map layers to a coarser grid using aggregation.");
parm.rastin = G_define_standard_option(G_OPT_R_INPUT);
parm.rastout = G_define_standard_option(G_OPT_R_OUTPUT);
parm.method = G_define_option();
parm.method->key = "method";
parm.method->type = TYPE_STRING;
parm.method->required = NO;
parm.method->description = _("Aggregation method");
parm.method->options = build_method_list();
parm.method->answer = "average";
parm.quantile = G_define_option();
parm.quantile->key = "quantile";
parm.quantile->type = TYPE_DOUBLE;
parm.quantile->required = NO;
parm.quantile->description = _("Quantile to calculate for method=quantile");
parm.quantile->options = "0.0-1.0";
parm.quantile->answer = "0.5";
flag.nulls = G_define_flag();
flag.nulls->key = 'n';
flag.nulls->description = _("Propagate NULLs");
flag.weight = G_define_flag();
flag.weight->key = 'w';
flag.weight->description = _("Weight according to area (slower)");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
nulls = flag.nulls->answer;
method = find_method(parm.method->answer);
if (method < 0)
G_fatal_error(_("Unknown method <%s>"), parm.method->answer);
if (menu[method].method == c_quant) {
quantile = atoi(parm.quantile->answer);
closure = &quantile;
}
G_get_set_window(&dst_w);
/* set window to old map */
Rast_get_cellhd(parm.rastin->answer, "", &src_w);
/* enlarge source window */
{
int r0 = (int)floor(Rast_northing_to_row(dst_w.north, &src_w));
int r1 = (int)ceil(Rast_northing_to_row(dst_w.south, &src_w));
int c0 = (int)floor(Rast_easting_to_col(dst_w.west, &src_w));
int c1 = (int)ceil(Rast_easting_to_col(dst_w.east, &src_w));
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;
}
Rast_set_input_window(&src_w);
Rast_set_output_window(&dst_w);
row_scale = 2 + ceil(dst_w.ns_res / src_w.ns_res);
col_scale = 2 + ceil(dst_w.ew_res / src_w.ew_res);
/* allocate buffers for input rows */
bufs = G_malloc(row_scale * sizeof(DCELL *));
for (row = 0; row < row_scale; row++)
bufs[row] = Rast_allocate_d_input_buf();
/* open old map */
infile = Rast_open_old(parm.rastin->answer, "");
/* allocate output buffer */
outbuf = Rast_allocate_d_output_buf();
/* open new map */
outfile = Rast_open_new(parm.rastout->answer, DCELL_TYPE);
if (flag.weight->answer && menu[method].method_w)
resamp_weighted();
else
resamp_unweighted();
G_percent(dst_w.rows, dst_w.rows, 2);
Rast_close(infile);
Rast_close(outfile);
/* record map metadata/history info */
sprintf(title, "Aggregate resample by %s", parm.method->answer);
Rast_put_cell_title(parm.rastout->answer, title);
Rast_short_history(parm.rastout->answer, "raster", &history);
Rast_set_history(&history, HIST_DATSRC_1, parm.rastin->answer);
G_format_resolution(src_w.ns_res, buf_nsres, src_w.proj);
G_format_resolution(src_w.ew_res, buf_ewres, src_w.proj);
Rast_format_history(&history, HIST_DATSRC_2,
"Source map NS res: %s EW res: %s",
buf_nsres, buf_ewres);
Rast_command_history(&history);
Rast_write_history(parm.rastout->answer, &history);
/* copy color table from source map */
if (strcmp(parm.method->answer, "sum") != 0) {
if (Rast_read_colors(parm.rastin->answer, "", &colors) < 0)
G_fatal_error(_("Unable to read color table for %s"),
parm.rastin->answer);
Rast_mark_colors_as_fp(&colors);
Rast_write_colors(parm.rastout->answer, G_mapset(), &colors);
}
return (EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct
{
struct Option *input, *output, *method, *quantile, *range;
} parm;
struct
{
struct Flag *nulls;
} flag;
int i;
int num_inputs;
struct input *inputs;
int num_outputs;
struct output *outputs;
struct History history;
DCELL *values, *values_tmp;
int nrows, ncols;
int row, col;
double lo, hi;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("series"));
module->description =
_("Makes each output cell value a "
"function of the values assigned to the corresponding cells "
"in the input raster map layers.");
parm.input = G_define_standard_option(G_OPT_R_INPUTS);
parm.output = G_define_standard_option(G_OPT_R_OUTPUT);
parm.output->multiple = YES;
parm.method = G_define_option();
parm.method->key = "method";
parm.method->type = TYPE_STRING;
parm.method->required = YES;
parm.method->options = build_method_list();
parm.method->description = _("Aggregate operation");
parm.method->multiple = YES;
parm.quantile = G_define_option();
parm.quantile->key = "quantile";
parm.quantile->type = TYPE_DOUBLE;
parm.quantile->required = NO;
parm.quantile->description = _("Quantile to calculate for method=quantile");
parm.quantile->options = "0.0-1.0";
parm.quantile->multiple = YES;
parm.range = G_define_option();
parm.range->key = "range";
parm.range->type = TYPE_DOUBLE;
parm.range->key_desc = "lo,hi";
parm.range->description = _("Ignore values outside this range");
flag.nulls = G_define_flag();
flag.nulls->key = 'n';
flag.nulls->description = _("Propagate NULLs");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (parm.range->answer) {
lo = atof(parm.range->answers[0]);
hi = atof(parm.range->answers[1]);
}
/* process the input maps */
for (i = 0; parm.input->answers[i]; i++)
;
num_inputs = i;
if (num_inputs < 1)
G_fatal_error(_("Raster map not found"));
inputs = G_malloc(num_inputs * sizeof(struct input));
for (i = 0; i < num_inputs; i++) {
struct input *p = &inputs[i];
p->name = parm.input->answers[i];
G_message(_("Reading raster map <%s>..."), p->name);
p->fd = Rast_open_old(p->name, "");
p->buf = Rast_allocate_d_buf();
}
/* process the output maps */
for (i = 0; parm.output->answers[i]; i++)
;
num_outputs = i;
for (i = 0; parm.method->answers[i]; i++)
;
if (num_outputs != i)
G_fatal_error(_("output= and method= must have the same number of values"));
outputs = G_calloc(num_outputs, sizeof(struct output));
for (i = 0; i < num_outputs; i++) {
struct output *out = &outputs[i];
const char *output_name = parm.output->answers[i];
const char *method_name = parm.method->answers[i];
int method = find_method(method_name);
out->name = output_name;
out->method_fn = menu[method].method;
out->quantile = (parm.quantile->answer && parm.quantile->answers[i])
? atof(parm.quantile->answers[i])
: 0;
out->buf = Rast_allocate_d_buf();
out->fd = Rast_open_new(output_name,
menu[method].is_int ? CELL_TYPE : DCELL_TYPE);
}
/* initialise variables */
values = G_malloc(num_inputs * sizeof(DCELL));
values_tmp = G_malloc(num_inputs * sizeof(DCELL));
nrows = Rast_window_rows();
ncols = Rast_window_cols();
/* process the data */
G_verbose_message(_("Percent complete..."));
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
for (i = 0; i < num_inputs; i++)
Rast_get_d_row(inputs[i].fd, inputs[i].buf, row);
for (col = 0; col < ncols; col++) {
int null = 0;
for (i = 0; i < num_inputs; i++) {
DCELL v = inputs[i].buf[col];
if (Rast_is_d_null_value(&v))
null = 1;
else if (parm.range->answer && (v < lo || v > hi)) {
Rast_set_d_null_value(&v, 1);
null = 1;
}
values[i] = v;
}
for (i = 0; i < num_outputs; i++) {
struct output *out = &outputs[i];
if (null && flag.nulls->answer)
Rast_set_d_null_value(&out->buf[col], 1);
else {
memcpy(values_tmp, values, num_inputs * sizeof(DCELL));
(*out->method_fn)(&out->buf[col], values_tmp, num_inputs, &out->quantile);
}
}
}
for (i = 0; i < num_outputs; i++)
Rast_put_d_row(outputs[i].fd, outputs[i].buf);
}
G_percent(row, nrows, 2);
/* close maps */
for (i = 0; i < num_outputs; i++) {
struct output *out = &outputs[i];
Rast_close(out->fd);
Rast_short_history(out->name, "raster", &history);
Rast_command_history(&history);
Rast_write_history(out->name, &history);
}
for (i = 0; i < num_inputs; i++)
Rast_close(inputs[i].fd);
exit(EXIT_SUCCESS);
}