static int parse_vallist(char **vallist, d_Mask * d_mask)
{
char buf[1024];
char x[2];
FILE *fd;
init_d_mask_rules(d_mask);
if (vallist == NULL)
return -1;
for (; *vallist; vallist++) {
if (*vallist[0] == '/') {
fd = fopen(*vallist, "r");
if (fd == NULL) {
perror(*vallist);
G_usage();
exit(EXIT_FAILURE);
}
while (fgets(buf, sizeof buf, fd)) {
if (sscanf(buf, "%1s", x) != 1 || *x == '#')
continue;
parse_d_mask_rule(buf, d_mask, *vallist);
}
fclose(fd);
}
else
parse_d_mask_rule(*vallist, d_mask, (char *)NULL);
}
return 0;
}
int parse_units(char *s)
{
int x;
if (match(s, "miles", 2))
x = SQ_MILES;
else if (match(s, "meters", 2))
x = SQ_METERS;
else if (match(s, "kilometers", 1))
x = SQ_KILOMETERS;
else if (match(s, "acres", 1))
x = ACRES;
else if (match(s, "hectares", 1))
x = HECTARES;
else if (match(s, "cell_counts", 1))
x = CELL_COUNTS;
else if (match(s, "counts", 1))
x = CELL_COUNTS;
else if (match(s, "percent_cover", 1))
x = PERCENT_COVER;
else {
G_usage();
exit(EXIT_FAILURE);
}
if (nunits >= MAX_UNITS) {
G_fatal_error(_("Only %d unit%s allowed"),
MAX_UNITS, MAX_UNITS == 1 ? "" : "s");
}
unit[nunits].type = x;
nunits++;
return 0;
}
int parse_d_mask_rule(char *vallist, d_Mask * d_mask, char *where)
{
double a, b;
char junk[128];
/* #-# */
if (sscanf(vallist, "%lf-%lf", &a, &b) == 2)
add_d_mask_rule(d_mask, a, b, 0);
/* inf-# */
else if (sscanf(vallist, "%[^ -\t]-%lf", junk, &a) == 2)
add_d_mask_rule(d_mask, a, a, -1);
/* #-inf */
else if (sscanf(vallist, "%lf-%[^ \t]", &a, junk) == 2)
add_d_mask_rule(d_mask, a, a, 1);
/* # */
else if (sscanf(vallist, "%lf", &a) == 1)
add_d_mask_rule(d_mask, a, a, 0);
else {
if (where)
fprintf(stderr, "%s: ", where);
G_usage();
G_fatal_error(_("[%s]: illegal value specified"), vallist);
}
return 0;
}
void parse_d_mask_rule(char *vallist, d_Mask * d_mask, char *where)
{
double a, b;
char junk[128];
/* #-# */
if (sscanf(vallist, "%lf-%lf", &a, &b) == 2) {
G_message(_("Adding rule: %lf - %lf"), a, b);
add_d_mask_rule(d_mask, a, b, 0);
}
/* inf-# */
else if (sscanf(vallist, "%[^ -\t]-%lf", junk, &a) == 2)
add_d_mask_rule(d_mask, a, a, -1);
/* #-inf */
else if (sscanf(vallist, "%lf-%[^ \t]", &a, junk) == 2)
add_d_mask_rule(d_mask, a, a, 1);
/* # */
else if (sscanf(vallist, "%lf", &a) == 1)
add_d_mask_rule(d_mask, a, a, 0);
else {
if (where)
G_message("%s: ", where);
G_warning(_("%s: illegal value spec"), vallist);
G_usage();
exit(EXIT_FAILURE);
}
}
int parse_mask_rule(char *catlist, Mask * mask, char *where)
{
long a, b;
char junk[128];
/* #-# */
if (sscanf(catlist, "%ld-%ld", &a, &b) == 2)
add_mask_rule(mask, a, b, 0);
/* inf-# */
else if (sscanf(catlist, "%[^ -\t]-%ld", junk, &a) == 2)
add_mask_rule(mask, a, a, -1);
/* #-inf */
else if (sscanf(catlist, "%ld-%[^ \t]", &a, junk) == 2)
add_mask_rule(mask, a, a, 1);
/* # */
else if (sscanf(catlist, "%ld", &a) == 1)
add_mask_rule(mask, a, a, 0);
else {
if (where)
fprintf(stderr, "%s: ", where);
G_usage();
G_fatal_error(_("[%s]: illegal category specified"), catlist);
}
return 0;
}
static int profile(int coords, const char *map, const char *nulls, char **line)
{
double e1, n1, e2, n2;
char buf[1024], profile[1024];
const char *argv[7];
int argc = 0;
int n;
int projection;
projection = G_projection();
argv[argc++] = "r.profile";
if (coords)
argv[argc++] = "-g";
sprintf(buf, "input=%s", map);
argv[argc++] = G_store(buf);
argv[argc++] = "output=-";
sprintf(buf, "null_value=%s", nulls);
argv[argc++] = G_store(buf);
strcpy(profile, "coordinates=");
for (n = 0; line[n]; n += 4) {
int err = parse_line("line", &line[n], &e1, &n1, &e2, &n2, projection);
if (err) {
G_usage();
exit(EXIT_FAILURE);
}
if (n > 0)
strcat(profile, ",");
G_format_easting(e1, buf, projection);
strcat(profile, buf);
G_format_northing(n1, buf, projection);
strcat(profile, ",");
strcat(profile, buf);
G_format_easting(e2, buf, projection);
strcat(profile, ",");
strcat(profile, buf);
G_format_northing(n2, buf, projection);
strcat(profile, ",");
strcat(profile, buf);
}
argv[argc++] = profile;
argv[argc++] = NULL;
G_verbose_message(_("End coordinate: %.15g, %.15g"), e2, n2);
return G_vspawn_ex(argv[0], argv);
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct Option *pid;
char *tempfile, *G__tempfile();
int p;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("general, map management");
module->description =
"Creates a temporary file and prints the file name.";
pid = G_define_option();
pid->key = "pid";
pid->type = TYPE_INTEGER;
pid->required = YES;
pid->description = "Process id to use when naming the tempfile";
G_disable_interactive();
if (G_parser(argc, argv))
exit(1);
if (sscanf(pid->answer, "%d", &p) != 1) {
G_usage();
exit(EXIT_FAILURE);
}
tempfile = G__tempfile(p);
/* create tempfile so next run of this program will create a unique name */
close(creat(tempfile, 0666));
fprintf(stdout, "%s\n", tempfile);
exit(EXIT_SUCCESS);
}
/* ************************************************************************* */
int main(int argc, char *argv[])
{
struct Cell_head region;
struct Cell_head default_region;
FILE *fp = NULL;
struct GModule *module;
int i = 0, polytype = 0;
char *null_value;
int out_type;
int fd; /*Normale maps ;) */
int rgbfd[3];
int vectfd[3];
int celltype[3] = { 0, 0, 0 };
int headertype;
double scale = 1.0, llscale = 1.0, eleval = 0.0;
int digits = 12;
/* Initialize GRASS */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("export"));
module->description = _("Converts raster maps into the VTK-ASCII format.");
/* Get parameters from user */
set_params();
/* Have GRASS get inputs */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (param.input->answers == NULL && param.rgbmaps->answers == NULL &&
param.vectmaps->answers == NULL) {
G_fatal_error(_("No input maps specified. You need to specify at least one input map or three vector maps or three rgb maps."));
}
/*open the output */
if (param.output->answer) {
fp = fopen(param.output->answer, "w");
if (fp == NULL) {
perror(param.output->answer);
G_usage();
exit(EXIT_FAILURE);
}
}
else
fp = stdout;
/*Correct the coordinates, so the precision of VTK is not hurt :( */
if (param.coorcorr->answer) {
/*Get the default region for coordiante correction */
G_get_default_window(&default_region);
/*Use the center of the current region as extent */
y_extent = (default_region.north + default_region.south) / 2;
x_extent = (default_region.west + default_region.east) / 2;
}
else {
x_extent = 0;
y_extent = 0;
}
/* Figure out the region from the map */
G_get_window(®ion);
/*Set the null Value, maybe i have to check this? */
null_value = param.null_val->answer;
/*number of significant digits */
sscanf(param.decimals->answer, "%i", &digits);
/* read and compute the scale factor */
sscanf(param.elevscale->answer, "%lf", &scale);
sscanf(param.elev->answer, "%lf", &eleval);
/*if LL projection, convert the elevation values to degrees */
if (region.proj == PROJECTION_LL) {
llscale = M_PI / (180) * 6378137;
scale /= llscale;
}
/********************* WRITE ELEVATION *************************************/
if (param.elevationmap->answer) {
/*If the elevation is set, write the correct Header */
if (param.usestruct->answer) {
write_vtk_structured_elevation_header(fp, region);
}
else {
write_vtk_polygonal_elevation_header(fp, region);
}
G_debug(3, _("Open Raster file %s"), param.elevationmap->answer);
/* open raster map */
fd = Rast_open_old(param.elevationmap->answer, "");
out_type = Rast_get_map_type(fd);
/*The write the Coordinates */
if (param.usestruct->answer) {
write_vtk_structured_coordinates(fd, fp,
param.elevationmap->answer,
region, out_type, null_value,
scale, digits);
}
else {
polytype = QUADS; /*The default */
if (param.usetriangle->answer)
polytype = TRIANGLE_STRIPS;
if (param.usevertices->answer)
polytype = VERTICES;
write_vtk_polygonal_coordinates(fd, fp,
param.elevationmap->answer,
region, out_type, null_value,
scale, polytype, digits);
}
Rast_close(fd);
}
else {
/*Should pointdata or celldata be written */
if (param.point->answer)
headertype = 1;
else
headertype = 0;
/*If no elevation is given, write the normal Header */
if (param.origin->answer)
write_vtk_normal_header(fp, region, scale * eleval, headertype);
else
write_vtk_normal_header(fp, region, eleval / llscale, headertype);
}
/******************** WRITE THE POINT OR CELL DATA HEADER ******************/
if (param.input->answers != NULL || param.rgbmaps->answers != NULL) {
if (param.point->answer || param.elevationmap->answer)
write_vtk_pointdata_header(fp, region);
else
write_vtk_celldata_header(fp, region);
}
/********************** WRITE NORMAL DATA; CELL OR POINT *******************/
/*Loop over all input maps! */
if (param.input->answers != NULL) {
for (i = 0; param.input->answers[i] != NULL; i++) {
G_debug(3, _("Open Raster file %s"), param.input->answers[i]);
/* open raster map */
fd = Rast_open_old(param.input->answers[i], "");
out_type = Rast_get_map_type(fd);
/*Now write the data */
write_vtk_data(fd, fp, param.input->answers[i], region, out_type,
null_value, digits);
Rast_close(fd);
}
}
/********************** WRITE RGB IMAGE DATA; CELL OR POINT ****************/
if (param.rgbmaps->answers != NULL) {
if (param.rgbmaps->answers[0] != NULL &&
param.rgbmaps->answers[1] != NULL &&
param.rgbmaps->answers[2] != NULL) {
/*Loop over all three rgb input maps! */
for (i = 0; i < 3; i++) {
G_debug(3, _("Open Raster file %s"),
param.rgbmaps->answers[i]);
/* open raster map */
rgbfd[i] = Rast_open_old(param.rgbmaps->answers[i], "");
celltype[i] = Rast_get_map_type(rgbfd[i]);
}
/*Maps have to be from the same type */
if (celltype[0] == celltype[1] && celltype[0] == celltype[2]) {
G_debug(3, _("Writing VTK ImageData\n"));
out_type = celltype[0];
/*Now write the data */
write_vtk_rgb_image_data(rgbfd[0], rgbfd[1], rgbfd[2], fp,
"RGB_Image", region, out_type,
digits);
}
else {
G_warning(_("Wrong RGB maps. Maps should have the same type! RGB output not added!"));
/*do nothing */
}
/*Close the maps */
for (i = 0; i < 3; i++)
Rast_close(rgbfd[i]);
}
}
/********************** WRITE VECTOR DATA; CELL OR POINT ****************/
if (param.vectmaps->answers != NULL) {
if (param.vectmaps->answers[0] != NULL &&
param.vectmaps->answers[1] != NULL &&
param.vectmaps->answers[2] != NULL) {
/*Loop over all three vect input maps! */
for (i = 0; i < 3; i++) {
G_debug(3, _("Open Raster file %s"),
param.vectmaps->answers[i]);
/* open raster map */
vectfd[i] = Rast_open_old(param.vectmaps->answers[i], "");
celltype[i] = Rast_get_map_type(vectfd[i]);
}
/*Maps have to be from the same type */
if (celltype[0] == celltype[1] && celltype[0] == celltype[2]) {
G_debug(3, _("Writing VTK Vector Data\n"));
out_type = celltype[0];
/*Now write the data */
write_vtk_vector_data(vectfd[0], vectfd[1], vectfd[2], fp,
"Vector_Data", region, out_type,
digits);
}
else {
G_warning(_("Wrong vector maps. Maps should have the same type! Vector output not added!"));
/*do nothing */
}
/*Close the maps */
for (i = 0; i < 3; i++)
Rast_close(vectfd[i]);
}
}
if (param.output->answer && fp != NULL)
if (fclose(fp)) {
G_fatal_error(_("Error closing VTK-ASCII file"));
}
return 0;
}
int main(int argc, char *argv[])
{
const char *name;
const char *mapset;
long x, y;
double dx;
RASTER_MAP_TYPE map_type;
int i;
int from_stdin = FALSE;
struct GModule *module;
struct
{
struct Option *map, *fs, *cats, *vals, *raster, *file, *fmt_str,
*fmt_coeff;
} parm;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("category"));
module->description =
_("Manages category values and labels associated "
"with user-specified raster map layers.");
parm.map = G_define_standard_option(G_OPT_R_MAP);
parm.cats = G_define_standard_option(G_OPT_V_CATS);
parm.cats->multiple = YES;
parm.cats->guisection = _("Selection");
parm.vals = G_define_option();
parm.vals->key = "vals";
parm.vals->type = TYPE_DOUBLE;
parm.vals->multiple = YES;
parm.vals->required = NO;
parm.vals->label = _("Comma separated value list");
parm.vals->description = _("Example: 1.4,3.8,13");
parm.vals->guisection = _("Selection");
parm.fs = G_define_standard_option(G_OPT_F_SEP);
parm.fs->answer = "tab";
parm.raster = G_define_standard_option(G_OPT_R_INPUT);
parm.raster->key = "raster";
parm.raster->required = NO;
parm.raster->description =
_("Raster map from which to copy category table");
parm.raster->guisection = _("Define");
parm.file = G_define_standard_option(G_OPT_F_INPUT);
parm.file->key = "rules";
parm.file->required = NO;
parm.file->description =
_("File containing category label rules (or \"-\" to read from stdin)");
parm.file->guisection = _("Define");
parm.fmt_str = G_define_option();
parm.fmt_str->key = "format";
parm.fmt_str->type = TYPE_STRING;
parm.fmt_str->required = NO;
parm.fmt_str->label =
_("Default label or format string for dynamic labeling");
parm.fmt_str->description =
_("Used when no explicit label exists for the category");
parm.fmt_coeff = G_define_option();
parm.fmt_coeff->key = "coefficients";
parm.fmt_coeff->type = TYPE_DOUBLE;
parm.fmt_coeff->required = NO;
parm.fmt_coeff->key_desc = "mult1,offset1,mult2,offset2";
/* parm.fmt_coeff->answer = "0.0,0.0,0.0,0.0"; */
parm.fmt_coeff->label = _("Dynamic label coefficients");
parm.fmt_coeff->description =
_("Two pairs of category multiplier and offsets, for $1 and $2");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
name = parm.map->answer;
fs = G_option_to_separator(parm.fs);
mapset = G_find_raster2(name, "");
if (mapset == NULL)
G_fatal_error(_("Raster map <%s> not found"), name);
map_type = Rast_map_type(name, mapset);
/* create category labels */
if (parm.raster->answer || parm.file->answer ||
parm.fmt_str->answer || parm.fmt_coeff->answer) {
/* restrict editing to current mapset */
if (strcmp(mapset, G_mapset()) != 0)
G_fatal_error(_("Raster map <%s> not found in current mapset"),
name);
/* use cats from another map */
if (parm.raster->answer) {
int fd;
const char *cmapset;
cmapset = G_find_raster2(parm.raster->answer, "");
if (cmapset == NULL)
G_fatal_error(_("Raster map <%s> not found"),
parm.raster->answer);
fd = Rast_open_old(name, mapset);
Rast_init_cats("", &cats);
if (0 > Rast_read_cats(parm.raster->answer, cmapset, &cats))
G_fatal_error(_("Unable to read category file of raster map <%s@%s>"),
parm.raster->answer, cmapset);
Rast_write_cats(name, &cats);
G_message(_("Category table for <%s> set from <%s>"),
name, parm.raster->answer);
Rast_close(fd);
}
/* load cats from rules file */
if (parm.file->answer) {
FILE *fp;
char **tokens;
int ntokens;
char *e1;
char *e2;
if (strcmp("-", parm.file->answer) == 0) {
from_stdin = TRUE;
fp = stdin;
}
else {
fp = fopen(parm.file->answer, "r");
if (!fp)
G_fatal_error(_("Unable to open file <%s>"),
parm.file->answer);
}
Rast_init_cats("", &cats);
for (;;) {
char buf[1024];
DCELL d1, d2;
int parse_error = 0;
if (!G_getl2(buf, sizeof(buf), fp))
break;
tokens = G_tokenize(buf, fs);
ntokens = G_number_of_tokens(tokens);
if (ntokens == 3) {
d1 = strtod(tokens[0], &e1);
d2 = strtod(tokens[1], &e2);
if (*e1 == 0 && *e2 == 0)
Rast_set_d_cat(&d1, &d2, tokens[2], &cats);
else
parse_error = 1;
}
else if (ntokens == 2) {
d1 = strtod(tokens[0], &e1);
if (*e1 == 0)
Rast_set_d_cat(&d1, &d1, tokens[1], &cats);
else
parse_error = 1;
}
else if (!strlen(buf))
continue;
else
parse_error = 1;
if (parse_error)
G_fatal_error(_("Incorrect format of input rules. "
"Check separators. Invalid line is:\n%s"), buf);
}
G_free_tokens(tokens);
Rast_write_cats(name, &cats);
if (!from_stdin)
fclose(fp);
}
/* set dynamic cat rules for cats without explicit labels */
if (parm.fmt_str->answer || parm.fmt_coeff->answer) {
char *fmt_str;
double m1, a1, m2, a2;
/* read existing values */
Rast_init_cats("", &cats);
if (0 > Rast_read_cats(name, G_mapset(), &cats))
G_warning(_("Unable to read category file of raster map <%s@%s>"),
name, G_mapset());
if (parm.fmt_str->answer) {
fmt_str =
G_malloc(strlen(parm.fmt_str->answer) > strlen(cats.fmt)
? strlen(parm.fmt_str->answer) +
1 : strlen(cats.fmt) + 1);
strcpy(fmt_str, parm.fmt_str->answer);
}
else {
fmt_str = G_malloc(strlen(cats.fmt) + 1);
strcpy(fmt_str, cats.fmt);
}
m1 = cats.m1;
a1 = cats.a1;
m2 = cats.m2;
a2 = cats.a2;
if (parm.fmt_coeff->answer) {
m1 = atof(parm.fmt_coeff->answers[0]);
a1 = atof(parm.fmt_coeff->answers[1]);
m2 = atof(parm.fmt_coeff->answers[2]);
a2 = atof(parm.fmt_coeff->answers[3]);
}
Rast_set_cats_fmt(fmt_str, m1, a1, m2, a2, &cats);
Rast_write_cats(name, &cats);
}
Rast_free_cats(&cats);
exit(EXIT_SUCCESS);
}
else {
if (Rast_read_cats(name, mapset, &cats) < 0)
G_fatal_error(_("Unable to read category file of raster map <%s> in <%s>"),
name, mapset);
}
/* describe the category labels */
/* if no cats requested, use r.describe to get the cats */
if (parm.cats->answer == NULL) {
if (map_type == CELL_TYPE) {
get_cats(name, mapset);
while (next_cat(&x))
print_label(x);
exit(EXIT_SUCCESS);
}
}
else {
if (map_type != CELL_TYPE)
G_warning(_("The map is floating point! Ignoring cats list, using vals list"));
else { /* integer map */
for (i = 0; parm.cats->answers[i]; i++)
if (!scan_cats(parm.cats->answers[i], &x, &y)) {
G_usage();
exit(EXIT_FAILURE);
}
for (i = 0; parm.cats->answers[i]; i++) {
scan_cats(parm.cats->answers[i], &x, &y);
while (x <= y)
print_label(x++);
}
exit(EXIT_SUCCESS);
}
}
if (parm.vals->answer == NULL)
G_fatal_error(_("vals argument is required for floating point map!"));
for (i = 0; parm.vals->answers[i]; i++)
if (!scan_vals(parm.vals->answers[i], &dx)) {
G_usage();
exit(EXIT_FAILURE);
}
for (i = 0; parm.vals->answers[i]; i++) {
scan_vals(parm.vals->answers[i], &dx);
print_d_label(dx);
}
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
char command[GPATH_MAX];
int err, ret;
struct Option *opt1;
struct Option *opt2;
struct Option *opt3;
struct Option *opt4;
struct Option *opt5;
struct Option *opt6;
struct Option *opt7;
struct Option *opt8;
struct Option *opt9;
struct Option *opt10;
struct Option *opt11;
struct Option *opt12;
struct Option *opt13;
struct Option *opt14;
struct Option *opt15;
struct Option *opt16;
struct Flag *flag_sfd;
struct Flag *flag_flow;
struct Flag *flag_seg;
struct Flag *flag_abs;
struct Flag *flag_flat;
struct GModule *module;
G_gisinit(argv[0]);
/* Set description */
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("hydrology"));
module->description = _("Calculates hydrological parameters and RUSLE factors.");
opt1 = G_define_standard_option(G_OPT_R_ELEV);
opt1->guisection = _("Inputs");
opt2 = G_define_standard_option(G_OPT_R_INPUT);
opt2->key = "depression";
opt2->label = _("Name of input depressions raster map");
opt2->description = _("All non-NULL and non-zero cells are considered as real depressions");
opt2->required = NO;
opt2->guisection = _("Inputs");
opt3 = G_define_standard_option(G_OPT_R_INPUT);
opt3->key = "flow";
opt3->description = _("Name of input raster representing amount of overland flow per cell");
opt3->required = NO;
opt3->guisection = _("Inputs");
opt4 = G_define_standard_option(G_OPT_R_INPUT);
opt4->key = "disturbed_land";
opt4->label = _("Name of input raster map percent of disturbed land");
opt4->description = _("For USLE");
opt4->required = NO;
opt4->guisection = _("Inputs");
opt5 = G_define_standard_option(G_OPT_R_INPUT);
opt5->key = "blocking";
opt5->label =
_("IName of input raster map blocking overland surface flow");
opt5->description =
_("For USLE. All non-NULL and non-zero cells are considered as blocking terrain.");
opt5->required = NO;
opt5->guisection = _("Inputs");
opt6 = G_define_option();
opt6->key = "threshold";
opt6->description =
_("Minimum size of exterior watershed basin");
opt6->required = NO;
opt6->type = TYPE_INTEGER;
opt6->guisection = _("Inputs");
opt7 = G_define_option();
opt7->key = "max_slope_length";
opt7->label =
_("Maximum length of surface flow in map units");
opt7->description = _("For USLE");
opt7->required = NO;
opt7->type = TYPE_DOUBLE;
opt7->guisection = _("Inputs");
opt8 = G_define_standard_option(G_OPT_R_OUTPUT);
opt8->key = "accumulation";
opt8->label =
_("Name for output accumulation raster map");
opt8->description =
_("Number of cells that drain through each cell");
opt8->required = NO;
opt8->guisection = _("Outputs");
opt9 = G_define_standard_option(G_OPT_R_OUTPUT);
opt9->key = "drainage";
opt9->description = _("Name for output drainage direction raster map");
opt9->required = NO;
opt9->guisection = _("Outputs");
opt10 = G_define_standard_option(G_OPT_R_OUTPUT);
opt10->key = "basin";
opt10->description =
_("Name for basins raster map");
opt10->description = _("Unique label for each watershed basin");
opt10->required = NO;
opt10->guisection = _("Outputs");
opt11 = G_define_standard_option(G_OPT_R_OUTPUT);
opt11->key = "stream";
opt11->description = _("Name for output stream segments raster map");
opt11->required = NO;
opt11->guisection = _("Outputs");
opt12 = G_define_standard_option(G_OPT_R_OUTPUT);
opt12->key = "half_basin";
opt12->label = _("Name for output half basins raster map");
opt12->description =
_("Each half-basin is given a unique value");
opt12->required = NO;
opt12->guisection = _("Outputs");
opt13 = G_define_standard_option(G_OPT_R_OUTPUT);
opt13->key = "length_slope";
opt13->label = _("Name for output slope length raster map");
opt13->description =
_("Slope length and steepness (LS) factor for USLE");
opt13->required = NO;
opt13->guisection = _("Outputs");
opt14 = G_define_standard_option(G_OPT_R_OUTPUT);
opt14->key = "slope_steepness";
opt14->label = _("Name for output slope steepness raster map");
opt14->description = _("Slope steepness (S) factor for USLE");
opt14->required = NO;
opt14->guisection = _("Outputs");
opt15 = G_define_option();
opt15->key = "convergence";
opt15->type = TYPE_INTEGER;
opt15->required = NO;
opt15->answer = "5";
opt15->label = _("Convergence factor for MFD (1-10)");
opt15->description =
_("1 = most diverging flow, 10 = most converging flow. Recommended: 5");
opt16 = G_define_option();
opt16->key = "memory";
opt16->type = TYPE_INTEGER;
opt16->required = NO;
opt16->answer = "300"; /* 300MB default value, please keep r.terraflow in sync */
opt16->description = _("Maximum memory to be used with -m flag (in MB)");
flag_sfd = G_define_flag();
flag_sfd->key = 's';
flag_sfd->label = _("SFD (D8) flow (default is MFD)");
flag_sfd->description =
_("SFD: single flow direction, MFD: multiple flow direction");
flag_flow = G_define_flag();
flag_flow->key = '4';
flag_flow->description =
_("Allow only horizontal and vertical flow of water");
flag_seg = G_define_flag();
flag_seg->key = 'm';
flag_seg->label =
_("Enable disk swap memory option: Operation is slow");
flag_seg->description =
_("Only needed if memory requirements exceed available RAM; see manual on how to calculate memory requirements");
flag_abs = G_define_flag();
flag_abs->key = 'a';
flag_abs->label =
_("Use positive flow accumulation even for likely underestimates");
flag_abs->description =
_("See manual for a detailed description of flow accumulation output");
flag_flat = G_define_flag();
flag_flat->key = 'b';
flag_flat->label =
_("Beautify flat areas");
flag_flat->description =
_("Flow direction in flat areas is modified to look prettier");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* Check option combinations */
/* Check for some output map */
if ((opt8->answer == NULL)
&& (opt9->answer == NULL)
&& (opt10->answer == NULL)
&& (opt11->answer == NULL)
&& (opt12->answer == NULL)
&& (opt14->answer == NULL)
&& (opt15->answer == NULL)) {
G_fatal_error(_("Sorry, you must choose an output map."));
}
err = 0;
/* basin and basin threshold */
err += (opt10->answer != NULL && opt6->answer == NULL);
/* stream and basin threshold */
err += (opt11->answer != NULL && opt6->answer == NULL);
/* half_basin and basin threshold */
err += (opt12->answer != NULL && opt6->answer == NULL);
/* LS factor and basin threshold */
err += (opt13->answer != NULL && opt6->answer == NULL);
/* S factor and basin threshold */
err += (opt14->answer != NULL && opt6->answer == NULL);
if (err) {
G_message(_("Sorry, if any of the following options are set:\n"
" basin, stream, half_basin, length_slope, or slope_steepness\n"
" you MUST provide a value for the basin "
"threshold parameter."));
G_usage();
exit(EXIT_FAILURE);
}
/* Build command line */
sprintf(command, "%s/etc/r.watershed.%s",
G_gisbase(),
flag_seg->answer ? "seg" : "ram");
new_argv[new_argc++] = command;
if (flag_sfd->answer)
new_argv[new_argc++] = "-s";
if (flag_flow->answer)
new_argv[new_argc++] = "-4";
if (flag_abs->answer)
new_argv[new_argc++] = "-a";
if (flag_flat->answer && !flag_seg->answer)
new_argv[new_argc++] = "-b";
if (flag_flat->answer && flag_seg->answer)
G_message(_("Beautify flat areas is not yet supported for disk swap mode"));
do_opt(opt1);
do_opt(opt2);
do_opt(opt3);
do_opt(opt4);
do_opt(opt5);
do_opt(opt6);
do_opt(opt7);
do_opt(opt8);
do_opt(opt9);
do_opt(opt10);
do_opt(opt11);
do_opt(opt12);
do_opt(opt13);
do_opt(opt14);
do_opt(opt15);
if (flag_seg->answer)
do_opt(opt16);
new_argv[new_argc++] = NULL;
G_debug(1, "Mode: %s", flag_seg->answer ? "Segmented" : "All in RAM");
ret = G_vspawn_ex(new_argv[0], new_argv);
if (ret != EXIT_SUCCESS)
G_warning(_("Subprocess failed with exit code %d"), ret);
/* record map metadata/history info */
if (opt8->answer)
write_hist(opt8->answer,
"Watershed accumulation: overland flow that traverses each cell",
opt1->answer, flag_seg->answer, flag_sfd->answer);
if (opt9->answer)
write_hist(opt9->answer,
"Watershed drainage direction (CCW from East divided by 45deg)",
opt1->answer, flag_seg->answer, flag_sfd->answer);
if (opt10->answer)
write_hist(opt10->answer,
"Watershed basins", opt1->answer, flag_seg->answer,
flag_sfd->answer);
if (opt11->answer)
write_hist(opt11->answer,
"Watershed stream segments", opt1->answer,
flag_seg->answer, flag_sfd->answer);
if (opt12->answer)
write_hist(opt12->answer,
"Watershed half-basins", opt1->answer, flag_seg->answer,
flag_sfd->answer);
if (opt13->answer)
write_hist(opt13->answer,
"Watershed slope length and steepness (LS) factor",
opt1->answer, flag_seg->answer, flag_sfd->answer);
if (opt14->answer)
write_hist(opt14->answer,
"Watershed slope steepness (S) factor",
opt1->answer, flag_seg->answer, flag_sfd->answer);
exit(ret);
}
int main(int argc, char **argv)
{
int colorg = 0;
int colorb = 0;
int colort = 0;
int colorbg = 0;
double size = 0., gsize = 0.; /* initialize to zero */
double east, north;
int do_text, fontsize, mark_type, line_width, dirn;
struct GModule *module;
struct Option *opt1, *opt2, *opt3, *opt4, *fsize, *tcolor, *lwidth,
*direction, *bgcolor;
struct Flag *noborder, *notext, *geogrid, *nogrid, *wgs84, *cross,
*fiducial, *dot, *align;
struct pj_info info_in; /* Proj structures */
struct pj_info info_out; /* Proj structures */
struct Cell_head wind;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("cartography"));
G_add_keyword(_("graticule"));
module->description =
_("Overlays a user-specified grid "
"in the active display frame on the graphics monitor.");
opt2 = G_define_option();
opt2->key = "size";
opt2->key_desc = "value";
opt2->type = TYPE_STRING;
opt2->required = YES;
opt2->label = _("Size of grid to be drawn (in map units)");
opt2->description =
_("0 for north-south resolution of the current region. "
"In map units or DDD:MM:SS format. "
"Example: \"1000\" or \"0:10\"");
opt3 = G_define_standard_option(G_OPT_M_COORDS);
opt3->key = "origin";
opt3->answer = "0,0";
opt3->multiple = NO;
opt3->description = _("Lines of the grid pass through this coordinate");
direction = G_define_option();
direction->key = "direction";
direction->type = TYPE_STRING;
direction->required = NO;
direction->answer = "both";
direction->options = "both,east-west,north-south";
direction->description =
_("Draw only east-west lines, north-south lines, or both ");
direction->guisection = _("Disable");
lwidth = G_define_option();
lwidth->key = "width";
lwidth->type = TYPE_DOUBLE;
lwidth->required = NO;
lwidth->description = _("Grid line width");
opt1 = G_define_standard_option(G_OPT_C);
opt1->answer = "gray";
opt1->label = _("Grid color");
opt1->guisection = _("Color");
opt4 = G_define_standard_option(G_OPT_C);
opt4->key = "border_color";
opt4->label = _("Border color");
opt4->guisection = _("Color");
tcolor = G_define_standard_option(G_OPT_C);
tcolor->key = "text_color";
tcolor->answer = "gray";
tcolor->label = _("Text color");
tcolor->guisection = _("Color");
bgcolor = G_define_standard_option(G_OPT_CN);
bgcolor->key = "bgcolor";
bgcolor->answer = "none";
bgcolor->label = _("Background color");
bgcolor->guisection = _("Color");
fsize = G_define_option();
fsize->key = "fontsize";
fsize->type = TYPE_INTEGER;
fsize->required = NO;
fsize->answer = "9";
fsize->options = "1-72";
fsize->description = _("Font size for gridline coordinate labels");
align = G_define_flag();
align->key = 'a';
align->description =
_("Align the origin to the east-north corner of the current region");
geogrid = G_define_flag();
geogrid->key = 'g';
geogrid->description =
_("Draw geographic grid (referenced to current ellipsoid)");
geogrid->guisection = _("Draw");
wgs84 = G_define_flag();
wgs84->key = 'w';
wgs84->description =
_("Draw geographic grid (referenced to WGS84 ellipsoid)");
wgs84->guisection = _("Draw");
cross = G_define_flag();
cross->key = 'c';
cross->description = _("Draw '+' marks instead of grid lines");
cross->guisection = _("Draw");
dot = G_define_flag();
dot->key = 'd';
dot->description = _("Draw '.' marks instead of grid lines");
dot->guisection = _("Draw");
fiducial = G_define_flag();
fiducial->key = 'f';
fiducial->description = _("Draw fiducial marks instead of grid lines");
fiducial->guisection = _("Draw");
nogrid = G_define_flag();
nogrid->key = 'n';
nogrid->description = _("Disable grid drawing");
nogrid->guisection = _("Disable");
noborder = G_define_flag();
noborder->key = 'b';
noborder->description = _("Disable border drawing");
noborder->guisection = _("Disable");
notext = G_define_flag();
notext->key = 't';
notext->description = _("Disable text drawing");
notext->guisection = _("Disable");
/* Check command line */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* do some checking */
if (nogrid->answer && noborder->answer)
G_fatal_error(_("Both grid and border drawing are disabled"));
if (wgs84->answer)
geogrid->answer = 1; /* -w implies -g */
if (geogrid->answer && G_projection() == PROJECTION_LL)
G_fatal_error(_("Geo-grid option not available for LL projection, use without -g/-w"));
if (geogrid->answer && G_projection() == PROJECTION_XY)
G_fatal_error(_("Geo-grid option not available for XY projection, use without -g/-w"));
if (notext->answer)
do_text = FALSE;
else
do_text = TRUE;
if (lwidth->answer) {
line_width = atoi(lwidth->answer);
if (line_width < 0 || line_width > 1e3)
G_fatal_error("Invalid line width");
}
else
line_width = 0;
fontsize = atoi(fsize->answer);
mark_type = MARK_GRID;
if (cross->answer + fiducial->answer + dot->answer > 1)
G_fatal_error(_("Choose a single mark style"));
if (cross->answer)
mark_type = MARK_CROSS;
if (fiducial->answer)
mark_type = MARK_FIDUCIAL;
if (dot->answer)
mark_type = MARK_DOT;
if (G_strcasecmp(direction->answer, "both") == 0)
dirn = DIRN_BOTH;
else if (G_strcasecmp(direction->answer, "east-west") == 0)
dirn = DIRN_LAT;
else if (G_strcasecmp(direction->answer, "north-south") == 0)
dirn = DIRN_LON;
else
G_fatal_error("Invalid direction: %s", direction->answer);
if (align->answer || strcmp(opt2->answer, "0") == 0)
G_get_element_window(&wind, "", "WIND", G_mapset());
if (strcmp(opt2->answer, "0") == 0) {
if (geogrid->answer)
gsize = wind.ns_res;
else
size = wind.ns_res;
}
else {
/* get grid size */
if (geogrid->answer) {
if (!G_scan_resolution(opt2->answer, &gsize, PROJECTION_LL) ||
gsize <= 0.0)
G_fatal_error(_("Invalid geo-grid size <%s>"), opt2->answer);
}
else {
if (!G_scan_resolution(opt2->answer, &size, G_projection()) ||
size <= 0.0)
G_fatal_error(_("Invalid grid size <%s>"), opt2->answer);
}
}
if (align->answer) {
/* reduce accumulated errors when ew_res is not the same as ns_res. */
struct Cell_head w;
G_get_set_window(&w);
east =
wind.west +
(int)((w.west - wind.west) / wind.ew_res) * wind.ew_res;
north =
wind.south +
(int)((w.south - wind.south) / wind.ns_res) * wind.ns_res;
}
else {
/* get grid easting start */
if (!G_scan_easting(opt3->answers[0], &east, G_projection())) {
G_usage();
G_fatal_error(_("Illegal east coordinate <%s>"),
opt3->answers[0]);
}
/* get grid northing start */
if (!G_scan_northing(opt3->answers[1], &north, G_projection())) {
G_usage();
G_fatal_error(_("Illegal north coordinate <%s>"),
opt3->answers[1]);
}
}
/* Setup driver and check important information */
D_open_driver();
/* Parse and select grid color */
colorg = D_parse_color(opt1->answer, FALSE);
/* Parse and select border color */
colorb = D_parse_color(opt4->answer, FALSE);
/* Parse and select text color */
colort = D_parse_color(tcolor->answer, FALSE);
/* Parse and select background color */
colorbg = D_parse_color(bgcolor->answer, TRUE);
D_setup(0);
/* draw grid */
if (!nogrid->answer) {
if (geogrid->answer) {
/* initialzie proj stuff */
init_proj(&info_in, &info_out, wgs84->answer);
plot_geogrid(gsize, info_in, info_out, do_text, colorg, colort,
colorbg, fontsize, mark_type, line_width, dirn);
}
else {
/* Do the grid plotting */
plot_grid(size, east, north, do_text, colorg, colort, colorbg,
fontsize, mark_type, line_width, dirn);
}
}
/* Draw border */
if (!noborder->answer) {
/* Set border color */
D_use_color(colorb);
/* Do the border plotting */
plot_border(size, east, north, dirn);
}
D_save_command(G_recreate_command());
D_close_driver();
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
char *mapset;
int o_method;
struct GModule *module;
struct Option *method, *basemap, *covermap, *outputmap;
struct Flag *flag_c;
struct Categories cats;
char methods[1024];
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("raster, statistics");
module->description =
_("Calculates category or object oriented statistics.");
basemap = G_define_standard_option(G_OPT_R_BASE);
covermap = G_define_standard_option(G_OPT_R_COVER);
for (o_method = 0; menu[o_method].name; o_method++) {
if (o_method)
strcat(methods, ",");
else
*(methods) = 0;
strcat(methods, menu[o_method].name);
}
method = G_define_option();
method->key = "method";
method->type = TYPE_STRING;
method->required = YES;
method->description = _("Method of object-based statistic");
method->options = methods;
outputmap = G_define_standard_option(G_OPT_R_OUTPUT);
outputmap->description =
_("Resultant raster map (not used with 'distribution')");
outputmap->required = NO;
flag_c = G_define_flag();
flag_c->key = 'c';
flag_c->description =
_("Cover values extracted from the category labels of the cover map");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if ((mapset = G_find_cell2(basemap->answer, "")) == 0)
G_fatal_error(_("Raster map <%s> not found"), basemap->answer);
if (G_raster_map_is_fp(basemap->answer, mapset) != 0)
G_fatal_error(_("This module currently only works for integer (CELL) maps"));
if ((mapset = G_find_cell2(covermap->answer, "")) == 0)
G_fatal_error(_("Raster map <%s> not found"), covermap->answer);
if (G_raster_map_is_fp(covermap->answer, mapset) != 0)
G_fatal_error(_("This module currently only works for integer (CELL) maps"));
if (G_read_cats(covermap->answer, mapset, &cats) < 0) {
G_fatal_error(_("Unable to read category file of raster map <%s@%s>"),
covermap->answer, mapset);
}
for (o_method = 0; menu[o_method].name; o_method++)
if (strcmp(menu[o_method].name, method->answer) == 0)
break;
if (!menu[o_method].name) {
G_warning(_("<%s=%s> unknown %s"), method->key, method->answer,
method->key);
G_usage();
exit(EXIT_FAILURE);
}
switch (menu[o_method].val) {
case DISTRIB:
if (outputmap->answer != NULL)
G_warning(_("Output map <%s> ignored"), outputmap->answer);
o_distrib(basemap->answer, covermap->answer,
outputmap->answer, flag_c->answer);
break;
case AVERAGE:
is_ok(method->answer, outputmap->answer);
o_average(basemap->answer, covermap->answer,
outputmap->answer, flag_c->answer, &cats);
break;
case MODE:
is_ok(method->answer, outputmap->answer);
o_mode(basemap->answer, covermap->answer,
outputmap->answer, flag_c->answer, &cats);
break;
case ADEV:
is_ok(method->answer, outputmap->answer);
o_adev(basemap->answer, covermap->answer,
outputmap->answer, flag_c->answer, &cats);
break;
case SDEV:
is_ok(method->answer, outputmap->answer);
o_sdev(basemap->answer, covermap->answer,
outputmap->answer, flag_c->answer, &cats);
break;
case VARIANC:
is_ok(method->answer, outputmap->answer);
o_var(basemap->answer, covermap->answer,
outputmap->answer, flag_c->answer, &cats);
break;
case SKEWNES:
is_ok(method->answer, outputmap->answer);
o_skew(basemap->answer, covermap->answer,
outputmap->answer, flag_c->answer, &cats);
break;
case KURTOSI:
is_ok(method->answer, outputmap->answer);
o_kurt(basemap->answer, covermap->answer,
outputmap->answer, flag_c->answer, &cats);
break;
case MEDIAN:
is_ok(method->answer, outputmap->answer);
o_median(basemap->answer, covermap->answer,
outputmap->answer, flag_c->answer, &cats);
break;
case MIN:
is_ok(method->answer, outputmap->answer);
o_min(basemap->answer, covermap->answer,
outputmap->answer, flag_c->answer, &cats);
break;
case MAX:
is_ok(method->answer, outputmap->answer);
o_max(basemap->answer, covermap->answer,
outputmap->answer, flag_c->answer, &cats);
break;
case SUM:
is_ok(method->answer, outputmap->answer);
o_sum(basemap->answer, covermap->answer,
outputmap->answer, flag_c->answer, &cats);
break;
case DIV:
is_ok(method->answer, outputmap->answer);
o_divr(basemap->answer, covermap->answer,
outputmap->answer, flag_c->answer, &cats);
break;
default:
G_fatal_error(_("Not yet implemented!"));
}
return 0;
}
int main(int argc, char **argv)
{
int colorg = 0;
int colorb = 0;
int colort = 0;
double size = 0., gsize = 0.; /* initialize to zero */
double east, north;
int do_text, fontsize, mark_type, line_width;
struct GModule *module;
struct Option *opt1, *opt2, *opt3, *opt4, *fsize, *tcolor, *lwidth;
struct Flag *noborder, *notext, *geogrid, *nogrid, *wgs84, *cross,
*fiducial, *dot;
struct pj_info info_in; /* Proj structures */
struct pj_info info_out; /* Proj structures */
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("display, cartography");
module->description =
_("Overlays a user-specified grid "
"in the active display frame on the graphics monitor.");
opt2 = G_define_option();
opt2->key = "size";
opt2->key_desc = "value";
opt2->type = TYPE_STRING;
opt2->required = YES;
opt2->label = _("Size of grid to be drawn");
opt2->description = _("In map units or DDD:MM:SS format. "
"Example: \"1000\" or \"0:10\"");
opt3 = G_define_option();
opt3->key = "origin";
opt3->type = TYPE_STRING;
opt3->key_desc = "easting,northing";
opt3->answer = "0,0";
opt3->multiple = NO;
opt3->description = _("Lines of the grid pass through this coordinate");
lwidth = G_define_option();
lwidth->key = "width";
lwidth->type = TYPE_DOUBLE;
lwidth->required = NO;
lwidth->description = _("Grid line width");
opt1 = G_define_standard_option(G_OPT_C_FG);
opt1->answer = "gray";
opt1->label = _("Grid color");
opt1->guisection = _("Color");
opt4 = G_define_standard_option(G_OPT_C_FG);
opt4->key = "bordercolor";
opt4->label = _("Border color");
opt4->guisection = _("Color");
tcolor = G_define_standard_option(G_OPT_C_FG);
tcolor->key = "textcolor";
tcolor->answer = "gray";
tcolor->label = _("Text color");
tcolor->guisection = _("Color");
fsize = G_define_option();
fsize->key = "fontsize";
fsize->type = TYPE_INTEGER;
fsize->required = NO;
fsize->answer = "9";
fsize->options = "1-72";
fsize->description = _("Font size for gridline coordinate labels");
geogrid = G_define_flag();
geogrid->key = 'g';
geogrid->description =
_("Draw geographic grid (referenced to current ellipsoid)");
wgs84 = G_define_flag();
wgs84->key = 'w';
wgs84->description =
_("Draw geographic grid (referenced to WGS84 ellipsoid)");
cross = G_define_flag();
cross->key = 'c';
cross->description = _("Draw '+' marks instead of grid lines");
dot = G_define_flag();
dot->key = 'd';
dot->description = _("Draw '.' marks instead of grid lines");
fiducial = G_define_flag();
fiducial->key = 'f';
fiducial->description = _("Draw fiducial marks instead of grid lines");
nogrid = G_define_flag();
nogrid->key = 'n';
nogrid->description = _("Disable grid drawing");
nogrid->guisection = _("Disable");
noborder = G_define_flag();
noborder->key = 'b';
noborder->description = _("Disable border drawing");
noborder->guisection = _("Disable");
notext = G_define_flag();
notext->key = 't';
notext->description = _("Disable text drawing");
notext->guisection = _("Disable");
/* Check command line */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* do some checking */
if (nogrid->answer && noborder->answer)
G_fatal_error(_("Both grid and border drawing are disabled"));
if (wgs84->answer)
geogrid->answer = 1; /* -w implies -g */
if (geogrid->answer && G_projection() == PROJECTION_LL)
G_fatal_error(_("Geo-Grid option is not available for LL projection"));
if (geogrid->answer && G_projection() == PROJECTION_XY)
G_fatal_error(_("Geo-Grid option is not available for XY projection"));
if (notext->answer)
do_text = FALSE;
else
do_text = TRUE;
if (lwidth->answer) {
line_width = atoi(lwidth->answer);
if(line_width < 0 || line_width > 1e3)
G_fatal_error("Invalid line width.");
}
else
line_width = 0;
fontsize = atoi(fsize->answer);
mark_type = MARK_GRID;
if (cross->answer + fiducial->answer + dot->answer > 1)
G_fatal_error(_("Choose a single mark style"));
if (cross->answer)
mark_type = MARK_CROSS;
if (fiducial->answer)
mark_type = MARK_FIDUCIAL;
if (dot->answer)
mark_type = MARK_DOT;
/* get grid size */
if (geogrid->answer) {
if (!G_scan_resolution(opt2->answer, &gsize, PROJECTION_LL) ||
gsize <= 0.0)
G_fatal_error(_("Invalid geo-grid size <%s>"), opt2->answer);
}
else {
if (!G_scan_resolution(opt2->answer, &size, G_projection()) ||
size <= 0.0)
G_fatal_error(_("Invalid grid size <%s>"), opt2->answer);
}
/* get grid easting start */
if (!G_scan_easting(opt3->answers[0], &east, G_projection())) {
G_usage();
G_fatal_error(_("Illegal east coordinate <%s>"), opt3->answers[0]);
}
/* get grid northing start */
if (!G_scan_northing(opt3->answers[1], &north, G_projection())) {
G_usage();
G_fatal_error(_("Illegal north coordinate <%s>"), opt3->answers[1]);
}
/* Setup driver and check important information */
if (R_open_driver() != 0)
G_fatal_error(_("No graphics device selected"));
/* Parse and select grid color */
colorg = D_parse_color(opt1->answer, FALSE);
/* Parse and select border color */
colorb = D_parse_color(opt4->answer, FALSE);
/* Parse and select text color */
colort = D_parse_color(tcolor->answer, FALSE);
D_setup(0);
/* draw grid */
if (!nogrid->answer) {
if (geogrid->answer) {
/* initialzie proj stuff */
init_proj(&info_in, &info_out, wgs84->answer);
plot_geogrid(gsize, info_in, info_out, do_text, colorg, colort,
fontsize, mark_type, line_width);
}
else {
/* Do the grid plotting */
plot_grid(size, east, north, do_text, colorg, colort, fontsize,
mark_type, line_width);
}
}
/* Draw border */
if (!noborder->answer) {
/* Set border color */
D_raster_use_color(colorb);
/* Do the border plotting */
plot_border(size, east, north);
}
D_add_to_list(G_recreate_command());
R_close_driver();
exit(EXIT_SUCCESS);
}
int viz_calc_tvals(cmndln_info * linefax, char **a_levels, char *a_min,
char *a_max, char *a_step, char *a_tnum, int quiet)
{
double interval; /*increment tvalue for intervals */
float datarange; /*diff btwn min and max data tvalues */
float tval; /*the threshold value being computed */
float min, max;
int ithresh;
int do_interval = 0;
int i; /*looping variable */
/*
** Note that the maximum number of thresholds
** that are computed is 127. This is to set a cap on the size of the
** display file that is created */
/* If levels are specified, only use those. Otherwise, if step is
specified use that, otherwise use number of thresholds */
min = Headfax.min;
max = Headfax.max;
if (a_min)
sscanf(a_min, "%f", &min);
if (a_max)
sscanf(a_max, "%f", &max);
datarange = max - min;
if (datarange <= 0.0)
G_fatal_error("range error: %f", datarange);
if (a_levels) {
for (i = 0; a_levels[i]; i++) {
if (i == MAXTHRESH) {
G_warning("maximum no. of thresholds is %d", MAXTHRESH);
break;
}
if (1 != sscanf(a_levels[i], "%f", &(linefax->tvalue[i]))) {
G_usage();
exit(0);
}
}
linefax->nthres = i;
}
else if (a_step) {
sscanf(a_step, "%lf", &interval);
do_interval = 1;
}
else if (a_tnum) { /* should already be default even if not specified */
sscanf(a_tnum, "%d", &ithresh);
if (ithresh < 2) {
ithresh = 2;
G_warning("Minimum number of thresholds is 2");
}
interval = datarange / (ithresh - 1);
do_interval = 1;
}
else { /* should never get here */
G_usage();
exit(0);
}
if (do_interval) {
for (i = 0, tval = min; tval <= max; i++, tval = min + (i * interval)) {
if (i == MAXTHRESH) {
G_warning("maximum no. of thresholds is %d", MAXTHRESH);
break;
}
linefax->tvalue[i] = tval;
}
linefax->nthres = i;
}
if (!quiet) {
fprintf(stderr, "threshold values: ");
for (i = 0; i < linefax->nthres; i++)
fprintf(stderr, "%f ", linefax->tvalue[i]);
G_message("\nNo. of thresholds: %i", linefax->nthres + 1);
}
return (0);
}
int main(int argc, char *argv[])
{
int col, row;
/* to menage start (source) raster map */
struct Range start_range;
CELL start_range_min, start_range_max;
int start_is_time; /* 0 or 1 */
struct
{
struct Option *max, *dir, *base, *start,
*spotdist, *velocity, *mois,
*least, *comp_dens, *init_time,
*time_lag, *backdrop, *out, *x_out, *y_out;
} parm;
struct
{
/* please, remove display before GRASS 7 released */
struct Flag *display, *spotting, *start_is_time;
} flag;
struct GModule *module;
/* initialize access to database and create temporary files */
G_gisinit(argv[0]);
/* Set description */
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("fire"));
G_add_keyword(_("spread"));
G_add_keyword(_("hazard"));
module->label =
_("Simulates elliptically anisotropic spread.");
module->description =
_("Generates a raster map of the cumulative time of spread, "
"given raster maps containing the rates of spread (ROS), "
"the ROS directions and the spread origins. "
"It optionally produces raster maps to contain backlink UTM "
"coordinates for tracing spread paths. "
"Usable for fire spread simulations.");
parm.max = G_define_option();
parm.max->key = "max";
parm.max->type = TYPE_STRING;
parm.max->required = YES;
parm.max->gisprompt = "old,cell,raster";
parm.max->guisection = _("Input maps");
parm.max->label =
_("Raster map containing maximal ROS (cm/min)");
parm.max->description =
_("Name of an existing raster map layer in the user's current "
"mapset search path containing the maximum ROS values (cm/minute).");
parm.dir = G_define_option();
parm.dir->key = "dir";
parm.dir->type = TYPE_STRING;
parm.dir->required = YES;
parm.dir->gisprompt = "old,cell,raster";
parm.dir->guisection = _("Input maps");
parm.dir->label =
_("Raster map containing directions of maximal ROS (degree)");
parm.dir->description =
_("Name of an existing raster map layer in the user's "
"current mapset search path containing directions of the maximum ROSes, "
"clockwise from north (degree)."); /* TODO: clockwise from north? see r.ros */
parm.base = G_define_option();
parm.base->key = "base";
parm.base->type = TYPE_STRING;
parm.base->required = YES;
parm.base->gisprompt = "old,cell,raster";
parm.base->guisection = _("Input maps");
parm.base->label =
_("Raster map containing base ROS (cm/min)");
parm.base->description =
_("Name of an existing raster map layer in the user's "
"current mapset search path containing the ROS values in the directions "
"perpendicular to maximum ROSes' (cm/minute). These ROSes are also the ones "
"without the effect of directional factors.");
parm.start = G_define_option();
parm.start->key = "start";
parm.start->type = TYPE_STRING;
parm.start->required = YES;
parm.start->gisprompt = "old,cell,raster";
parm.start->guisection = _("Input maps");
parm.start->description =
_("Raster map containing starting sources");
parm.start->description =
_("Name of an existing raster map layer in the "
"user's current mapset search path containing starting locations of the "
"spread phenomenon. Any positive integers in this map are recognized as "
"starting sources (seeds).");
parm.spotdist = G_define_option();
parm.spotdist->key = "spot_dist";
parm.spotdist->type = TYPE_STRING;
parm.spotdist->gisprompt = "old,cell,raster";
parm.spotdist->guisection = _("Input maps");
parm.spotdist->label =
_("Raster map containing maximal spotting distance (m, required with -s)");
parm.spotdist->description =
_("Name of an existing raster map layer in "
"the user's current mapset search path containing the maximum potential "
"spotting distances (meters).");
parm.velocity = G_define_option();
parm.velocity->key = "w_speed";
parm.velocity->type = TYPE_STRING;
parm.velocity->gisprompt = "old,cell,raster";
parm.velocity->guisection = _("Input maps");
parm.velocity->label =
_("Raster map containing midflame wind speed (ft/min, required with -s)");
parm.velocity->description =
_("Name of an existing raster map layer in the "
"user's current mapset search path containing wind velocities at half of "
"the average flame height (feet/minute).");
parm.mois = G_define_option();
parm.mois->key = "f_mois";
parm.mois->type = TYPE_STRING;
parm.mois->gisprompt = "old,cell,raster";
parm.mois->guisection = _("Input maps");
parm.mois->label =
_("Raster map containing fine fuel moisture of the cell receiving a spotting firebrand (%, required with -s)");
parm.mois->description =
_("Name of an existing raster map layer in the "
"user's current mapset search path containing the 1-hour (<.25\") fuel "
"moisture (percentage content multiplied by 100).");
parm.least = G_define_option();
parm.least->key = "least_size";
parm.least->type = TYPE_STRING;
parm.least->key_desc = "odd int";
parm.least->options = "3,5,7,9,11,13,15";
parm.least->description =
_("Basic sampling window size needed to meet certain accuracy (3)"); /* TODO: what is 3 here? default? */
parm.least->description =
_("An odd integer ranging 3 - 15 indicating "
"the basic sampling window size within which all cells will be considered "
"to see whether they will be reached by the current spread cell. The default "
"number is 3 which means a 3x3 window.");
parm.comp_dens = G_define_option();
parm.comp_dens->key = "comp_dens";
parm.comp_dens->type = TYPE_STRING;
parm.comp_dens->key_desc = "decimal";
parm.comp_dens->label =
_("Sampling density for additional computing (range: 0.0 - 1.0 (0.5))"); /* TODO: again, what is 0.5?, TODO: range not set */
parm.comp_dens->description =
_("A decimal number ranging 0.0 - 1.0 indicating "
"additional sampling cells will be considered to see whether they will be "
"reached by the current spread cell. The closer to 1.0 the decimal number "
"is, the longer the program will run and the higher the simulation accuracy "
"will be. The default number is 0.5.");
parm.init_time = G_define_option();
parm.init_time->key = "init_time";
parm.init_time->type = TYPE_STRING;
parm.init_time->key_desc = "int (>= 0)"; /* TODO: move to ->options */
parm.init_time->answer = "0";
parm.init_time->label =
_("Initial time for current simulation (0) (min)");
parm.init_time->description =
_("A non-negative number specifying the initial "
"time for the current spread simulation (minutes). This is useful when multiple "
"phase simulation is conducted. The default time is 0.");
parm.time_lag = G_define_option();
parm.time_lag->key = "lag";
parm.time_lag->type = TYPE_STRING;
parm.time_lag->key_desc = "int (>= 0)"; /* TODO: move to ->options */
parm.time_lag->description =
_("Simulating time duration LAG (fill the region) (min)"); /* TODO: what does this mean? */
parm.time_lag->description =
_("A non-negative integer specifying the simulating "
"duration time lag (minutes). The default is infinite, but the program will "
"terminate when the current geographic region/mask has been filled. It also "
"controls the computational time, the shorter the time lag, the faster the "
"program will run.");
/* TODO: what's this? probably display, so remove */
parm.backdrop = G_define_option();
parm.backdrop->key = "backdrop";
parm.backdrop->type = TYPE_STRING;
parm.backdrop->gisprompt = "old,cell,raster";
parm.backdrop->label =
_("Name of raster map as a display backdrop");
parm.backdrop->description =
_("Name of an existing raster map layer in the "
"user's current mapset search path to be used as the background on which "
"the \"live\" movement will be shown.");
parm.out = G_define_option();
parm.out->key = "output";
parm.out->type = TYPE_STRING;
parm.out->required = YES;
parm.out->gisprompt = "new,cell,raster";
parm.out->guisection = _("Output maps");
parm.out->label =
_("Raster map to contain output spread time (min)");
parm.out->description =
_("Name of the new raster map layer to contain "
"the results of the cumulative spread time needed for a phenomenon to reach "
"each cell from the starting sources (minutes).");
parm.x_out = G_define_option();
parm.x_out->key = "x_output";
parm.x_out->type = TYPE_STRING;
parm.x_out->gisprompt = "new,cell,raster";
parm.x_out->guisection = _("Output maps");
parm.x_out->label =
_("Name of raster map to contain X back coordinates");
parm.x_out->description =
_("Name of the new raster map layer to contain "
"the results of backlink information in UTM easting coordinates for each "
"cell.");
parm.y_out = G_define_option();
parm.y_out->key = "y_output";
parm.y_out->type = TYPE_STRING;
parm.y_out->gisprompt = "new,cell,raster";
parm.y_out->guisection = _("Output maps");
parm.y_out->label =
_("Name of raster map to contain Y back coordinates");
parm.y_out->description =
_("Name of the new raster map layer to contain "
"the results of backlink information in UTM northing coordinates for each "
"cell.");
flag.display = G_define_flag();
flag.display->key = 'd';
#if 0
flag.display->label = _("DISPLAY 'live' spread process on screen");
flag.display->description =
_("Display the 'live' simulation on screen. A graphics window "
"must be opened and selected before using this option.");
#else
flag.display->description = _("Live display - disabled and depreciated");
#endif
flag.spotting = G_define_flag();
flag.spotting->key = 's';
flag.spotting->description = _("Consider spotting effect (for wildfires)");
flag.start_is_time = G_define_flag();
flag.start_is_time->key = 'i';
flag.start_is_time->label = _("Use start raster map values in"
" output spread time raster map");
flag.start_is_time->description = _("Designed to be used with output"
" of previous run of r.spread when computing spread iteratively."
" The values in start raster map are considered as time."
" Allowed values in raster map are from zero"
" to the value of init_time option."
" If not enabled, init_time is used in the area of start raster map");
/* Parse command line */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* FIXME - allow seed to be specified for repeatability */
G_srand48_auto();
display = flag.display->answer;
#if 1
if (display)
G_fatal_error(_("The display feature is disabled"));
#endif
spotting = flag.spotting->answer;
max_layer = parm.max->answer;
dir_layer = parm.dir->answer;
base_layer = parm.base->answer;
start_layer = parm.start->answer;
backdrop_layer = parm.backdrop->answer;
out_layer = parm.out->answer;
if (parm.x_out->answer) {
x_out = 1;
x_out_layer = parm.x_out->answer;
}
if (parm.y_out->answer) {
y_out = 1;
y_out_layer = parm.y_out->answer;
}
if (spotting) {
if (!
(parm.spotdist->answer && parm.velocity->answer &&
parm.mois->answer)) {
G_warning
("SPOTTING DISTANCE, fuel MOISTURE, or wind VELOCITY map not given w/ -s");
G_usage();
exit(EXIT_FAILURE);
}
else {
spotdist_layer = parm.spotdist->answer;
velocity_layer = parm.velocity->answer;
mois_layer = parm.mois->answer;
}
}
/*Check the given the least sampling size, assign the default if needed */
if (parm.least->answer)
least = atoi(parm.least->answer);
else
least = 3;
/*Check the given computing density, assign the default if needed */
if (parm.comp_dens->answer) {
comp_dens = atof(parm.comp_dens->answer);
if (comp_dens < 0.0 || comp_dens > 1.0) {
G_warning("Illegal computing density <%s>",
parm.comp_dens->answer);
G_usage();
exit(EXIT_FAILURE);
}
}
else {
comp_dens = 0.5;
}
/*Check the given initial time and simulation time lag, assign the default if needed */
init_time = atoi(parm.init_time->answer);
if (init_time < 0) {
G_warning("Illegal initial time <%s>", parm.init_time->answer);
G_usage();
exit(EXIT_FAILURE);
}
if (parm.time_lag->answer) {
time_lag = atoi(parm.time_lag->answer);
if (time_lag < 0) {
G_warning("Illegal simulating time lag <%s>",
parm.time_lag->answer);
G_usage();
exit(EXIT_FAILURE);
}
}
else {
time_lag = 99999;
}
/* Get database window parameters */
G_get_window(&window);
/* find number of rows and columns in window */
nrows = Rast_window_rows();
ncols = Rast_window_cols();
/*transfor measurement unit from meters to centimeters due to ROS unit
*if the input ROSs are in m/min units, cancell the following*/
window.ns_res = 100 * window.ns_res;
window.ew_res = 100 * window.ew_res;
/* Initialize display screens */
#if 0
if (display)
display_init();
#endif
/* Check if input layers exists in data base */
if (G_find_raster2(max_layer, "") == NULL)
G_fatal_error("Raster map <%s> not found", max_layer);
if (G_find_raster2(dir_layer, "") == NULL)
G_fatal_error(_("Raster map <%s> not found"), dir_layer);
if (G_find_raster2(base_layer, "") == NULL)
G_fatal_error(_("Raster map <%s> not found"), base_layer);
if (G_find_raster2(start_layer, "") == NULL)
G_fatal_error(_("Raster map <%s> not found"), start_layer);
if (spotting) {
if (G_find_raster2(spotdist_layer, "") == NULL)
G_fatal_error(_("Raster map <%s> not found"), spotdist_layer);
if (G_find_raster2(velocity_layer, "") == NULL)
G_fatal_error(_("Raster map <%s> not found"), velocity_layer);
if (G_find_raster2(mois_layer, "") == NULL)
G_fatal_error(_("Raster map <%s> not found"), mois_layer);
}
/* Open input cell layers for reading */
max_fd = Rast_open_old(max_layer, G_find_raster2(max_layer, ""));
dir_fd = Rast_open_old(dir_layer, G_find_raster2(dir_layer, ""));
base_fd = Rast_open_old(base_layer, G_find_raster2(base_layer, ""));
if (spotting) {
spotdist_fd =
Rast_open_old(spotdist_layer, G_find_raster2(spotdist_layer, ""));
velocity_fd =
Rast_open_old(velocity_layer, G_find_raster2(velocity_layer, ""));
mois_fd = Rast_open_old(mois_layer, G_find_raster2(mois_layer, ""));
}
/* Allocate memories for a row */
cell = Rast_allocate_c_buf();
if (x_out)
x_cell = Rast_allocate_c_buf();
if (y_out)
y_cell = Rast_allocate_c_buf();
/* Allocate memories for a map */
map_max = (CELL *) G_calloc(nrows * ncols + 1, sizeof(CELL));
map_dir = (CELL *) G_calloc(nrows * ncols + 1, sizeof(CELL));
map_base = (CELL *) G_calloc(nrows * ncols + 1, sizeof(CELL));
map_visit = (CELL *) G_calloc(nrows * ncols + 1, sizeof(CELL));
map_out = (float *)G_calloc(nrows * ncols + 1, sizeof(float));
if (spotting) {
map_spotdist = (CELL *) G_calloc(nrows * ncols + 1, sizeof(CELL));
map_velocity = (CELL *) G_calloc(nrows * ncols + 1, sizeof(CELL));
map_mois = (CELL *) G_calloc(nrows * ncols + 1, sizeof(CELL));
}
if (x_out)
map_x_out = (CELL *) G_calloc(nrows * ncols + 1, sizeof(CELL));
if (y_out)
map_y_out = (CELL *) G_calloc(nrows * ncols + 1, sizeof(CELL));
/* Write the input layers in the map "arrays" */
G_message(_("Reading inputs..."));
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
Rast_get_c_row(max_fd, cell, row);
for (col = 0; col < ncols; col++)
DATA(map_max, row, col) = cell[col];
Rast_get_c_row(dir_fd, cell, row);
for (col = 0; col < ncols; col++)
DATA(map_dir, row, col) = cell[col];
Rast_get_c_row(base_fd, cell, row);
for (col = 0; col < ncols; col++)
DATA(map_base, row, col) = cell[col];
if (spotting) {
Rast_get_c_row(spotdist_fd, cell, row);
for (col = 0; col < ncols; col++)
DATA(map_spotdist, row, col) = cell[col];
Rast_get_c_row(velocity_fd, cell, row);
for (col = 0; col < ncols; col++)
DATA(map_velocity, row, col) = cell[col];
Rast_get_c_row(mois_fd, cell, row);
for (col = 0; col < ncols; col++)
DATA(map_mois, row, col) = cell[col];
}
}
G_percent(row, nrows, 2);
/* Scan the START layer searching for starting points.
* Create an array of starting points (min_heap) ordered by costs.
*/
start_fd = Rast_open_old(start_layer, G_find_raster2(start_layer, ""));
Rast_read_range(start_layer, G_find_file("cell", start_layer, ""),
&start_range);
Rast_get_range_min_max(&start_range, &start_range_min, &start_range_max);
start_is_time = flag.start_is_time->answer;
/* values higher than init_time are unexpected and may cause segfaults */
if (start_is_time && start_range_max > init_time)
G_fatal_error(_("Maximum of start raster map is grater than init_time"
" (%d > %d)"), start_range_max, init_time);
/* values lower then zero does not make sense for time */
if (start_is_time && start_range_min < 0)
G_fatal_error(_("Minimum of start raster map is less than zero"
" (%d < 0)"), start_range_min, init_time);
/* Initialize the heap */
heap =
(struct costHa *)G_calloc(nrows * ncols + 1, sizeof(struct costHa));
heap_len = 0;
G_message(_("Reading %s..."), start_layer);
G_debug(1, "Collecting origins...");
collect_ori(start_fd, start_is_time);
G_debug(1, "Done");
/* Major computation of spread time */
G_debug(1, "Spreading...");
spread();
G_debug(1, "Done");
/* Open cumulative cost layer (and x, y direction layers) for writing */
cum_fd = Rast_open_c_new(out_layer);
if (x_out)
x_fd = Rast_open_c_new(x_out_layer);
if (y_out)
y_fd = Rast_open_c_new(y_out_layer);
/* prepare output -- adjust from cm to m */
window.ew_res = window.ew_res / 100;
window.ns_res = window.ns_res / 100;
/* copy maps in ram to output maps */
ram2out();
G_free(map_max);
G_free(map_dir);
G_free(map_base);
G_free(map_out);
G_free(map_visit);
if (x_out)
G_free(map_x_out);
if (y_out)
G_free(map_y_out);
if (spotting) {
G_free(map_spotdist);
G_free(map_mois);
G_free(map_velocity);
}
Rast_close(max_fd);
Rast_close(dir_fd);
Rast_close(base_fd);
Rast_close(start_fd);
Rast_close(cum_fd);
if (x_out)
Rast_close(x_fd);
if (y_out)
Rast_close(y_fd);
if (spotting) {
Rast_close(spotdist_fd);
Rast_close(velocity_fd);
Rast_close(mois_fd);
}
/* close graphics */
#if 0
if (display)
display_close();
#endif
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
double e1, n1, e2, n2;
char buf[256];
char command[2048];
int n, err;
int projection;
char *mapset;
char name[GNAME_MAX];
struct GModule *module;
struct
{
struct Option *map;
struct Option *line;
struct Option *null_str;
/* struct Option *width;
struct Option *result; */
} parms;
struct Flag *coord;
char coord_str[3];
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("raster, transect");
module->description =
_("Outputs raster map layer values lying along "
"user defined transect line(s).");
parms.map = G_define_standard_option(G_OPT_R_MAP);
parms.map->description = _("Raster map to be queried");
/* parms.result = G_define_option();
parms.result->key = "result";
parms.result->key_desc = "type";
parms.result->type = TYPE_STRING;
parms.result->description = _("Type of result to be output");
parms.result->required = NO;
parms.result->multiple = NO;
parms.result->options = "raw,median,average";
parms.result->answer = "raw";
*/
parms.line = G_define_option();
parms.line->key = "line";
parms.line->key_desc = "east,north,azimuth,distance";
parms.line->type = TYPE_STRING;
parms.line->description = _("Transect definition");
parms.line->required = YES;
parms.line->multiple = YES;
parms.null_str = G_define_option();
parms.null_str->key = "null";
parms.null_str->type = TYPE_STRING;
parms.null_str->required = NO;
parms.null_str->answer = "*";
parms.null_str->description = _("Char string to represent no data cell");
/* parms.width = G_define_option();
parms.width->key = "width";
parms.width->type = TYPE_INTEGER;
parms.width->description = _("Transect width, in cells (odd number)");
parms.width->answer = "1";
*/
coord = G_define_flag();
coord->key = 'g';
coord->description =
_("Output easting and northing in first two columns of four column output");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
projection = G_projection();
/* sscanf (parms.width->answer, "%d", &n);
if (n <= 0 || n%2 == 0)
{
fprintf(stderr,"<%s=%s> ** illegal value **\n",
parms.width->key, parms.width->answer);
G_usage();
exit(EXIT_FAILURE);
}
*/
strncpy(name, parms.map->answer, 255);
mapset = G_find_cell(name, "");
if (mapset == NULL)
G_fatal_error(_("Raster map <%s> not found"), name);
if (coord->answer)
strcpy(coord_str, "-g");
else
strcpy(coord_str, "");
sprintf(command,
"r.profile %s input=\"%s\" output=\"-\" null=\"%s\" profile=",
coord_str, parms.map->answer, parms.null_str->answer);
err = 0;
for (n = 0; parms.line->answers[n]; n += 4) {
err += parse_line(parms.line->key, parms.line->answers + n,
&e1, &n1, &e2, &n2, projection);
if (!err) {
if (n)
strcat(command, ",");
G_format_easting(e1, buf, projection);
strcat(command, buf);
G_format_northing(n1, buf, projection);
strcat(command, ",");
strcat(command, buf);
G_format_easting(e2, buf, projection);
strcat(command, ",");
strcat(command, buf);
G_format_northing(n2, buf, projection);
strcat(command, ",");
strcat(command, buf);
}
}
if (err) {
G_usage();
exit(EXIT_FAILURE);
}
G_verbose_message(_("End coordinate: %.15g, %.15g"), e2, n2);
exit(system(command));
}
void parse_command_line(int argc, char **argv)
{
struct Option *driver, *database, *table, *sql,
*fs, *vs, *nv, *input, *output;
struct Flag *c, *d, *v, *flag_test;
struct GModule *module;
const char *drv, *db;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
sql = G_define_standard_option(G_OPT_DB_SQL);
sql->guisection = _("Query");
input = G_define_standard_option(G_OPT_F_INPUT);
input->required = NO;
input->label = _("Name of file containing SQL select statement(s)");
input->description = _("'-' for standard input");
input->guisection = _("Query");
table = G_define_standard_option(G_OPT_DB_TABLE);
table->description = _("Name of table to query");
table->guisection = _("Query");
driver = G_define_standard_option(G_OPT_DB_DRIVER);
driver->options = db_list_drivers();
if ((drv = db_get_default_driver_name()))
driver->answer = (char *) drv;
driver->guisection = _("Connection");
database = G_define_standard_option(G_OPT_DB_DATABASE);
if ((db = db_get_default_database_name()))
database->answer = (char *) db;
database->guisection = _("Connection");
fs = G_define_standard_option(G_OPT_F_SEP);
fs->guisection = _("Format");
vs = G_define_standard_option(G_OPT_F_SEP);
vs->key = "vseparator";
vs->label = _("Vertical record separator (requires -v flag)");
vs->answer = NULL;
vs->guisection = _("Format");
nv = G_define_option();
nv->key = "nv";
nv->type = TYPE_STRING;
nv->required = NO;
nv->description = _("Null value indicator");
nv->guisection = _("Format");
output = G_define_standard_option(G_OPT_F_OUTPUT);
output->required = NO;
output->description =
_("Name for output file (if omitted or \"-\" output to stdout)");
c = G_define_flag();
c->key = 'c';
c->description = _("Do not include column names in output");
c->guisection = _("Format");
d = G_define_flag();
d->key = 'd';
d->description = _("Describe query only (don't run it)");
d->guisection = _("Query");
v = G_define_flag();
v->key = 'v';
v->description = _("Vertical output (instead of horizontal)");
v->guisection = _("Format");
flag_test = G_define_flag();
flag_test->key = 't';
flag_test->description = _("Only test query, do not execute");
flag_test->guisection = _("Query");
/* Set description */
module = G_define_module();
G_add_keyword(_("database"));
G_add_keyword(_("attribute table"));
G_add_keyword(_("SQL"));
module->label = _("Selects data from attribute table.");
module->description = _("Performs SQL query statement(s).");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
parms.driver = driver->answer;
parms.database = database->answer;
parms.table = table->answer;
parms.sql = sql->answer;
parms.fs = G_option_to_separator(fs);
parms.vs = '\0';
if (vs->answer)
parms.vs = G_option_to_separator(vs);
parms.nv = nv->answer;
parms.input = input->answer;
parms.output = output->answer;
if (!c->answer)
parms.c = TRUE;
else
parms.c = FALSE;
parms.d = d->answer;
if (!v->answer)
parms.h = TRUE;
else
parms.h = FALSE;
parms.test_only = flag_test->answer;
if (parms.input && *parms.input == 0) {
G_usage();
exit(EXIT_FAILURE);
}
if (!parms.input && !parms.sql && !parms.table)
G_fatal_error(_("You must provide one of these options: <%s>, <%s>, or <%s>"),
sql->key, input->key, table->key);
}
/* ************************************************************************* */
int main(int argc, char *argv[])
{
char *output = NULL;
RASTER3D_Region region;
struct Cell_head window2d;
struct Cell_head default_region;
FILE *fp = NULL;
struct GModule *module;
int dp, i, changemask = 0;
int rows, cols;
const char *mapset, *name;
double scale = 1.0, llscale = 1.0;
input_maps *in;
/* Initialize GRASS */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster3d"));
G_add_keyword(_("export"));
G_add_keyword(_("voxel"));
G_add_keyword("VTK");
module->description =
_("Converts 3D raster maps into the VTK-ASCII format.");
/* Get parameters from user */
set_params();
/* Have GRASS get inputs */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/*The precision of the output */
if (param.decimals->answer) {
if (sscanf(param.decimals->answer, "%d", &dp) != 1)
G_fatal_error(_("failed to interpret dp as an integer"));
if (dp > 20 || dp < 0)
G_fatal_error(_("dp has to be from 0 to 20"));
} else {
dp = 8; /*This value is taken from the lib settings in G_format_easting */
}
/*Check the input */
check_input_maps();
/*Correct the coordinates, so the precision of VTK is not hurt :( */
if (param.coorcorr->answer) {
/*Get the default region for coordiante correction */
G_get_default_window(&default_region);
/*Use the center of the current region as extent */
y_extent = (default_region.north + default_region.south) / 2;
x_extent = (default_region.west + default_region.east) / 2;
} else {
x_extent = 0;
y_extent = 0;
}
/*open the output */
if (param.output->answer) {
fp = fopen(param.output->answer, "w");
if (fp == NULL) {
perror(param.output->answer);
G_usage();
exit(EXIT_FAILURE);
}
} else
fp = stdout;
/* Figure out the region from the map */
Rast3d_init_defaults();
Rast3d_get_window(®ion);
/*initiate the input mpas structure */
in = create_input_maps_struct();
/* read and compute the scale factor */
sscanf(param.elevscale->answer, "%lf", &scale);
/*if LL projection, convert the elevation values to degrees */
if (param.scalell->answer && region.proj == PROJECTION_LL) {
llscale = M_PI / (180) * 6378137;
scale /= llscale;
}
/*Open the top and bottom file */
if (param.structgrid->answer) {
/*Check if the g3d-region is equal to the 2d rows and cols */
rows = Rast_window_rows();
cols = Rast_window_cols();
/*If not equal, set the 2D windows correct */
if (rows != region.rows || cols != region.cols) {
G_message(_("The 2D and 3D region settings are different. "
"Using the 2D window settings to adjust the 2D part of the 3D region."));
G_get_set_window(&window2d);
window2d.ns_res = region.ns_res;
window2d.ew_res = region.ew_res;
window2d.rows = region.rows;
window2d.cols = region.cols;
Rast_set_window(&window2d);
}
/*open top */
mapset = NULL;
name = NULL;
name = param.top->answer;
mapset = G_find_raster2(name, "");
in->top = open_input_map(name, mapset);
in->topMapType = Rast_get_map_type(in->top);
/*open bottom */
mapset = NULL;
name = NULL;
name = param.bottom->answer;
mapset = G_find_raster2(name, "");
in->bottom = open_input_map(name, mapset);
in->bottomMapType = Rast_get_map_type(in->bottom);
/* Write the vtk-header and the points */
if (param.point->answer) {
write_vtk_structured_grid_header(fp, output, region);
write_vtk_points(in, fp, region, dp, 1, scale);
} else {
write_vtk_unstructured_grid_header(fp, output, region);
write_vtk_points(in, fp, region, dp, 0, scale);
write_vtk_unstructured_grid_cells(fp, region);
}
Rast_close(in->top);
in->top = -1;
Rast_close(in->bottom);
in->bottom = -1;
} else {
/* Write the structured point vtk-header */
write_vtk_structured_point_header(fp, output, region, dp, scale);
}
/*Write the normal VTK data (cell or point data) */
/*Loop over all 3d input maps! */
if (param.input->answers != NULL) {
for (i = 0; param.input->answers[i] != NULL; i++) {
G_debug(3, "Open 3D raster map <%s>", param.input->answers[i]);
/*Open the map */
in->map =
Rast3d_open_cell_old(param.input->answers[i],
G_find_raster3d(param.input->answers[i], ""),
®ion, RASTER3D_TILE_SAME_AS_FILE,
RASTER3D_USE_CACHE_DEFAULT);
if (in->map == NULL) {
G_warning(_("Unable to open 3D raster map <%s>"),
param.input->answers[i]);
fatal_error(" ", in);
}
/*if requested set the Mask on */
if (param.mask->answer) {
if (Rast3d_mask_file_exists()) {
changemask = 0;
if (Rast3d_mask_is_off(in->map)) {
Rast3d_mask_on(in->map);
changemask = 1;
}
}
}
/* Write the point or cell data */
write_vtk_data(fp, in->map, region, param.input->answers[i], dp);
/*We set the Mask off, if it was off before */
if (param.mask->answer) {
if (Rast3d_mask_file_exists())
if (Rast3d_mask_is_on(in->map) && changemask)
Rast3d_mask_off(in->map);
}
/* Close the 3d raster map */
if (!Rast3d_close(in->map)) {
in->map = NULL;
fatal_error(_("Unable to close 3D raster map, the VTK file may be incomplete"),
in);
}
in->map = NULL;
}
}
/*Write the RGB voxel data */
open_write_rgb_maps(in, region, fp, dp);
open_write_vector_maps(in, region, fp, dp);
/*Close the output file */
if (param.output->answer && fp != NULL)
if (fclose(fp))
fatal_error(_("Unable to close VTK-ASCII file"), in);
/*close all open maps and free memory */
release_input_maps_struct(in);
return 0;
}
int main(int argc, char *argv[])
{
char *p;
int method;
int in_fd;
int selection_fd;
int out_fd;
DCELL *result;
char *selection;
RASTER_MAP_TYPE map_type;
int row, col;
int readrow;
int nrows, ncols;
int n;
int copycolr;
int half;
stat_func *newvalue;
stat_func_w *newvalue_w;
ifunc cat_names;
double quantile;
const void *closure;
struct Colors colr;
struct Cell_head cellhd;
struct Cell_head window;
struct History history;
struct GModule *module;
struct
{
struct Option *input, *output, *selection;
struct Option *method, *size;
struct Option *title;
struct Option *weight;
struct Option *gauss;
struct Option *quantile;
} parm;
struct
{
struct Flag *align, *circle;
} flag;
DCELL *values; /* list of neighborhood values */
DCELL(*values_w)[2]; /* list of neighborhood values and weights */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("algebra"));
G_add_keyword(_("statistics"));
module->description =
_("Makes each cell category value a "
"function of the category values assigned to the cells "
"around it, and stores new cell values in an output raster "
"map layer.");
parm.input = G_define_standard_option(G_OPT_R_INPUT);
parm.selection = G_define_standard_option(G_OPT_R_INPUT);
parm.selection->key = "selection";
parm.selection->required = NO;
parm.selection->description = _("Name of an input raster map to select the cells which should be processed");
parm.output = 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->answer = "average";
p = G_malloc(1024);
for (n = 0; menu[n].name; n++) {
if (n)
strcat(p, ",");
else
*p = 0;
strcat(p, menu[n].name);
}
parm.method->options = p;
parm.method->description = _("Neighborhood operation");
parm.method->guisection = _("Neighborhood");
parm.size = G_define_option();
parm.size->key = "size";
parm.size->type = TYPE_INTEGER;
parm.size->required = NO;
parm.size->description = _("Neighborhood size");
parm.size->answer = "3";
parm.size->guisection = _("Neighborhood");
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 of the output raster map");
parm.weight = G_define_standard_option(G_OPT_F_INPUT);
parm.weight->key = "weight";
parm.weight->required = NO;
parm.weight->description = _("Text file containing weights");
parm.gauss = G_define_option();
parm.gauss->key = "gauss";
parm.gauss->type = TYPE_DOUBLE;
parm.gauss->required = NO;
parm.gauss->description = _("Sigma (in cells) for Gaussian filter");
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.align = G_define_flag();
flag.align->key = 'a';
flag.align->description = _("Do not align output with the input");
flag.circle = G_define_flag();
flag.circle->key = 'c';
flag.circle->description = _("Use circular neighborhood");
flag.circle->guisection = _("Neighborhood");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
sscanf(parm.size->answer, "%d", &ncb.nsize);
if (ncb.nsize <= 0)
G_fatal_error(_("Neighborhood size must be positive"));
if (ncb.nsize % 2 == 0)
G_fatal_error(_("Neighborhood size must be odd"));
ncb.dist = ncb.nsize / 2;
if (parm.weight->answer && flag.circle->answer)
G_fatal_error(_("weight= and -c are mutually exclusive"));
if (parm.weight->answer && parm.gauss->answer)
G_fatal_error(_("weight= and gauss= are mutually exclusive"));
ncb.oldcell = parm.input->answer;
ncb.newcell = parm.output->answer;
if (!flag.align->answer) {
Rast_get_cellhd(ncb.oldcell, "", &cellhd);
G_get_window(&window);
Rast_align_window(&window, &cellhd);
Rast_set_window(&window);
}
nrows = Rast_window_rows();
ncols = Rast_window_cols();
/* open raster maps */
in_fd = Rast_open_old(ncb.oldcell, "");
map_type = Rast_get_map_type(in_fd);
/* get the method */
for (method = 0; (p = menu[method].name); method++)
if ((strcmp(p, parm.method->answer) == 0))
break;
if (!p) {
G_warning(_("<%s=%s> unknown %s"),
parm.method->key, parm.method->answer, parm.method->key);
G_usage();
exit(EXIT_FAILURE);
}
if (menu[method].method == c_quant) {
quantile = atoi(parm.quantile->answer);
closure = &quantile;
}
half = (map_type == CELL_TYPE) ? menu[method].half : 0;
/* establish the newvalue routine */
newvalue = menu[method].method;
newvalue_w = menu[method].method_w;
/* copy color table? */
copycolr = menu[method].copycolr;
if (copycolr) {
G_suppress_warnings(1);
copycolr =
(Rast_read_colors(ncb.oldcell, "", &colr) > 0);
G_suppress_warnings(0);
}
/* read the weights */
if (parm.weight->answer) {
read_weights(parm.weight->answer);
if (!newvalue_w)
weights_mask();
}
else if (parm.gauss->answer) {
if (!newvalue_w)
G_fatal_error(_("Method %s not compatible with Gaussian filter"), parm.method->answer);
gaussian_weights(atof(parm.gauss->answer));
}
else
newvalue_w = NULL;
/* allocate the cell buffers */
allocate_bufs();
result = Rast_allocate_d_buf();
/* get title, initialize the category and stat info */
if (parm.title->answer)
strcpy(ncb.title, parm.title->answer);
else
sprintf(ncb.title, "%dx%d neighborhood: %s of %s",
ncb.nsize, ncb.nsize, menu[method].name, ncb.oldcell);
/* initialize the cell bufs with 'dist' rows of the old cellfile */
readrow = 0;
for (row = 0; row < ncb.dist; row++)
readcell(in_fd, readrow++, nrows, ncols);
/* open the selection raster map */
if (parm.selection->answer) {
G_message(_("Opening selection map <%s>"), parm.selection->answer);
selection_fd = Rast_open_old(parm.selection->answer, "");
selection = Rast_allocate_null_buf();
} else {
selection_fd = -1;
selection = NULL;
}
/*open the new raster map */
out_fd = Rast_open_new(ncb.newcell, map_type);
if (flag.circle->answer)
circle_mask();
if (newvalue_w)
values_w =
(DCELL(*)[2]) G_malloc(ncb.nsize * ncb.nsize * 2 * sizeof(DCELL));
else
values = (DCELL *) G_malloc(ncb.nsize * ncb.nsize * sizeof(DCELL));
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
readcell(in_fd, readrow++, nrows, ncols);
if (selection)
Rast_get_null_value_row(selection_fd, selection, row);
for (col = 0; col < ncols; col++) {
DCELL *rp = &result[col];
if (selection && selection[col]) {
*rp = ncb.buf[ncb.dist][col];
continue;
}
if (newvalue_w)
n = gather_w(values_w, col);
else
n = gather(values, col);
if (n < 0)
Rast_set_d_null_value(rp, 1);
else {
if (newvalue_w)
newvalue_w(rp, values_w, n, closure);
else
newvalue(rp, values, n, closure);
if (half && !Rast_is_d_null_value(rp))
*rp += 0.5;
}
}
Rast_put_d_row(out_fd, result);
}
G_percent(row, nrows, 2);
Rast_close(out_fd);
Rast_close(in_fd);
if (selection)
Rast_close(selection_fd);
/* put out category info */
null_cats();
if ((cat_names = menu[method].cat_names))
cat_names();
Rast_write_cats(ncb.newcell, &ncb.cats);
if (copycolr)
Rast_write_colors(ncb.newcell, G_mapset(), &colr);
Rast_short_history(ncb.newcell, "raster", &history);
Rast_command_history(&history);
Rast_write_history(ncb.newcell, &history);
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
static DCELL *count, *sum, *mean, *sumu, *sum2, *sum3, *sum4, *min, *max;
DCELL *result;
struct GModule *module;
struct {
struct Option *method, *basemap, *covermap, *output;
} opt;
struct {
struct Flag *c, *r;
} flag;
char methods[2048];
const char *basemap, *covermap, *output;
int usecats;
int reclass;
int base_fd, cover_fd;
struct Categories cats;
CELL *base_buf;
DCELL *cover_buf;
struct Range range;
CELL mincat, ncats;
int method;
int rows, cols;
int row, col, i;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("statistics"));
module->description =
_("Calculates category or object oriented statistics (accumulator-based statistics).");
opt.basemap = G_define_standard_option(G_OPT_R_BASE);
opt.covermap = G_define_standard_option(G_OPT_R_COVER);
opt.method = G_define_option();
opt.method->key = "method";
opt.method->type = TYPE_STRING;
opt.method->required = YES;
opt.method->description = _("Method of object-based statistic");
for (i = 0; menu[i].name; i++) {
if (i)
strcat(methods, ",");
else
*(methods) = 0;
strcat(methods, menu[i].name);
}
opt.method->options = G_store(methods);
for (i = 0; menu[i].name; i++) {
if (i)
strcat(methods, ";");
else
*(methods) = 0;
strcat(methods, menu[i].name);
strcat(methods, ";");
strcat(methods, menu[i].text);
}
opt.method->descriptions = G_store(methods);
opt.output = G_define_standard_option(G_OPT_R_OUTPUT);
opt.output->description = _("Resultant raster map");
opt.output->required = YES;
flag.c = G_define_flag();
flag.c->key = 'c';
flag.c->description =
_("Cover values extracted from the category labels of the cover map");
flag.r = G_define_flag();
flag.r->key = 'r';
flag.r->description =
_("Create reclass map with statistics as category labels");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
basemap = opt.basemap->answer;
covermap = opt.covermap->answer;
output = opt.output->answer;
usecats = flag.c->answer;
reclass = flag.r->answer;
for (i = 0; menu[i].name; i++)
if (strcmp(menu[i].name, opt.method->answer) == 0)
break;
if (!menu[i].name) {
G_warning(_("<%s=%s> unknown %s"), opt.method->key, opt.method->answer,
opt.method->key);
G_usage();
exit(EXIT_FAILURE);
}
method = menu[i].val;
base_fd = Rast_open_old(basemap, "");
cover_fd = Rast_open_old(covermap, "");
if (usecats && Rast_read_cats(covermap, "", &cats) < 0)
G_fatal_error(_("Unable to read category file of cover map <%s>"), covermap);
if (Rast_map_is_fp(basemap, "") != 0)
G_fatal_error(_("The base map must be an integer (CELL) map"));
if (Rast_read_range(basemap, "", &range) < 0)
G_fatal_error(_("Unable to read range of base map <%s>"), basemap);
mincat = range.min;
ncats = range.max - range.min + 1;
rows = Rast_window_rows();
cols = Rast_window_cols();
switch (method) {
case COUNT:
count = G_calloc(ncats, sizeof(DCELL));
break;
case SUM:
sum = G_calloc(ncats, sizeof(DCELL));
break;
case MIN:
min = G_malloc(ncats * sizeof(DCELL));
break;
case MAX:
max = G_malloc(ncats * sizeof(DCELL));
break;
case RANGE:
min = G_malloc(ncats * sizeof(DCELL));
max = G_malloc(ncats * sizeof(DCELL));
break;
case AVERAGE:
case ADEV:
case VARIANCE2:
case STDDEV2:
case SKEWNESS2:
case KURTOSIS2:
count = G_calloc(ncats, sizeof(DCELL));
sum = G_calloc(ncats, sizeof(DCELL));
break;
case VARIANCE1:
case STDDEV1:
count = G_calloc(ncats, sizeof(DCELL));
sum = G_calloc(ncats, sizeof(DCELL));
sum2 = G_calloc(ncats, sizeof(DCELL));
break;
case SKEWNESS1:
count = G_calloc(ncats, sizeof(DCELL));
sum = G_calloc(ncats, sizeof(DCELL));
sum2 = G_calloc(ncats, sizeof(DCELL));
sum3 = G_calloc(ncats, sizeof(DCELL));
break;
case KURTOSIS1:
count = G_calloc(ncats, sizeof(DCELL));
sum = G_calloc(ncats, sizeof(DCELL));
sum2 = G_calloc(ncats, sizeof(DCELL));
sum4 = G_calloc(ncats, sizeof(DCELL));
break;
}
if (min)
for (i = 0; i < ncats; i++)
min[i] = 1e300;
if (max)
for (i = 0; i < ncats; i++)
max[i] = -1e300;
base_buf = Rast_allocate_c_buf();
cover_buf = Rast_allocate_d_buf();
G_message(_("First pass"));
for (row = 0; row < rows; row++) {
Rast_get_c_row(base_fd, base_buf, row);
Rast_get_d_row(cover_fd, cover_buf, row);
for (col = 0; col < cols; col++) {
int n;
DCELL v;
if (Rast_is_c_null_value(&base_buf[col]))
continue;
if (Rast_is_d_null_value(&cover_buf[col]))
continue;
n = base_buf[col] - mincat;
if (n < 0 || n >= ncats)
continue;
v = cover_buf[col];
if (usecats)
sscanf(Rast_get_c_cat((CELL *) &v, &cats), "%lf", &v);
if (count)
count[n]++;
if (sum)
sum[n] += v;
if (sum2)
sum2[n] += v * v;
if (sum3)
sum3[n] += v * v * v;
if (sum4)
sum4[n] += v * v * v * v;
if (min && min[n] > v)
min[n] = v;
if (max && max[n] < v)
max[n] = v;
}
G_percent(row, rows, 2);
}
G_percent(row, rows, 2);
result = G_calloc(ncats, sizeof(DCELL));
switch (method) {
case ADEV:
case VARIANCE2:
case STDDEV2:
case SKEWNESS2:
case KURTOSIS2:
mean = G_calloc(ncats, sizeof(DCELL));
for (i = 0; i < ncats; i++)
mean[i] = sum[i] / count[i];
G_free(sum);
break;
}
switch (method) {
case ADEV:
sumu = G_calloc(ncats, sizeof(DCELL));
break;
case VARIANCE2:
case STDDEV2:
sum2 = G_calloc(ncats, sizeof(DCELL));
break;
case SKEWNESS2:
sum2 = G_calloc(ncats, sizeof(DCELL));
sum3 = G_calloc(ncats, sizeof(DCELL));
break;
case KURTOSIS2:
sum2 = G_calloc(ncats, sizeof(DCELL));
sum4 = G_calloc(ncats, sizeof(DCELL));
break;
}
if (mean) {
G_message(_("Second pass"));
for (row = 0; row < rows; row++) {
Rast_get_c_row(base_fd, base_buf, row);
Rast_get_d_row(cover_fd, cover_buf, row);
for (col = 0; col < cols; col++) {
int n;
DCELL v, d;
if (Rast_is_c_null_value(&base_buf[col]))
continue;
if (Rast_is_d_null_value(&cover_buf[col]))
continue;
n = base_buf[col] - mincat;
if (n < 0 || n >= ncats)
continue;
v = cover_buf[col];
if (usecats)
sscanf(Rast_get_c_cat((CELL *) &v, &cats), "%lf", &v);
d = v - mean[n];
if (sumu)
sumu[n] += fabs(d);
if (sum2)
sum2[n] += d * d;
if (sum3)
sum3[n] += d * d * d;
if (sum4)
sum4[n] += d * d * d * d;
}
G_percent(row, rows, 2);
}
G_percent(row, rows, 2);
G_free(mean);
G_free(cover_buf);
}
switch (method) {
case COUNT:
for (i = 0; i < ncats; i++)
result[i] = count[i];
break;
case SUM:
for (i = 0; i < ncats; i++)
result[i] = sum[i];
break;
case AVERAGE:
for (i = 0; i < ncats; i++)
result[i] = sum[i] / count[i];
break;
case MIN:
for (i = 0; i < ncats; i++)
result[i] = min[i];
break;
case MAX:
for (i = 0; i < ncats; i++)
result[i] = max[i];
break;
case RANGE:
for (i = 0; i < ncats; i++)
result[i] = max[i] - min[i];
break;
case VARIANCE1:
for (i = 0; i < ncats; i++) {
double n = count[i];
double var = (sum2[i] - sum[i] * sum[i] / n) / (n - 1);
result[i] = var;
}
break;
case STDDEV1:
for (i = 0; i < ncats; i++) {
double n = count[i];
double var = (sum2[i] - sum[i] * sum[i] / n) / (n - 1);
result[i] = sqrt(var);
}
break;
case SKEWNESS1:
for (i = 0; i < ncats; i++) {
double n = count[i];
double var = (sum2[i] - sum[i] * sum[i] / n) / (n - 1);
double skew = (sum3[i] / n
- 3 * sum[i] * sum2[i] / (n * n)
+ 2 * sum[i] * sum[i] * sum[i] / (n * n * n))
/ (pow(var, 1.5));
result[i] = skew;
}
break;
case KURTOSIS1:
for (i = 0; i < ncats; i++) {
double n = count[i];
double var = (sum2[i] - sum[i] * sum[i] / n) / (n - 1);
double kurt = (sum4[i] / n
- 4 * sum[i] * sum3[i] / (n * n)
+ 6 * sum[i] * sum[i] * sum2[i] / (n * n * n)
- 3 * sum[i] * sum[i] * sum[i] * sum[i] / (n * n * n * n))
/ (var * var) - 3;
result[i] = kurt;
}
break;
case ADEV:
for (i = 0; i < ncats; i++)
result[i] = sumu[i] / count[i];
break;
case VARIANCE2:
for (i = 0; i < ncats; i++)
result[i] = sum2[i] / (count[i] - 1);
break;
case STDDEV2:
for (i = 0; i < ncats; i++)
result[i] = sqrt(sum2[i] / (count[i] - 1));
break;
case SKEWNESS2:
for (i = 0; i < ncats; i++) {
double n = count[i];
double var = sum2[i] / (n - 1);
double sdev = sqrt(var);
result[i] = sum3[i] / (sdev * sdev * sdev) / n;
}
G_free(count);
G_free(sum2);
G_free(sum3);
break;
case KURTOSIS2:
for (i = 0; i < ncats; i++) {
double n = count[i];
double var = sum2[i] / (n - 1);
result[i] = sum4[i] / (var * var) / n - 3;
}
G_free(count);
G_free(sum2);
G_free(sum4);
break;
}
if (reclass) {
const char *tempfile = G_tempfile();
char *input_arg = G_malloc(strlen(basemap) + 7);
char *output_arg = G_malloc(strlen(output) + 8);
char *rules_arg = G_malloc(strlen(tempfile) + 7);
FILE *fp;
G_message(_("Generating reclass map"));
sprintf(input_arg, "input=%s", basemap);
sprintf(output_arg, "output=%s", output);
sprintf(rules_arg, "rules=%s", tempfile);
fp = fopen(tempfile, "w");
if (!fp)
G_fatal_error(_("Unable to open temporary file"));
for (i = 0; i < ncats; i++)
fprintf(fp, "%d = %d %f\n", mincat + i, mincat + i, result[i]);
fclose(fp);
G_spawn("r.reclass", "r.reclass", input_arg, output_arg, rules_arg, NULL);
}
else {
int out_fd;
DCELL *out_buf;
struct Colors colors;
G_message(_("Writing output map"));
out_fd = Rast_open_fp_new(output);
out_buf = Rast_allocate_d_buf();
for (row = 0; row < rows; row++) {
Rast_get_c_row(base_fd, base_buf, row);
for (col = 0; col < cols; col++)
if (Rast_is_c_null_value(&base_buf[col]))
Rast_set_d_null_value(&out_buf[col], 1);
else
out_buf[col] = result[base_buf[col] - mincat];
Rast_put_d_row(out_fd, out_buf);
G_percent(row, rows, 2);
}
G_percent(row, rows, 2);
Rast_close(out_fd);
if (Rast_read_colors(covermap, "", &colors) > 0)
Rast_write_colors(output, G_mapset(), &colors);
}
return 0;
}
FILE *openAscii(char *asciiFile, RASTER3D_Region * region)
{
FILE *fp;
double tmp;
char buff[1024];
char line_buff[1024];
G_debug(3, "openAscii: opens the ascii file and reads the header");
fp = fopen(asciiFile, "r");
if (fp == NULL) {
perror(asciiFile);
G_usage();
exit(EXIT_FAILURE);
}
/* Initialize the default order */
rowOrder = ROW_ORDER_NORTH_TO_SOUTH;
depthOrder = DEPTH_ORDER_BOTTOM_TO_TOP;
/* Read the first line and check for grass version */
G_getl2(line_buff, 1024, fp);
/* First check for new ascii format*/
if (sscanf(line_buff, "version: %s", buff) == 1) {
G_message("Found version information: %s\n", buff);
if (G_strcasecmp(buff, "grass7") == 0) {
/* Parse the row and depth order */
G_getl2(line_buff, 1024, fp);
if (sscanf(line_buff, "order: %s", buff) != 1)
fatalError("Unable to parse the row and depth order");
if (G_strcasecmp(buff, "nsbt") == 0) {
rowOrder = ROW_ORDER_NORTH_TO_SOUTH;
depthOrder = DEPTH_ORDER_BOTTOM_TO_TOP;
G_message("Found north -> south, bottom -> top order (nsbt)");
}
if (G_strcasecmp(buff, "snbt") == 0) {
rowOrder = ROW_ORDER_SOUTH_TO_NORTH;
depthOrder = DEPTH_ORDER_BOTTOM_TO_TOP;
G_message("Found south -> north, bottom -> top order (snbt)");
}
if (G_strcasecmp(buff, "nstb") == 0) {
rowOrder = ROW_ORDER_NORTH_TO_SOUTH;
depthOrder = DEPTH_ORDER_TOP_TO_BOTTOM;
G_message("Found north -> south, top -> bottom order (nstb)");
}
if (G_strcasecmp(buff, "sntb") == 0) {
rowOrder = ROW_ORDER_SOUTH_TO_NORTH;
depthOrder = DEPTH_ORDER_TOP_TO_BOTTOM;
G_message("Found south -> north, top -> bottom order (sntb)");
}
} else {
G_fatal_error(_("Unsupported GRASS version %s"), buff);
}
} else {
/* Rewind the stream if no grass version info found */
rewind(fp);
}
Rast3d_get_window(region);
readHeaderString(fp, "north:", &(region->north));
readHeaderString(fp, "south:", &(region->south));
readHeaderString(fp, "east:", &(region->east));
readHeaderString(fp, "west:", &(region->west));
readHeaderString(fp, "top:", &(region->top));
readHeaderString(fp, "bottom:", &(region->bottom));
readHeaderString(fp, "rows:", &tmp);
region->rows = (int) tmp;
readHeaderString(fp, "cols:", &tmp);
region->cols = (int) tmp;
readHeaderString(fp, "levels:", &tmp);
region->depths = (int) tmp;
return fp;
}
int main(int argc, char *argv[])
{
char *p;
int i, j, k;
int method, half, use_catno;
const char *mapset;
struct GModule *module;
struct Option *point_opt, /* point vector */
*area_opt, /* area vector */
*point_type_opt, /* point type */
*point_field_opt, /* point layer */
*area_field_opt, /* area layer */
*method_opt, /* stats method */
*point_column_opt, /* point column for stats */
*count_column_opt, /* area column for point count */
*stats_column_opt, /* area column for stats result */
*fs_opt; /* field separator for printed output */
struct Flag *print_flag;
char *fs;
struct Map_info PIn, AIn;
int point_type, point_field, area_field;
struct line_pnts *Points;
struct line_cats *ACats, *PCats;
AREA_CAT *Area_cat;
int pline, ptype, count;
int area, nareas, nacats, nacatsalloc;
int ctype, nrec;
struct field_info *PFi, *AFi;
dbString stmt;
dbDriver *Pdriver, *Adriver;
char buf[2000];
int update_ok, update_err;
struct boxlist *List;
struct bound_box box;
dbCatValArray cvarr;
dbColumn *column;
struct pvalcat
{
double dval;
int catno;
} *pvalcats;
int npvalcats, npvalcatsalloc;
stat_func *statsvalue = NULL;
double result;
column = NULL;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("attribute table"));
G_add_keyword(_("database"));
G_add_keyword(_("univariate statistics"));
G_add_keyword(_("zonal statistics"));
module->description = _("Count points in areas, calculate statistics from point attributes.");
point_opt = G_define_standard_option(G_OPT_V_INPUT);
point_opt->key = "points";
point_opt->description = _("Name of existing vector map with points");
/* point_opt->guisection = _("Required"); */
area_opt = G_define_standard_option(G_OPT_V_INPUT);
area_opt->key = "areas";
area_opt->description = _("Name of existing vector map with areas");
/* area_opt->guisection = _("Required"); */
point_type_opt = G_define_standard_option(G_OPT_V_TYPE);
point_type_opt->key = "type";
point_type_opt->options = "point,centroid";
point_type_opt->answer = "point";
point_type_opt->label = _("Feature type");
point_type_opt->required = NO;
point_field_opt = G_define_standard_option(G_OPT_V_FIELD);
point_field_opt->key = "player";
point_field_opt->label = _("Layer number for points map");
area_field_opt = G_define_standard_option(G_OPT_V_FIELD);
area_field_opt->key = "alayer";
area_field_opt->label = _("Layer number for area map");
method_opt = G_define_option();
method_opt->key = "method";
method_opt->type = TYPE_STRING;
method_opt->required = NO;
method_opt->multiple = NO;
p = G_malloc(1024);
for (i = 0; menu[i].name; i++) {
if (i)
strcat(p, ",");
else
*p = 0;
strcat(p, menu[i].name);
}
method_opt->options = p;
method_opt->description = _("Method for aggregate statistics");
point_column_opt = G_define_standard_option(G_OPT_DB_COLUMN);
point_column_opt->key = "pcolumn";
point_column_opt->required = NO;
point_column_opt->multiple = NO;
point_column_opt->label =
_("Column name of points map to use for statistics");
point_column_opt->description = _("Column of points map must be numeric");
count_column_opt = G_define_option();
count_column_opt->key = "ccolumn";
count_column_opt->type = TYPE_STRING;
count_column_opt->required = NO;
count_column_opt->multiple = NO;
count_column_opt->label = _("Column name to upload points count");
count_column_opt->description =
_("Column to hold points count, must be of type integer, will be created if not existing");
stats_column_opt = G_define_option();
stats_column_opt->key = "scolumn";
stats_column_opt->type = TYPE_STRING;
stats_column_opt->required = NO;
stats_column_opt->multiple = NO;
stats_column_opt->label = _("Column name to upload statistics");
stats_column_opt->description =
_("Column to hold statistics, must be of type double, will be created if not existing");
fs_opt = G_define_standard_option(G_OPT_F_SEP);
print_flag = G_define_flag();
print_flag->key = 'p';
print_flag->label =
_("Print output to stdout, do not update attribute table");
print_flag->description = _("First column is always area category");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
point_type = Vect_option_to_types(point_type_opt);
point_field = atoi(point_field_opt->answer);
area_field = atoi(area_field_opt->answer);
if (print_flag->answer)
/* get field separator */
fs = G_option_to_separator(fs_opt);
else
fs = NULL;
/* check for stats */
if (method_opt->answer) {
if (!point_column_opt->answer) {
G_fatal_error("Method but no point column selected");
}
if (!print_flag->answer && !stats_column_opt->answer)
G_fatal_error("Name for stats column is missing");
}
if (point_column_opt->answer) {
if (!method_opt->answer)
G_fatal_error("No method for statistics selected");
if (!print_flag->answer && !stats_column_opt->answer)
G_fatal_error("Name for stats column is missing");
}
/* Open points vector */
if ((mapset = G_find_vector2(point_opt->answer, "")) == NULL)
G_fatal_error(_("Vector map <%s> not found"), point_opt->answer);
Vect_set_open_level(2);
if (Vect_open_old(&PIn, point_opt->answer, mapset) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), point_opt->answer);
/* Open areas vector */
if ((mapset = G_find_vector2(area_opt->answer, "")) == NULL)
G_fatal_error(_("Vector map <%s> not found"), area_opt->answer);
if (!print_flag->answer && strcmp(mapset, G_mapset()) != 0)
G_fatal_error(_("Vector map <%s> is not in user mapset and cannot be updated"),
area_opt->answer);
Vect_set_open_level(2);
if (Vect_open_old(&AIn, area_opt->answer, mapset) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), area_opt->answer);
method = -1;
use_catno = 0;
half = 0;
if (method_opt->answer) {
/* get the method */
for (method = 0; (p = menu[method].name); method++)
if ((strcmp(p, method_opt->answer) == 0))
break;
if (!p) {
G_warning(_("<%s=%s> unknown %s"),
method_opt->key, method_opt->answer,
method_opt->answer);
G_usage();
exit(EXIT_FAILURE);
}
/* establish the statsvalue routine */
statsvalue = menu[method].method;
/* category number of lowest/highest value */
if ((strcmp(menu[method].name, menu[5].name) == 0) ||
(strcmp(menu[method].name, menu[7].name) == 0))
use_catno = 1;
G_debug(1, "method: %s, use cat value: %s", menu[method].name,
(use_catno == 1 ? "yes" : "no"));
}
/* Open database driver */
db_init_string(&stmt);
Adriver = NULL;
if (!print_flag->answer) {
AFi = Vect_get_field(&AIn, area_field);
if (AFi == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
area_field);
Adriver = db_start_driver_open_database(AFi->driver, AFi->database);
if (Adriver == NULL)
G_fatal_error(_("Unable to open database <%s> with driver <%s>"),
AFi->database, AFi->driver);
if (!count_column_opt->answer)
G_fatal_error(_("ccolumn is required to upload point counts"));
/* check if count column exists */
G_debug(1, "check if count column exists");
db_get_column(Adriver, AFi->table, count_column_opt->answer, &column);
if (column) {
/* check count column type */
if (db_column_Ctype(Adriver, AFi->table, count_column_opt->answer)
!= DB_C_TYPE_INT)
G_fatal_error(_("ccolumn must be of type integer"));
db_free_column(column);
column = NULL;
}
else {
/* create count column */
/* db_add_column() exists but is not implemented,
* see lib/db/stubs/add_col.c */
sprintf(buf, "alter table %s add column %s integer",
AFi->table, count_column_opt->answer);
db_set_string(&stmt, buf);
if (db_execute_immediate(Adriver, &stmt) != DB_OK)
G_fatal_error(_("Unable to add column <%s>"),
count_column_opt->answer);
}
if (method_opt->answer) {
if (!stats_column_opt->answer)
G_fatal_error(_("scolumn is required to upload point stats"));
/* check if stats column exists */
G_debug(1, "check if stats column exists");
db_get_column(Adriver, AFi->table, stats_column_opt->answer,
&column);
if (column) {
/* check stats column type */
if (db_column_Ctype
(Adriver, AFi->table,
stats_column_opt->answer) != DB_C_TYPE_DOUBLE)
G_fatal_error(_("scolumn must be of type double"));
db_free_column(column);
column = NULL;
}
else {
/* create stats column */
/* db_add_column() exists but is not implemented,
* see lib/db/stubs/add_col.c */
sprintf(buf, "alter table %s add column %s double",
AFi->table, stats_column_opt->answer);
db_set_string(&stmt, buf);
if (db_execute_immediate(Adriver, &stmt) != DB_OK)
G_fatal_error(_("Unable to add column <%s>"),
stats_column_opt->answer);
}
}
}
else
AFi = NULL;
Pdriver = NULL;
if (method_opt->answer) {
G_verbose_message(_("collecting attributes from points vector..."));
PFi = Vect_get_field(&PIn, point_field);
if (PFi == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
point_field);
Pdriver = db_start_driver_open_database(PFi->driver, PFi->database);
if (Pdriver == NULL)
G_fatal_error(_("Unable to open database <%s> with driver <%s>"),
PFi->database, PFi->driver);
/* check if point column exists */
db_get_column(Pdriver, PFi->table, point_column_opt->answer, &column);
if (column) {
db_free_column(column);
column = NULL;
}
else {
G_fatal_error(_("Column <%s> not found in table <%s>"),
point_column_opt->answer, PFi->table);
}
/* Check column type */
ctype =
db_column_Ctype(Pdriver, PFi->table, point_column_opt->answer);
if (ctype == DB_C_TYPE_INT)
half = menu[method].half;
else if (ctype == DB_C_TYPE_DOUBLE)
half = 0;
else
G_fatal_error(_("column for points vector must be numeric"));
db_CatValArray_init(&cvarr);
nrec = db_select_CatValArray(Pdriver, PFi->table, PFi->key,
point_column_opt->answer, NULL, &cvarr);
G_debug(1, "selected values = %d", nrec);
db_close_database_shutdown_driver(Pdriver);
}
Points = Vect_new_line_struct();
ACats = Vect_new_cats_struct();
PCats = Vect_new_cats_struct();
List = Vect_new_boxlist(0);
/* Allocate space ( may be more than needed (duplicate cats and elements without cats) ) */
if ((nareas = Vect_get_num_areas(&AIn)) <= 0)
G_fatal_error("No areas in area input vector");
nacatsalloc = nareas;
Area_cat = (AREA_CAT *) G_calloc(nacatsalloc, sizeof(AREA_CAT));
/* Read all cats from 'area' */
nacats = 0;
for (area = 1; area <= nareas; area++) {
Vect_get_area_cats(&AIn, area, ACats);
if (ACats->n_cats <= 0)
continue;
for (i = 0; i < ACats->n_cats; i++) {
if (ACats->field[i] == area_field) {
Area_cat[nacats].area_cat = ACats->cat[i];
Area_cat[nacats].count = 0;
Area_cat[nacats].nvalues = 0;
Area_cat[nacats].nalloc = 0;
nacats++;
if (nacats >= nacatsalloc) {
nacatsalloc += 100;
Area_cat =
(AREA_CAT *) G_realloc(Area_cat,
nacatsalloc *
sizeof(AREA_CAT));
}
}
}
}
G_debug(1, "%d cats loaded from vector (including duplicates)", nacats);
/* Sort by category */
qsort((void *)Area_cat, nacats, sizeof(AREA_CAT), cmp_area);
/* remove duplicate categories */
for (i = 1; i < nacats; i++) {
if (Area_cat[i].area_cat == Area_cat[i - 1].area_cat) {
for (j = i; j < nacats - 1; j++) {
Area_cat[j].area_cat = Area_cat[j + 1].area_cat;
}
nacats--;
}
}
G_debug(1, "%d cats loaded from vector (unique)", nacats);
/* Go through all areas in area vector and find points in points vector
* falling into the area */
npvalcatsalloc = 10;
npvalcats = 0;
pvalcats =
(struct pvalcat *)G_calloc(npvalcatsalloc, sizeof(struct pvalcat));
G_message(_("Selecting points for each area..."));
count = 0;
for (area = 1; area <= nareas; area++) {
dbCatVal *catval;
G_debug(3, "area = %d", area);
G_percent(area, nareas, 2);
Vect_get_area_cats(&AIn, area, ACats);
if (ACats->n_cats <= 0)
continue;
/* select points by box */
Vect_get_area_box(&AIn, area, &box);
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
Vect_select_lines_by_box(&PIn, &box, point_type, List);
G_debug(4, "%d points selected by box", List->n_values);
/* For each point in box check if it is in the area */
for (i = 0; i < List->n_values; i++) {
pline = List->id[i];
G_debug(4, "%d: point %d", i, pline);
ptype = Vect_read_line(&PIn, Points, PCats, pline);
if (!(ptype & point_type))
continue;
/* point in area */
if (Vect_point_in_area(Points->x[0], Points->y[0], &AIn, area, &box)) {
AREA_CAT *area_info, search_ai;
int tmp_cat;
/* stats on point column */
if (method_opt->answer) {
npvalcats = 0;
tmp_cat = -1;
for (j = 0; j < PCats->n_cats; j++) {
if (PCats->field[j] == point_field) {
if (tmp_cat >= 0)
G_debug(3,
"More cats found in point layer (point=%d)",
pline);
tmp_cat = PCats->cat[j];
/* find cat in array */
db_CatValArray_get_value(&cvarr, tmp_cat,
&catval);
if (catval) {
pvalcats[npvalcats].catno = tmp_cat;
switch (cvarr.ctype) {
case DB_C_TYPE_INT:
pvalcats[npvalcats].dval = catval->val.i;
npvalcats++;
break;
case DB_C_TYPE_DOUBLE:
pvalcats[npvalcats].dval = catval->val.d;
npvalcats++;
break;
}
if (npvalcats >= npvalcatsalloc) {
npvalcatsalloc += 10;
pvalcats =
(struct pvalcat *)G_realloc(pvalcats,
npvalcatsalloc
*
sizeof
(struct
pvalcat));
}
}
}
}
}
/* update count for all area cats of given field */
search_ai.area_cat = -1;
for (j = 0; j < ACats->n_cats; j++) {
if (ACats->field[j] == area_field) {
if (search_ai.area_cat >= 0)
G_debug(3,
"More cats found in area layer (area=%d)",
area);
search_ai.area_cat = ACats->cat[j];
/* find cat in array */
area_info =
(AREA_CAT *) bsearch((void *)&search_ai, Area_cat,
nacats, sizeof(AREA_CAT),
cmp_area);
if (area_info->area_cat != search_ai.area_cat)
G_fatal_error(_("could not find area category %d"),
search_ai.area_cat);
/* each point is counted once, also if it has
* more than one category or no category
* OK? */
area_info->count++;
if (method_opt->answer) {
/* ensure enough space */
if (area_info->nvalues + npvalcats >=
area_info->nalloc) {
if (area_info->nalloc == 0) {
area_info->nalloc = npvalcats + 10;
area_info->values =
(double *)G_calloc(area_info->nalloc,
sizeof(double));
area_info->cats =
(int *)G_calloc(area_info->nalloc,
sizeof(int));
}
else
area_info->nalloc +=
area_info->nvalues + npvalcats + 10;
area_info->values =
(double *)G_realloc(area_info->values,
area_info->nalloc *
sizeof(double));
area_info->cats =
(int *)G_realloc(area_info->cats,
area_info->nalloc *
sizeof(int));
}
for (k = 0; k < npvalcats; k++) {
area_info->cats[area_info->nvalues] =
pvalcats[k].catno;
area_info->values[area_info->nvalues] =
pvalcats[k].dval;
area_info->nvalues++;
}
}
}
}
count++;
}
} /* next point in box */
} /* next area */
G_debug(1, "count = %d", count);
/* release catval array */
if (method_opt->answer)
db_CatValArray_free(&cvarr);
Vect_close(&PIn);
/* Update table or print to stdout */
if (print_flag->answer) { /* print header */
fprintf(stdout, "area_cat%scount", fs);
if (method_opt->answer)
fprintf(stdout, "%s%s", fs, menu[method].name);
fprintf(stdout, "\n");
}
else {
G_message("Updating attributes for area vector...");
update_err = update_ok = 0;
}
if (Adriver)
db_begin_transaction(Adriver);
for (i = 0; i < nacats; i++) {
if (!print_flag->answer)
G_percent(i, nacats, 2);
result = 0;
if (Area_cat[i].count > 0 && method_opt->answer) {
/* get stats */
statsvalue(&result, Area_cat[i].values, Area_cat[i].nvalues,
NULL);
if (half)
result += 0.5;
else if (use_catno)
result = Area_cat[i].cats[(int)result];
}
if (print_flag->answer) {
fprintf(stdout, "%d%s%d", Area_cat[i].area_cat, fs,
Area_cat[i].count);
if (method_opt->answer) {
if (Area_cat[i].count > 0)
fprintf(stdout, "%s%.15g", fs, result);
else
fprintf(stdout, "%snull", fs);
}
fprintf(stdout, "\n");
}
else {
sprintf(buf, "update %s set %s = %d", AFi->table,
count_column_opt->answer, Area_cat[i].count);
db_set_string(&stmt, buf);
if (method_opt->answer) {
if (Area_cat[i].count > 0)
sprintf(buf, " , %s = %.15g", stats_column_opt->answer,
result);
else
sprintf(buf, " , %s = null", stats_column_opt->answer);
db_append_string(&stmt, buf);
}
sprintf(buf, " where %s = %d", AFi->key, Area_cat[i].area_cat);
db_append_string(&stmt, buf);
G_debug(2, "SQL: %s", db_get_string(&stmt));
if (db_execute_immediate(Adriver, &stmt) == DB_OK) {
update_ok++;
}
else {
update_err++;
}
}
}
if (Adriver)
db_commit_transaction(Adriver);
if (!print_flag->answer) {
G_percent(nacats, nacats, 2);
db_close_database_shutdown_driver(Adriver);
db_free_string(&stmt);
G_message(_("%d records updated"), update_ok);
if (update_err > 0)
G_message(_("%d update errors"), update_err);
Vect_set_db_updated(&AIn);
}
Vect_close(&AIn);
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
int i, nsites, warn_once = 0;
int all;
long x, y;
struct Cell_head window;
struct GModule *module;
struct
{
struct Option *input, *tests, *dfield, *layer;
} parm;
struct
{
struct Flag *q, *l, *region;
} flag;
double *w, *z;
struct Map_info Map;
int line, nlines, npoints;
int field;
struct line_pnts *Points;
struct line_cats *Cats;
struct bound_box box;
/* Attributes */
int nrecords;
int ctype;
struct field_info *Fi;
dbDriver *Driver;
dbCatValArray cvarr;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("statistics"));
G_add_keyword(_("points"));
G_add_keyword(_("point pattern"));
module->description = _("Tests for normality for vector points.");
parm.input = G_define_standard_option(G_OPT_V_MAP);
parm.layer = G_define_standard_option(G_OPT_V_FIELD);
parm.tests = G_define_option();
parm.tests->key = "tests";
parm.tests->key_desc = "range";
parm.tests->type = TYPE_STRING;
parm.tests->multiple = YES;
parm.tests->required = YES;
parm.tests->label = _("Lists of tests (1-15)");
parm.tests->description = _("E.g. 1,3-8,13");
parm.dfield = G_define_standard_option(G_OPT_DB_COLUMN);
parm.dfield->required = YES;
flag.region = G_define_flag();
flag.region->key = 'r';
flag.region->description = _("Use only points in current region");
flag.l = G_define_flag();
flag.l->key = 'l';
flag.l->description = _("Lognormality instead of normality");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
all = flag.region->answer ? 0 : 1;
/* Open input */
Vect_set_open_level(2);
if (Vect_open_old2(&Map, parm.input->answer, "", parm.layer->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), parm.input->answer);
field = Vect_get_field_number(&Map, parm.layer->answer);
/* Read attributes */
Fi = Vect_get_field(&Map, field);
if (Fi == NULL) {
G_fatal_error("Database connection not defined for layer %d", field);
}
Driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (Driver == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
nrecords = db_select_CatValArray(Driver, Fi->table, Fi->key, parm.dfield->answer,
NULL, &cvarr);
G_debug(1, "nrecords = %d", nrecords);
ctype = cvarr.ctype;
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Only numeric column type supported"));
if (nrecords < 0)
G_fatal_error(_("Unable to select data from table"));
G_verbose_message(_("%d records selected from table"), nrecords);
db_close_database_shutdown_driver(Driver);
/* Read points */
npoints = Vect_get_num_primitives(&Map, GV_POINT);
z = (double *)G_malloc(npoints * sizeof(double));
G_get_window(&window);
Vect_region_box(&window, &box);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
nlines = Vect_get_num_lines(&Map);
nsites = 0;
for (line = 1; line <= nlines; line++) {
int type, cat, ret, cval;
double dval;
G_debug(3, "line = %d", line);
type = Vect_read_line(&Map, Points, Cats, line);
if (!(type & GV_POINT))
continue;
if (!all) {
if (!Vect_point_in_box(Points->x[0], Points->y[0], 0.0, &box))
continue;
}
Vect_cat_get(Cats, 1, &cat);
G_debug(3, "cat = %d", cat);
/* find actual value */
if (ctype == DB_C_TYPE_INT) {
ret = db_CatValArray_get_value_int(&cvarr, cat, &cval);
if (ret != DB_OK) {
G_warning(_("No record for cat %d"), cat);
continue;
}
dval = cval;
}
else if (ctype == DB_C_TYPE_DOUBLE) {
ret = db_CatValArray_get_value_double(&cvarr, cat, &dval);
if (ret != DB_OK) {
G_warning(_("No record for cat %d"), cat);
continue;
}
}
G_debug(3, "dval = %e", dval);
z[nsites] = dval;
nsites++;
}
G_verbose_message(_("Number of points: %d"), nsites);
if (nsites <= 0)
G_fatal_error(_("No points found"));
if (nsites < 4)
G_warning(_("Too small sample"));
if (flag.l->answer) {
warn_once = 0;
for (i = 0; i < nsites; ++i) {
if (z[i] > 1.0e-10)
z[i] = log10(z[i]);
else if (!warn_once) {
G_warning(_("Negative or very small point values set to -10.0"));
z[i] = -10.0;
warn_once = 1;
}
}
}
for (i = 0; parm.tests->answers[i]; i++)
if (!scan_cats(parm.tests->answers[i], &x, &y)) {
G_usage();
exit(EXIT_FAILURE);
}
for (i = 0; parm.tests->answers[i]; i++) {
scan_cats(parm.tests->answers[i], &x, &y);
while (x <= y)
switch (x++) {
case 1: /* moments */
fprintf(stdout, _("Moments \\sqrt{b_1} and b_2: "));
w = Cdhc_omnibus_moments(z, nsites);
fprintf(stdout, "%g %g\n", w[0], w[1]);
break;
case 2: /* geary */
fprintf(stdout, _("Geary's a-statistic & an approx. normal: "));
w = Cdhc_geary_test(z, nsites);
fprintf(stdout, "%g %g\n", w[0], w[1]);
break;
case 3: /* extreme deviates */
fprintf(stdout, _("Extreme normal deviates: "));
w = Cdhc_extreme(z, nsites);
fprintf(stdout, "%g %g\n", w[0], w[1]);
break;
case 4: /* D'Agostino */
fprintf(stdout, _("D'Agostino's D & an approx. normal: "));
w = Cdhc_dagostino_d(z, nsites);
fprintf(stdout, "%g %g\n", w[0], w[1]);
break;
case 5: /* Kuiper */
fprintf(stdout,
_("Kuiper's V (regular & modified for normality): "));
w = Cdhc_kuipers_v(z, nsites);
fprintf(stdout, "%g %g\n", w[1], w[0]);
break;
case 6: /* Watson */
fprintf(stdout,
_("Watson's U^2 (regular & modified for normality): "));
w = Cdhc_watson_u2(z, nsites);
fprintf(stdout, "%g %g\n", w[1], w[0]);
break;
case 7: /* Durbin */
fprintf(stdout,
_("Durbin's Exact Test (modified Kolmogorov): "));
w = Cdhc_durbins_exact(z, nsites);
fprintf(stdout, "%g\n", w[0]);
break;
case 8: /* Anderson-Darling */
fprintf(stdout,
_("Anderson-Darling's A^2 (regular & modified for normality): "));
w = Cdhc_anderson_darling(z, nsites);
fprintf(stdout, "%g %g\n", w[1], w[0]);
break;
case 9: /* Cramer-Von Mises */
fprintf(stdout,
_("Cramer-Von Mises W^2(regular & modified for normality): "));
w = Cdhc_cramer_von_mises(z, nsites);
fprintf(stdout, "%g %g\n", w[1], w[0]);
break;
case 10: /* Kolmogorov-Smirnov */
fprintf(stdout,
_("Kolmogorov-Smirnov's D (regular & modified for normality): "));
w = Cdhc_kolmogorov_smirnov(z, nsites);
fprintf(stdout, "%g %g\n", w[1], w[0]);
break;
case 11: /* chi-square */
fprintf(stdout,
_("Chi-Square stat (equal probability classes) and d.f.: "));
w = Cdhc_chi_square(z, nsites);
fprintf(stdout, "%g %d\n", w[0], (int)w[1]);
break;
case 12: /* Shapiro-Wilk */
if (nsites > 50) {
G_warning(_("Shapiro-Wilk's W cannot be used for n > 50"));
if (nsites < 99)
G_message(_("Use Weisberg-Binghams's W''"));
}
else {
fprintf(stdout, _("Shapiro-Wilk W: "));
w = Cdhc_shapiro_wilk(z, nsites);
fprintf(stdout, "%g\n", w[0]);
}
break;
case 13: /* Weisberg-Bingham */
if (nsites > 99 || nsites < 50)
G_warning(_("Weisberg-Bingham's W'' cannot be used for n < 50 or n > 99"));
else {
fprintf(stdout, _("Weisberg-Bingham's W'': "));
w = Cdhc_weisberg_bingham(z, nsites);
fprintf(stdout, "%g\n", w[0]);
}
break;
case 14: /* Royston */
if (nsites > 2000)
G_warning(_("Royston only extended Shapiro-Wilk's W up to n = 2000"));
else {
fprintf(stdout, _("Shapiro-Wilk W'': "));
w = Cdhc_royston(z, nsites);
fprintf(stdout, "%g\n", w[0]);
}
break;
case 15: /* Kotz */
fprintf(stdout, _("Kotz' T'_f (Lognormality vs. Normality): "));
w = Cdhc_kotz_families(z, nsites);
fprintf(stdout, "%g\n", w[0]);
break;
default:
break;
}
}
exit(EXIT_SUCCESS);
}
