int main(int argc, char **argv)
{
char *name;
int overlay;
int invert, fp;
struct GModule *module;
struct Option *map;
struct Option *vallist;
struct Option *bg;
struct Flag *flag_n;
struct Flag *flag_i;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("raster"));
module->description = _("Displays user-specified raster map in the active "
"graphics frame.");
/* set up command line */
map = G_define_standard_option(G_OPT_R_MAP);
map->description = _("Name of raster map to be displayed");
vallist = G_define_option();
vallist->key = "values";
vallist->key_desc = "value[-value]";
vallist->type = TYPE_STRING;
vallist->required = NO;
vallist->multiple = YES;
vallist->description = _("List of categories or values to be displayed");
vallist->guisection = _("Selection");
bg = G_define_standard_option(G_OPT_C_BG);
bg->key_desc = "color";
bg->gisprompt = "old_color,color,color";
bg->label = _("Background color (for null)");
bg->description = _("Either a standard color name or R:G:B triplet");
bg->guisection = _("Null cells");
flag_n = G_define_flag();
flag_n->key = 'n';
flag_n->description = _("Make null cells opaque");
flag_n->guisection = _("Null cells");
flag_i = G_define_flag();
flag_i->key = 'i';
flag_i->description = _("Invert value list");
flag_i->guisection = _("Selection");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
name = map->answer;
overlay = !flag_n->answer;
invert = flag_i->answer;
if (D_open_driver() != 0)
G_fatal_error(_("No graphics device selected. "
"Use d.mon to select graphics device."));
fp = Rast_map_is_fp(name, "");
if (vallist->answer) {
if (fp)
parse_vallist(vallist->answers, &d_mask);
else
parse_catlist(vallist->answers, &mask);
}
/* use DCELL even if the map is FCELL */
display(name, overlay, bg->answer, fp ? DCELL_TYPE : CELL_TYPE, invert);
D_save_command(G_recreate_command());
D_close_driver();
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
char *name, *outfile;
const char *unit;
int unit_id;
double factor;
int fd, projection;
FILE *fp, *coor_fp;
double res;
char *null_string;
char ebuf[256], nbuf[256], label[512], formatbuff[256];
char b1[100], b2[100];
int n;
int havefirst = FALSE;
int coords = 0, i, k = -1;
double e1, e2, n1, n2;
RASTER_MAP_TYPE data_type;
struct Cell_head window;
struct
{
struct Option *opt1, *profile, *res, *output, *null_str, *coord_file, *units;
struct Flag *g, *c, *m;
}
parm;
struct GModule *module;
G_gisinit(argv[0]);
/* Set description */
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("profile"));
module->description =
_("Outputs the raster map layer values lying on user-defined line(s).");
parm.opt1 = G_define_standard_option(G_OPT_R_INPUT);
parm.output = G_define_standard_option(G_OPT_F_OUTPUT);
parm.output->required = NO;
parm.output->answer = "-";
parm.output->description =
_("Name of file for output (use output=- for stdout)");
parm.profile = G_define_standard_option(G_OPT_M_COORDS);
parm.profile->required = NO;
parm.profile->multiple = YES;
parm.profile->description = _("Profile coordinate pairs");
parm.coord_file = G_define_standard_option(G_OPT_F_INPUT);
parm.coord_file->key = "file";
parm.coord_file->required = NO;
parm.coord_file->label =
_("Name of input file containing coordinate pairs");
parm.coord_file->description =
_("Use instead of the 'coordinates' option. "
"\"-\" reads from stdin.");
parm.res = G_define_option();
parm.res->key = "resolution";
parm.res->type = TYPE_DOUBLE;
parm.res->required = NO;
parm.res->description =
_("Resolution along profile (default = current region resolution)");
parm.null_str = G_define_option();
parm.null_str->key = "null";
parm.null_str->type = TYPE_STRING;
parm.null_str->required = NO;
parm.null_str->answer = "*";
parm.null_str->description = _("Character to represent no data cell");
parm.g = G_define_flag();
parm.g->key = 'g';
parm.g->description =
_("Output easting and northing in first two columns of four column output");
parm.c = G_define_flag();
parm.c->key = 'c';
parm.c->description =
_("Output RRR:GGG:BBB color values for each profile point");
parm.units = G_define_standard_option(G_OPT_M_UNITS);
parm.units->options = "meters,kilometers,feet,miles";
parm.units->label = parm.units->description;
parm.units->description = _("If units are not specified, current location units are used. "
"Meters are used by default in geographic (latlon) locations.");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
clr = 0;
if (parm.c->answer)
clr = 1; /* color output */
null_string = parm.null_str->answer;
if ((parm.profile->answer && parm.coord_file->answer) ||
(!parm.profile->answer && !parm.coord_file->answer))
G_fatal_error(_("Either use profile option or coordinate_file "
" option, but not both"));
G_get_window(&window);
projection = G_projection();
/* get conversion factor and units name */
if (parm.units->answer) {
unit_id = G_units(parm.units->answer);
factor = 1. / G_meters_to_units_factor(unit_id);
unit = G_get_units_name(unit_id, 1, 0);
}
/* keep meters in case of latlon */
else if (projection == PROJECTION_LL) {
factor = 1;
unit = "meters";
}
else {
/* get conversion factor to current units */
unit = G_database_unit_name(1);
factor = G_database_units_to_meters_factor();
}
if (parm.res->answer) {
res = atof(parm.res->answer);
/* Catch bad resolution ? */
if (res <= 0)
G_fatal_error(_("Illegal resolution %g [%s]"), res / factor, unit);
}
else {
/* Do average of EW and NS res */
res = (window.ew_res + window.ns_res) / 2;
}
G_message(_("Using resolution: %g [%s]"), res / factor, unit);
G_begin_distance_calculations();
/* Open Input File for reading */
/* Get Input Name */
name = parm.opt1->answer;
if (parm.g->answer)
coords = 1;
/* Open Raster File */
fd = Rast_open_old(name, "");
/* initialize color structure */
if (clr)
Rast_read_colors(name, "", &colors);
/* Open ASCII file for output or stdout */
outfile = parm.output->answer;
if ((strcmp("-", outfile)) == 0) {
fp = stdout;
}
else if (NULL == (fp = fopen(outfile, "w")))
G_fatal_error(_("Unable to open file <%s>"), outfile);
/* Get Raster Type */
data_type = Rast_get_map_type(fd);
/* Done with file */
/* Show message giving output format */
G_message(_("Output columns:"));
if (coords == 1)
sprintf(formatbuff,
_("Easting, Northing, Along track dist. [%s], Elevation"), unit);
else
sprintf(formatbuff, _("Along track dist. [%s], Elevation"), unit);
if (clr)
strcat(formatbuff, _(" RGB color"));
G_message(formatbuff);
/* Get Profile Start Coords */
if (parm.coord_file->answer) {
if (strcmp("-", parm.coord_file->answer) == 0)
coor_fp = stdin;
else
coor_fp = fopen(parm.coord_file->answer, "r");
if (coor_fp == NULL)
G_fatal_error(_("Could not open <%s>"), parm.coord_file->answer);
for (n = 1; input(b1, ebuf, b2, nbuf, label, coor_fp); n++) {
G_debug(4, "stdin line %d: ebuf=[%s] nbuf=[%s]", n, ebuf, nbuf);
if (!G_scan_easting(ebuf, &e2, G_projection()) ||
!G_scan_northing(nbuf, &n2, G_projection()))
G_fatal_error(_("Invalid coordinates %s %s"), ebuf, nbuf);
if (havefirst)
do_profile(e1, e2, n1, n2, coords, res, fd, data_type,
fp, null_string, unit, factor);
e1 = e2;
n1 = n2;
havefirst = TRUE;
}
if (coor_fp != stdin)
fclose(coor_fp);
}
else {
/* Coords given on the Command Line using the profile= option */
for (i = 0; parm.profile->answers[i]; i += 2) {
/* Test for number coordinate pairs */
k = i;
}
if (k == 0) {
/* Only one coordinate pair supplied */
G_scan_easting(parm.profile->answers[0], &e1, G_projection());
G_scan_northing(parm.profile->answers[1], &n1, G_projection());
e2 = e1;
n2 = n1;
/* Get profile info */
do_profile(e1, e2, n1, n2, coords, res, fd, data_type, fp,
null_string, unit, factor);
}
else {
for (i = 0; i <= k - 2; i += 2) {
G_scan_easting(parm.profile->answers[i], &e1, G_projection());
G_scan_northing(parm.profile->answers[i + 1], &n1,
G_projection());
G_scan_easting(parm.profile->answers[i + 2], &e2,
G_projection());
G_scan_northing(parm.profile->answers[i + 3], &n2,
G_projection());
/* Get profile info */
do_profile(e1, e2, n1, n2, coords, res, fd, data_type,
fp, null_string, unit, factor);
}
}
}
Rast_close(fd);
fclose(fp);
if (clr)
Rast_free_colors(&colors);
exit(EXIT_SUCCESS);
} /* Done with main */
int main(int argc, char *argv[])
{
int i, cat, with_z, more, ctype, nrows;
char buf[DB_SQL_MAX];
int count;
double coor[3];
int ncoor;
struct Option *driver_opt, *database_opt, *table_opt;
struct Option *xcol_opt, *ycol_opt, *zcol_opt, *keycol_opt, *where_opt,
*outvect;
struct Flag *same_table_flag;
struct GModule *module;
struct Map_info Map;
struct line_pnts *Points;
struct line_cats *Cats;
dbString sql;
dbDriver *driver;
dbCursor cursor;
dbTable *table;
dbColumn *column;
dbValue *value;
struct field_info *fi;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("import"));
G_add_keyword(_("database"));
G_add_keyword(_("points"));
module->description =
_("Creates new vector (points) map from database table containing coordinates.");
table_opt = G_define_standard_option(G_OPT_DB_TABLE);
table_opt->required = YES;
table_opt->description = _("Input table name");
driver_opt = G_define_standard_option(G_OPT_DB_DRIVER);
driver_opt->options = db_list_drivers();
driver_opt->answer = (char *)db_get_default_driver_name();
driver_opt->guisection = _("Input DB");
database_opt = G_define_standard_option(G_OPT_DB_DATABASE);
database_opt->answer = (char *)db_get_default_database_name();
database_opt->guisection = _("Input DB");
xcol_opt = G_define_standard_option(G_OPT_DB_COLUMN);
xcol_opt->key = "x";
xcol_opt->required = YES;
xcol_opt->description = _("Name of column containing x coordinate");
ycol_opt = G_define_standard_option(G_OPT_DB_COLUMN);
ycol_opt->key = "y";
ycol_opt->required = YES;
ycol_opt->description = _("Name of column containing y coordinate");
zcol_opt = G_define_standard_option(G_OPT_DB_COLUMN);
zcol_opt->key = "z";
zcol_opt->description = _("Name of column containing z coordinate");
zcol_opt->guisection = _("3D output");
keycol_opt = G_define_standard_option(G_OPT_DB_COLUMN);
keycol_opt->key = "key";
keycol_opt->required = NO;
keycol_opt->label = _("Name of column containing category number");
keycol_opt->description = _("Must refer to an integer column");
where_opt = G_define_standard_option(G_OPT_DB_WHERE);
where_opt->guisection = _("Selection");
outvect = G_define_standard_option(G_OPT_V_OUTPUT);
same_table_flag = G_define_flag();
same_table_flag->key = 't';
same_table_flag->description =
_("Use imported table as attribute table for new map");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (zcol_opt->answer) {
with_z = WITH_Z;
ncoor = 3;
}
else {
with_z = WITHOUT_Z;
ncoor = 2;
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
db_init_string(&sql);
if (G_get_overwrite()) {
/* We don't want to delete the input table when overwriting the output
* vector. */
char name[GNAME_MAX], mapset[GMAPSET_MAX];
if (!G_name_is_fully_qualified(outvect->answer, name, mapset)) {
strcpy(name, outvect->answer);
strcpy(mapset, G_mapset());
}
Vect_set_open_level(1); /* no topo needed */
if (strcmp(mapset, G_mapset()) == 0 && G_find_vector2(name, mapset) &&
Vect_open_old(&Map, name, mapset) >= 0) {
int num_dblinks;
num_dblinks = Vect_get_num_dblinks(&Map);
for (i = 0; i < num_dblinks; i++) {
if ((fi = Vect_get_dblink(&Map, i)) != NULL &&
strcmp(fi->driver, driver_opt->answer) == 0 &&
strcmp(fi->database, database_opt->answer) == 0 &&
strcmp(fi->table, table_opt->answer) == 0)
G_fatal_error(_("Vector map <%s> cannot be overwritten "
"because input table <%s> is linked to "
"this map."),
outvect->answer, table_opt->answer);
}
Vect_close(&Map);
}
}
if (Vect_open_new(&Map, outvect->answer, with_z) < 0)
G_fatal_error(_("Unable to create vector map <%s>"),
outvect->answer);
Vect_set_error_handler_io(NULL, &Map);
Vect_hist_command(&Map);
fi = Vect_default_field_info(&Map, 1, NULL, GV_1TABLE);
/* Open driver */
driver = db_start_driver_open_database(driver_opt->answer,
database_opt->answer);
if (driver == NULL) {
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
fi->database, fi->driver);
}
db_set_error_handler_driver(driver);
/* check if target table already exists */
G_debug(3, "Output vector table <%s>, driver: <%s>, database: <%s>",
outvect->answer, db_get_default_driver_name(),
db_get_default_database_name());
if (!same_table_flag->answer &&
db_table_exists(db_get_default_driver_name(),
db_get_default_database_name(), outvect->answer) == 1)
G_fatal_error(_("Output vector map, table <%s> (driver: <%s>, database: <%s>) "
"already exists"), outvect->answer,
db_get_default_driver_name(),
db_get_default_database_name());
if (keycol_opt->answer) {
int coltype;
coltype = db_column_Ctype(driver, table_opt->answer, keycol_opt->answer);
if (coltype == -1)
G_fatal_error(_("Column <%s> not found in table <%s>"),
keycol_opt->answer, table_opt->answer);
if (coltype != DB_C_TYPE_INT)
G_fatal_error(_("Data type of key column must be integer"));
}
else {
if (same_table_flag->answer) {
G_fatal_error(_("Option <%s> must be specified when -%c flag is given"),
keycol_opt->key, same_table_flag->key);
}
if (strcmp(db_get_default_driver_name(), "sqlite") != 0)
G_fatal_error(_("Unable to define key column. This operation is not supported "
"by <%s> driver. You need to define <%s> option."),
fi->driver, keycol_opt->key);
}
/* Open select cursor */
sprintf(buf, "SELECT %s, %s", xcol_opt->answer, ycol_opt->answer);
db_set_string(&sql, buf);
if (with_z) {
sprintf(buf, ", %s", zcol_opt->answer);
db_append_string(&sql, buf);
}
if (keycol_opt->answer) {
sprintf(buf, ", %s", keycol_opt->answer);
db_append_string(&sql, buf);
}
sprintf(buf, " FROM %s", table_opt->answer);
db_append_string(&sql, buf);
if (where_opt->answer) {
sprintf(buf, " WHERE %s", where_opt->answer);
db_append_string(&sql, buf);
}
G_debug(2, "SQL: %s", db_get_string(&sql));
if (db_open_select_cursor(driver, &sql, &cursor, DB_SEQUENTIAL) != DB_OK) {
G_fatal_error(_("Unable to open select cursor: '%s'"),
db_get_string(&sql));
}
table = db_get_cursor_table(&cursor);
nrows = db_get_num_rows(&cursor);
G_debug(2, "%d points selected", nrows);
count = cat = 0;
G_message(_("Writing features..."));
while (db_fetch(&cursor, DB_NEXT, &more) == DB_OK && more) {
G_percent(count, nrows, 2);
/* key column */
if (keycol_opt->answer) {
column = db_get_table_column(table, with_z ? 3 : 2);
ctype = db_sqltype_to_Ctype(db_get_column_sqltype(column));
if (ctype != DB_C_TYPE_INT)
G_fatal_error(_("Key column must be integer"));
value = db_get_column_value(column);
cat = db_get_value_int(value);
}
else {
cat++;
}
/* coordinates */
for (i = 0; i < ncoor; i++) {
column = db_get_table_column(table, i);
ctype = db_sqltype_to_Ctype(db_get_column_sqltype(column));
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("x/y/z column must be integer or double"));
value = db_get_column_value(column);
if (ctype == DB_C_TYPE_INT)
coor[i] = (double)db_get_value_int(value);
else
coor[i] = db_get_value_double(value);
}
Vect_reset_line(Points);
Vect_reset_cats(Cats);
Vect_append_point(Points, coor[0], coor[1], coor[2]);
Vect_cat_set(Cats, 1, cat);
Vect_write_line(&Map, GV_POINT, Points, Cats);
count++;
}
G_percent(1, 1, 1);
/* close connection to input DB before copying attributes */
db_close_database_shutdown_driver(driver);
/* Copy table */
if (!same_table_flag->answer) {
G_message(_("Copying attributes..."));
if (DB_FAILED == db_copy_table_where(driver_opt->answer, database_opt->answer,
table_opt->answer,
fi->driver, fi->database, fi->table,
where_opt->answer)) { /* where can be NULL */
G_warning(_("Unable to copy table"));
}
else {
Vect_map_add_dblink(&Map, 1, NULL, fi->table,
keycol_opt->answer ? keycol_opt->answer : GV_KEY_COLUMN,
fi->database, fi->driver);
}
if (!keycol_opt->answer) {
/* TODO: implement for all DB drivers in generic way if
* possible */
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);
}
db_set_error_handler_driver(driver);
/* add key column */
sprintf(buf, "ALTER TABLE %s ADD COLUMN %s INTEGER",
fi->table, GV_KEY_COLUMN);
db_set_string(&sql, buf);
if (db_execute_immediate(driver, &sql) != DB_OK) {
G_fatal_error(_("Unable to add key column <%s>: "
"SERIAL type is not supported by <%s>"),
GV_KEY_COLUMN, fi->driver);
}
/* update key column */
sprintf(buf, "UPDATE %s SET %s = _ROWID_",
fi->table, GV_KEY_COLUMN);
db_set_string(&sql, buf);
if (db_execute_immediate(driver, &sql) != DB_OK) {
G_fatal_error(_("Failed to update key column <%s>"),
GV_KEY_COLUMN);
}
}
}
else {
/* do not copy attributes, link original table */
Vect_map_add_dblink(&Map, 1, NULL, table_opt->answer,
keycol_opt->answer ? keycol_opt->answer : GV_KEY_COLUMN,
database_opt->answer, driver_opt->answer);
}
Vect_build(&Map);
Vect_close(&Map);
G_done_msg(_n("%d point written to vector map.",
"%d points written to vector map.",
count), count);
return (EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
FILTER *filter;
int nfilters;
int repeat;
char *in_name;
char *filt_name;
char *out_name;
char title[1024];
char temp[300];
int i;
struct GModule *module;
struct Flag *flag2;
struct Option *opt1;
struct Option *opt2;
struct Option *opt3;
struct Option *opt4;
struct Option *opt5;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("algebra"));
G_add_keyword(_("statistics"));
module->description = _("Performs raster map matrix filter.");
/* Define the different options */
opt1 = G_define_standard_option(G_OPT_R_INPUT);
opt2 = G_define_standard_option(G_OPT_R_OUTPUT);
opt3 = G_define_standard_option(G_OPT_F_INPUT);
opt3->key = "filter";
opt3->required = YES;
opt3->description = _("Path to filter file");
opt4 = G_define_option();
opt4->key = "repeat";
opt4->type = TYPE_INTEGER;
opt4->multiple = NO;
opt4->required = NO;
opt4->answer = "1";
opt4->description = _("Number of times to repeat the filter");
opt4->guisection = _("Filter");
opt5 = G_define_option();
opt5->key = "title";
opt5->type = TYPE_STRING;
opt5->required = NO;
opt5->description = _("Output raster map title");
/* Define the different flags */
/* this isn't implemented at all
flag3 = G_define_flag() ;
flag3->key = 'p' ;
flag3->description = _("Preserved edge") ;
*/
flag2 = G_define_flag();
flag2->key = 'z';
flag2->description = _("Apply filter only to null data values");
flag2->guisection = _("Filter");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/*
preserve_edges = flag3->answer;
*/
null_only = flag2->answer;
sscanf(opt4->answer, "%d", &repeat);
out_name = opt2->answer;
filt_name = opt3->answer;
in_name = opt1->answer;
nrows = Rast_window_rows();
ncols = Rast_window_cols();
buflen = ncols * sizeof(DCELL);
/* get the filter */
filter = get_filter(filt_name, &nfilters, temp);
/* make sure filter matrix won't extend outside the raster map */
for (i = 0; i < nfilters; i++) {
if (filter[i].size > ncols || filter[i].size > nrows)
G_fatal_error(_("Raster map too small for the size of the filter"));
}
/* make a title for result */
if (opt5->answer)
strcpy(title, opt5->answer);
else {
if (*temp == 0)
strcpy(temp, "unknown filter");
sprintf(title, "%s filtered using %s", in_name, temp);
}
perform_filter(in_name, out_name, filter, nfilters, repeat);
Rast_put_cell_title(out_name, title);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct Option *start_opt, *select_opt, *stop_opt, *output_opt,
*width_opt, *height_opt, *bgcolor_opt, *res_opt;
struct Flag *list_flag, *selected_flag, *select_flag, *release_flag,
*cmd_flag, *truecolor_flag, *update_flag, *x_flag, *sfile_flag;
int nopts, ret;
const char *mon;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("graphics"));
G_add_keyword(_("monitors"));
module->description = _("Controls graphics display monitors from the command line.");
start_opt = G_define_option();
start_opt->key = "start";
start_opt->type = TYPE_STRING;
start_opt->description = _("Name of monitor to start");
start_opt->options = "wx0,wx1,wx2,wx3,wx4,wx5,wx6,wx7,png,ps,html,cairo";
start_opt->guisection = _("Manage");
stop_opt = G_define_option();
stop_opt->key = "stop";
stop_opt->type = TYPE_STRING;
stop_opt->description = _("Name of monitor to stop");
stop_opt->options = "wx0,wx1,wx2,wx3,wx4,wx5,wx6,wx7,png,ps,html,cairo";
stop_opt->guisection = _("Manage");
select_opt = G_define_option();
select_opt->key = "select";
select_opt->type = TYPE_STRING;
select_opt->description = _("Name of monitor to select");
select_opt->options = "wx0,wx1,wx2,wx3,wx4,wx5,wx6,wx7,png,ps,html,cairo";
select_opt->guisection = _("Manage");
width_opt = G_define_option();
width_opt->key = "width";
width_opt->label = _("Width for display monitor if not set by GRASS_RENDER_WIDTH");
width_opt->description = _("Default value: 720");
width_opt->type = TYPE_INTEGER;
width_opt->key_desc = "value";
width_opt->guisection = _("Settings");
height_opt = G_define_option();
height_opt->key = "height";
height_opt->label = _("Height for display monitor if not set by GRASS_RENDER_HEIGHT");
height_opt->description = _("Default value: 480");
height_opt->type = TYPE_INTEGER;
height_opt->key_desc = "value";
height_opt->guisection = _("Settings");
res_opt = G_define_option();
res_opt->key = "resolution";
res_opt->label = _("Dimensions of display monitor versus current size");
res_opt->description = _("Example: resolution=2 enlarge display monitor twice to 1280x960");
res_opt->type = TYPE_INTEGER;
res_opt->key_desc = "value";
res_opt->guisection = _("Settings");
bgcolor_opt = G_define_standard_option(G_OPT_CN);
bgcolor_opt->key = "bgcolor";
bgcolor_opt->label = _("Background color");
bgcolor_opt->answer = DEFAULT_BG_COLOR;
bgcolor_opt->guisection = _("Settings");
output_opt = G_define_standard_option(G_OPT_F_OUTPUT);
output_opt->required = NO;
output_opt->label = _("Name for output file (when starting new monitor)");
output_opt->description = _("Ignored for 'wx' monitors");
output_opt->guisection = _("Settings");
list_flag = G_define_flag();
list_flag->key = 'l';
list_flag->description = _("List running monitors and exit");
list_flag->guisection = _("Print");
selected_flag = G_define_flag();
selected_flag->key = 'p';
selected_flag->description = _("Print name of currently selected monitor and exit");
selected_flag->guisection = _("Print");
cmd_flag = G_define_flag();
cmd_flag->key = 'c';
cmd_flag->description = _("Print commands for currently selected monitor and exit");
cmd_flag->guisection = _("Print");
sfile_flag = G_define_flag();
sfile_flag->key = 'g';
sfile_flag->description =
_("Print path to support files of currently selected monitor and exit");
select_flag = G_define_flag();
select_flag->key = 's';
select_flag->description = _("Do not automatically select when starting");
select_flag->guisection = _("Manage");
release_flag = G_define_flag();
release_flag->key = 'r';
release_flag->description = _("Release and stop currently selected monitor and exit");
release_flag->guisection = _("Manage");
truecolor_flag = G_define_flag();
truecolor_flag->key = 't';
truecolor_flag->description = _("Disable true colors");
truecolor_flag->guisection = _("Settings");
update_flag = G_define_flag();
update_flag->key = 'u';
update_flag->label = _("Open output file in update mode");
update_flag->description = _("Requires --overwrite flag");
update_flag->guisection = _("Settings");
x_flag = G_define_flag();
x_flag->key = 'x';
x_flag->label = _("Launch light-weight wx monitor without toolbars and statusbar");
x_flag->description = _("Requires 'start=wx0-7'");
x_flag->guisection = _("Settings");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (x_flag->answer && start_opt->answer && strncmp(start_opt->answer, "wx", 2) != 0)
G_warning(_("Flag -%c has effect only for wx monitors (%s=wx0-7)"),
x_flag->key, start_opt->key);
if (selected_flag->answer || release_flag->answer ||
cmd_flag->answer || sfile_flag->answer) {
if (list_flag->answer)
G_warning(_("Flag -%c ignored"), list_flag->key);
mon = G_getenv_nofatal("MONITOR");
if (mon) {
if (selected_flag->answer) {
G_verbose_message(_("Currently selected monitor:"));
fprintf(stdout, "%s\n", mon);
}
else if (cmd_flag->answer) {
G_message(_("List of commands for monitor <%s>:"), mon);
list_cmd(mon, stdout);
}
else if (sfile_flag->answer) {
list_files(mon, stdout);
}
else if (mon) { /* release */
G_unsetenv("MONITOR");
G_verbose_message(_("Monitor <%s> released"), mon);
ret = stop_mon(mon);
}
}
else
G_important_message(_("No monitor selected"));
exit(EXIT_SUCCESS);
}
if (list_flag->answer) {
print_list(stdout);
exit(EXIT_SUCCESS);
}
nopts = 0;
if (start_opt->answer)
nopts++;
if (stop_opt->answer)
nopts++;
if (select_opt->answer)
nopts++;
if (nopts != 1)
G_fatal_error(_("Either <%s>, <%s> or <%s> must be given"),
start_opt->key, stop_opt->key, select_opt->key);
if (output_opt->answer &&
(!start_opt->answer || strncmp(start_opt->answer, "wx", 2) == 0))
G_warning(_("Option <%s> ignored"), output_opt->key);
if (start_opt->answer) {
int width, height;
width = width_opt->answer ? atoi(width_opt->answer) : 0;
height = height_opt->answer ? atoi(height_opt->answer) : 0;
if (width < 1) {
char *env_width = getenv("GRASS_RENDER_WIDTH");
if (env_width)
width = atoi(env_width);
}
if (height < 1) {
char *env_height = getenv("GRASS_RENDER_HEIGHT");
if (env_height)
height = atoi(env_height);
}
if (width < 1)
width = DEFAULT_WIDTH;
if (height < 1)
height = DEFAULT_HEIGHT;
if (res_opt->answer) {
int res;
res = atoi(res_opt->answer);
width *= res;
height *= res;
}
G_debug(1, "Monitor width/height = %d/%d", width, height);
ret = start_mon(start_opt->answer, output_opt->answer, !select_flag->answer,
width, height, bgcolor_opt->answer,
!truecolor_flag->answer, x_flag->answer, update_flag->answer);
if (output_opt->answer && !update_flag->answer) {
D_open_driver();
D_setup_unity(0);
D_erase(bgcolor_opt->answer);
D_close_driver();
}
}
if (stop_opt->answer)
ret = stop_mon(stop_opt->answer);
if (select_opt->answer)
ret = select_mon(select_opt->answer);
if (ret != 0)
exit(EXIT_FAILURE);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct Option *type, *rc_file;
struct Flag *update, *nolaunch;
struct GModule *module;
const char *gui_type_env;
char progname[GPATH_MAX];
char *desc;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("general"));
G_add_keyword(_("gui"));
G_add_keyword(_("user interface"));
module->label =
_("Launches a GRASS graphical user interface (GUI) session.");
module->description = _("And updates default user interface settings.");
type = G_define_option();
type->key = "ui";
type->type = TYPE_STRING;
type->label = _("User interface");
type->description = _("Default value: GRASS_GUI if defined otherwise wxpython");
desc = NULL;
G_asprintf(&desc,
"wxpython;%s;text;%s",
_("wxPython based GUI (wxGUI)"),
_("command line interface only"));
type->descriptions = desc;
type->options = "wxpython,text";
type->guisection = _("Type");
rc_file = G_define_standard_option(G_OPT_F_INPUT);
rc_file->key = "workspace";
rc_file->required = NO;
rc_file->key_desc = "name.gxw";
rc_file->description = _("Name of workspace file to load on start-up (valid only for wxGUI)");
update = G_define_flag();
update->key = 'd';
update->description = _("Update default user interface settings");
update->guisection = _("Default");
nolaunch = G_define_flag();
nolaunch->key = 'n';
nolaunch->description =
_("Do not launch GUI after updating the default user interface settings");
nolaunch->guisection = _("Default");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (type->answer && strcmp(type->answer, "text") == 0 &&
!nolaunch->answer)
nolaunch->answer = TRUE;
if (nolaunch->answer && !update->answer)
update->answer = TRUE;
gui_type_env = G__getenv("GUI");
if (!type->answer) {
if (gui_type_env && strcmp(gui_type_env, "text")) {
type->answer = G_store(gui_type_env);
}
else {
type->answer = "wxpython";
}
}
if (((gui_type_env && update->answer) &&
strcmp(gui_type_env, type->answer) != 0) || !gui_type_env) {
G_setenv("GUI", type->answer);
G_message(_("<%s> is now the default GUI"), type->answer);
}
else {
if(update->answer)
if(gui_type_env) {
G_debug(1, "No change: old gui_type_env=[%s], new type->ans=[%s]",
gui_type_env, type->answer);
}
}
if(nolaunch->answer)
exit(EXIT_SUCCESS);
G_message(_("Launching <%s> GUI in the background, please wait..."), type->answer);
if (strcmp(type->answer, "wxpython") == 0) {
sprintf(progname, "%s/gui/wxpython/wxgui.py", G_gisbase());
if (rc_file->answer) {
G_spawn_ex(getenv("GRASS_PYTHON"), getenv("GRASS_PYTHON"), progname,
"--workspace", rc_file->answer, SF_BACKGROUND, NULL);
}
else {
G_spawn_ex(getenv("GRASS_PYTHON"), getenv("GRASS_PYTHON"), progname,
SF_BACKGROUND, NULL);
}
}
/* stop the impatient from starting it again
before the splash screen comes up */
G_sleep(3);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct
{
struct Option *base, *cover, *output;
} parm;
char *basemap, *base_mapset;
char *covermap, *cover_mapset;
char *outmap;
char command[1024];
struct Categories cover_cats;
FILE *stats_fd, *reclass_fd;
int first;
long basecat, covercat, catb, catc;
double area;
struct stats stats;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("raster, statistics");
module->description =
_("Finds the median of values in a cover map within "
"areas assigned the same category value in a "
"user-specified base map.");
parm.base = G_define_standard_option(G_OPT_R_INPUT);
parm.base->key = "base";
parm.base->description = _("Name of base raster map");
parm.cover = G_define_standard_option(G_OPT_R_INPUT);
parm.cover->key = "cover";
parm.cover->description = _("Name of cover raster map");
parm.output = G_define_standard_option(G_OPT_R_OUTPUT);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
basemap = parm.base->answer;
covermap = parm.cover->answer;
outmap = parm.output->answer;
base_mapset = G_find_cell2(basemap, "");
if (base_mapset == NULL)
G_fatal_error(_("Base raster map <%s> not found"), basemap);
cover_mapset = G_find_cell2(covermap, "");
if (cover_mapset == NULL)
G_fatal_error(_("Raster map <%s> not found"), covermap);
if (G_legal_filename(outmap) < 0)
G_fatal_error(_("<%s> is an illegal file name"), outmap);
if (strcmp(G_mapset(), base_mapset) == 0 && strcmp(basemap, outmap) == 0)
G_fatal_error(_("Base map and output map <%s> must be different"),
outmap);
if (G_read_cats(covermap, cover_mapset, &cover_cats) < 0)
G_fatal_error(_("Unable to read category labels of raster map <%s>"),
covermap);
strcpy(command, "r.stats -an \"");
strcat(command, G_fully_qualified_name(basemap, base_mapset));
strcat(command, ",");
strcat(command, G_fully_qualified_name(covermap, cover_mapset));
strcat(command, "\"");
/* strcpy (command,"cat /tmp/t"); */
G_debug(3, "command: %s", command);
stats_fd = popen(command, "r");
G_debug(3, "r.reclass i=\"%s\" o=\"%s\"",
G_fully_qualified_name(basemap, base_mapset), outmap);
sprintf(command, "r.reclass i=\"%s\" o=\"%s\"",
G_fully_qualified_name(basemap, base_mapset), outmap);
reclass_fd = popen(command, "w");
first = 1;
while (read_stats(stats_fd, &basecat, &covercat, &area)) {
if (first) {
stats.n = 0;
stats.nalloc = 16;
stats.cat = (long *)
G_calloc(stats.nalloc, sizeof(long));
stats.area = (double *)
G_calloc(stats.nalloc, sizeof(double));
first = 0;
catb = basecat;
}
if (basecat != catb) {
catc = median(&stats);
write_reclass(reclass_fd, catb, catc,
G_get_cat(catc, &cover_cats));
catb = basecat;
stats.n = 0;
}
stats.n++;
if (stats.n > stats.nalloc) {
stats.nalloc *= 2;
stats.cat = (long *)
G_realloc(stats.cat, stats.nalloc * sizeof(long));
stats.area = (double *)
G_realloc(stats.area, stats.nalloc * sizeof(double));
}
stats.cat[stats.n - 1] = covercat;
stats.area[stats.n - 1] = area;
}
if (!first) {
catc = median(&stats);
write_reclass(reclass_fd, catb, catc, G_get_cat(catc, &cover_cats));
}
pclose(stats_fd);
pclose(reclass_fd);
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
char title[80];
char buf[80], *p;
struct Ortho_Image_Group group;
struct GModule *module;
struct Option *group_opt;
/* must run in a term window */
G_putenv("GRASS_UI_TERM", "1");
/* initialize grass */
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("imagery, orthorectify");
module->description = _("Menu driver for the photo imagery programs.");
group_opt = G_define_standard_option(G_OPT_I_GROUP);
group_opt->description =
_("Name of imagery group for ortho-rectification");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
strncpy(group.name, group_opt->answer, 99);
group.name[99] = '\0';
/* strip off mapset if it's there: I_() fns only work with current mapset */
if ((p = strchr(group.name, '@')))
*p = 0;
/* get and check the group reference files */
if (!I_get_group_ref(group.name, &group.group_ref)) {
G_warning(_("Pre-selected group <%s> not found"), group.name);
/* clean the wrong name in GROUPFILE */
I_put_group("");
/* ask for new group name */
if (!I_ask_group_old(
_("Enter imagery group for ortho-rectification"), group.name))
exit(EXIT_SUCCESS);
I_get_group_ref(group.name, &group.group_ref);
}
if (group.group_ref.nfiles <= 0)
G_fatal_error(_("Group [%s] contains no files"), group.name);
I_put_group(group.name);
while (1) {
if (!I_get_group(group.name)) {
exit(EXIT_SUCCESS);
}
/* print the screen full of options */
sprintf(title, "i.ortho.photo -- \tImagery Group = %s ", group.name);
G_clear_screen();
fprintf(stderr, "%s\n\n", title);
fprintf(stderr, "Initialization Options:\n");
fprintf(stderr, "\n");
fprintf(stderr, " 1. Select/Modify imagery group\n");
fprintf(stderr, " 2. Select/Modify imagery group target\n");
fprintf(stderr, " 3. Select/Modify target elevation model\n");
fprintf(stderr, " 4. Select/Modify imagery group camera\n");
fprintf(stderr, "\n");
fprintf(stderr, "Transformation Parameter Computations:\n");
fprintf(stderr, "\n");
fprintf(stderr, " 5. Compute image-to-photo transformation\n");
fprintf(stderr, " 6. Initialize exposure station parameters\n");
fprintf(stderr, " 7. Compute ortho-rectification parameters\n");
fprintf(stderr, "\n");
fprintf(stderr, "Ortho-rectification Option:\n");
fprintf(stderr, "\n");
fprintf(stderr, " 8. Ortho-rectify imagery files\n");
fprintf(stderr, "\n");
fprintf(stderr, "RETURN exit\n");
fprintf(stderr, "\n> ");
/* Get the option */
if (!G_gets(buf))
continue;
if (*buf == 0) /* exit */
exit(EXIT_SUCCESS);
/* run the program chosen */
G_strip(buf);
fprintf(stderr, "<%s>\n", buf);
if (strcmp(buf, "1") == 0)
run_system("i.group");
if (strcmp(buf, "2") == 0)
run_etc_imagery("i.photo.target", group.name);
if (strcmp(buf, "3") == 0)
run_etc_imagery("i.photo.elev", group.name);
if (strcmp(buf, "4") == 0)
run_etc_imagery("i.photo.camera", group.name);
if (strcmp(buf, "5") == 0)
run_etc_imagery("i.photo.2image", group.name);
if (strcmp(buf, "6") == 0)
run_etc_imagery("i.photo.init", group.name);
if (strcmp(buf, "7") == 0)
run_etc_imagery("i.photo.2target", group.name);
if (strcmp(buf, "8") == 0) {
rectify(group.name);
/*
sprintf(buf, "i.photo.rectify group=%s", group.name);
run_system(buf);
*/
}
}
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct
{
struct Option *quant, *perc, *slots, *basemap, *covermap, *output;
} opt;
struct {
struct Flag *r, *p;
} flag;
const char *basemap, *covermap;
char **outputs;
int reclass, print;
int cover_fd, base_fd;
struct Range range;
struct FPRange fprange;
int i;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("statistics"));
module->description = _("Compute category quantiles using two passes.");
opt.basemap = G_define_standard_option(G_OPT_R_BASE);
opt.covermap = G_define_standard_option(G_OPT_R_COVER);
opt.quant = G_define_option();
opt.quant->key = "quantiles";
opt.quant->type = TYPE_INTEGER;
opt.quant->required = NO;
opt.quant->description = _("Number of quantiles");
opt.perc = G_define_option();
opt.perc->key = "percentiles";
opt.perc->type = TYPE_DOUBLE;
opt.perc->multiple = YES;
opt.perc->description = _("List of percentiles");
opt.perc->answer = "50";
opt.slots = G_define_option();
opt.slots->key = "bins";
opt.slots->type = TYPE_INTEGER;
opt.slots->required = NO;
opt.slots->description = _("Number of bins to use");
opt.slots->answer = "1000";
opt.output = G_define_standard_option(G_OPT_R_OUTPUT);
opt.output->description = _("Resultant raster map(s)");
opt.output->required = NO;
opt.output->multiple = YES;
flag.r = G_define_flag();
flag.r->key = 'r';
flag.r->description =
_("Create reclass map with statistics as category labels");
flag.p = G_define_flag();
flag.p->key = 'p';
flag.p->description =
_("Do not create output maps; just print statistics");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
basemap = opt.basemap->answer;
covermap = opt.covermap->answer;
outputs = opt.output->answers;
reclass = flag.r->answer;
print = flag.p->answer;
if (!print && !opt.output->answers)
G_fatal_error(_("Either -%c or %s= must be given"),
flag.p->key, opt.output->key);
if (print && opt.output->answers)
G_fatal_error(_("-%c and %s= are mutually exclusive"),
flag.p->key, opt.output->key);
num_slots = atoi(opt.slots->answer);
if (opt.quant->answer) {
num_quants = atoi(opt.quant->answer) - 1;
quants = G_calloc(num_quants, sizeof(DCELL));
for (i = 0; i < num_quants; i++)
quants[i] = 1.0 * (i + 1) / (num_quants + 1);
}
else {
for (i = 0; opt.perc->answers[i]; i++)
;
num_quants = i;
quants = G_calloc(num_quants, sizeof(DCELL));
for (i = 0; i < num_quants; i++)
quants[i] = atof(opt.perc->answers[i]) / 100;
qsort(quants, num_quants, sizeof(DCELL), compare_dcell);
}
if (opt.output->answer) {
for (i = 0; opt.output->answers[i]; i++)
;
if (i != num_quants)
G_fatal_error(_("Number of quantiles (%d) does not match number of output maps (%d)"),
num_quants, i);
}
base_fd = Rast_open_old(basemap, "");
cover_fd = Rast_open_old(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);
Rast_get_range_min_max(&range, &min, &max);
num_cats = max - min + 1;
if (num_cats > MAX_CATS)
G_fatal_error(_("Base map <%s> has too many categories (max: %d)"),
basemap, MAX_CATS);
Rast_read_fp_range(covermap, "", &fprange);
Rast_get_fp_range_min_max(&fprange, &f_min, &f_max);
slot_size = (f_max - f_min) / num_slots;
basecats = G_calloc(num_cats, sizeof(struct basecat));
for (i = 0; i < num_cats; i++)
basecats[i].slots = G_calloc(num_slots, sizeof(unsigned int));
rows = Rast_window_rows();
cols = Rast_window_cols();
get_slot_counts(base_fd, cover_fd);
initialize_bins();
fill_bins(base_fd, cover_fd);
sort_bins();
compute_quantiles();
if (print)
print_quantiles();
else if (reclass)
do_reclass(basemap, outputs);
else
do_output(base_fd, outputs, covermap);
Rast_close(cover_fd);
Rast_close(base_fd);
return (EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct {
struct Flag *r, *w, *l, *g, *a, *n, *c;
} flag;
struct {
struct Option *map, *field, *colr, *rast, *volume, *rules,
*attrcol, *rgbcol, *range, *use;
} opt;
int layer;
int overwrite, remove, is_from_stdin, stat, have_colors, convert, use;
const char *mapset, *cmapset;
const char *style, *rules, *cmap, *attrcolumn, *rgbcolumn;
char *name;
struct Map_info Map;
struct FPRange range;
struct Colors colors, colors_tmp;
/* struct Cell_stats statf; */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("color table"));
module->description =
_("Creates/modifies the color table associated with a vector map.");
opt.map = G_define_standard_option(G_OPT_V_MAP);
opt.field = G_define_standard_option(G_OPT_V_FIELD);
opt.use = G_define_option();
opt.use->key = "use";
opt.use->type = TYPE_STRING;
opt.use->required = YES;
opt.use->multiple = NO;
opt.use->options = "attr,cat,z";
opt.use->description = _("Source values");
G_asprintf((char **) &(opt.use->descriptions),
"attr;%s;cat;%s;z;%s",
_("read values from attribute table (requires <column> option)"),
_("use category values"),
_("use z coordinate (3D points or centroids only)"));
opt.use->answer = "cat";
opt.attrcol = G_define_standard_option(G_OPT_DB_COLUMN);
opt.attrcol->label = _("Name of column containing numeric data");
opt.attrcol->description = _("Required for use=attr");
opt.attrcol->guisection = _("Define");
opt.range = G_define_option();
opt.range->key = "range";
opt.range->type = TYPE_DOUBLE;
opt.range->required = NO;
opt.range->label = _("Manually set range (refers to 'column' option)");
opt.range->description = _("Ignored when 'rules' given");
opt.range->key_desc = "min,max";
opt.colr = G_define_standard_option(G_OPT_M_COLR);
opt.colr->guisection = _("Define");
opt.rast = G_define_standard_option(G_OPT_R_INPUT);
opt.rast->key = "raster";
opt.rast->required = NO;
opt.rast->description =
_("Raster map from which to copy color table");
opt.rast->guisection = _("Define");
opt.volume = G_define_standard_option(G_OPT_R3_INPUT);
opt.volume->key = "raster_3d";
opt.volume->required = NO;
opt.volume->description =
_("3D raster map from which to copy color table");
opt.volume->guisection = _("Define");
opt.rules = G_define_standard_option(G_OPT_F_INPUT);
opt.rules->key = "rules";
opt.rules->required = NO;
opt.rules->description = _("Path to rules file");
opt.rules->guisection = _("Define");
opt.rgbcol = G_define_standard_option(G_OPT_DB_COLUMN);
opt.rgbcol->key = "rgb_column";
opt.rgbcol->label = _("Name of color column to populate RGB values");
opt.rgbcol->description = _("If not given writes color table");
flag.r = G_define_flag();
flag.r->key = 'r';
flag.r->description = _("Remove existing color table");
flag.r->guisection = _("Remove");
flag.w = G_define_flag();
flag.w->key = 'w';
flag.w->description =
_("Only write new color table if it does not already exist");
flag.l = G_define_flag();
flag.l->key = 'l';
flag.l->description = _("List available rules then exit");
flag.l->suppress_required = YES;
flag.l->guisection = _("Print");
flag.n = G_define_flag();
flag.n->key = 'n';
flag.n->description = _("Invert colors");
flag.n->guisection = _("Define");
flag.g = G_define_flag();
flag.g->key = 'g';
flag.g->description = _("Logarithmic scaling");
flag.g->guisection = _("Define");
flag.a = G_define_flag();
flag.a->key = 'a';
flag.a->description = _("Logarithmic-absolute scaling");
flag.a->guisection = _("Define");
flag.c = G_define_flag();
flag.c->key = 'c';
flag.c->label = _("Convert color rules from RGB values to color table");
flag.c->description = _("Option 'rgb_column' with valid RGB values required");
/* TODO ?
flag.e = G_define_flag();
flag.e->key = 'e';
flag.e->description = _("Histogram equalization");
flag.e->guisection = _("Define");
*/
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (flag.l->answer) {
G_list_color_rules(stdout);
return EXIT_SUCCESS;
}
overwrite = !flag.w->answer;
remove = flag.r->answer;
name = opt.map->answer;
style = opt.colr->answer;
rules = opt.rules->answer;
attrcolumn = opt.attrcol->answer;
rgbcolumn = opt.rgbcol->answer;
convert = flag.c->answer;
use = USE_CAT;
if (opt.use->answer) {
switch (opt.use->answer[0]) {
case 'a':
use = USE_ATTR;
break;
case 'c':
use = USE_CAT;
break;
case 'z':
use = USE_Z;
break;
default:
break;
}
}
G_debug(1, "use=%d", use);
if (!name)
G_fatal_error(_("No vector map specified"));
if (use == USE_ATTR && !attrcolumn)
G_fatal_error(_("Option <%s> required"), opt.attrcol->key);
if (use != USE_ATTR && attrcolumn) {
G_important_message(_("Option <%s> given, assuming <use=attr>..."), opt.attrcol->key);
use = USE_ATTR;
}
if (opt.rast->answer && opt.volume->answer)
G_fatal_error(_("%s= and %s= are mutually exclusive"),
opt.rast->key, opt.volume->key);
cmap = NULL;
if (opt.rast->answer)
cmap = opt.rast->answer;
if (opt.volume->answer)
cmap = opt.volume->answer;
if (!cmap && !style && !rules && !remove && !convert)
G_fatal_error(_("One of -%c, -%c or %s=, %s= or %s= "
"must be specified"), flag.r->key, flag.c->key,
opt.colr->key, opt.rast->key, opt.rules->key);
if (!!style + !!cmap + !!rules > 1)
G_fatal_error(_("%s=, %s= and %s= are mutually exclusive"),
opt.colr->key, opt.rules->key, opt.rast->key);
if (flag.g->answer && flag.a->answer)
G_fatal_error(_("-%c and -%c are mutually exclusive"),
flag.g->key, flag.a->key);
if (flag.c->answer && !rgbcolumn)
G_fatal_error(_("%s= required for -%c"),
opt.rgbcol->key, flag.c->key);
is_from_stdin = rules && strcmp(rules, "-") == 0;
if (is_from_stdin)
G_fatal_error(_("Reading rules from standard input is not implemented yet, please provide path to rules file instead."));
mapset = G_find_vector(name, "");
if (!mapset)
G_fatal_error(_("Vector map <%s> not found"), name);
stat = -1;
if (remove) {
stat = Vect_remove_colors(name, mapset);
if (stat < 0)
G_fatal_error(_("Unable to remove color table of vector map <%s>"), name);
if (stat == 0)
G_warning(_("Color table of vector map <%s> not found"), name);
return EXIT_SUCCESS;
}
G_suppress_warnings(TRUE);
have_colors = Vect_read_colors(name, mapset, NULL);
if (have_colors > 0 && !overwrite) {
G_fatal_error(_("Color table exists. Exiting."));
}
G_suppress_warnings(FALSE);
/* open map and get min/max values */
Vect_set_open_level(1); /* no topology required */
if (Vect_open_old2(&Map, name, mapset, opt.field->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), name);
Vect_set_error_handler_io(&Map, NULL);
if (use == USE_Z && !Vect_is_3d(&Map))
G_fatal_error(_("Vector map <%s> is not 3D"), Vect_get_full_name(&Map));
layer = Vect_get_field_number(&Map, opt.field->answer);
if (layer < 1)
G_fatal_error(_("Layer <%s> not found"), opt.field->answer);
if (opt.range->answer) {
range.min = atof(opt.range->answers[0]);
range.max = atof(opt.range->answers[1]);
if (range.min > range.max)
G_fatal_error(_("Option <%s>: min must be greater or equal to max"),
opt.range->key);
}
Rast_init_colors(&colors);
if (is_from_stdin) {
G_fatal_error(_("Reading color rules from standard input is currently not supported"));
/*
if (!read_color_rules(stdin, &colors, min, max, fp))
exit(EXIT_FAILURE);
*/
} else if (style || rules) {
if (style && !G_find_color_rule(style))
G_fatal_error(_("Color table <%s> not found"), style);
if (use == USE_CAT) {
scan_cats(&Map, layer, style, rules,
opt.range->answer ? &range : NULL,
&colors);
}
else if (use == USE_Z) {
scan_z(&Map, layer, style, rules,
opt.range->answer ? &range : NULL,
&colors);
}
else {
scan_attr(&Map, layer, attrcolumn, style, rules,
opt.range->answer ? &range : NULL,
&colors);
}
}
else {
/* use color from another map (cmap) */
if (opt.rast->answer) {
cmapset = G_find_raster2(cmap, "");
if (!cmapset)
G_fatal_error(_("Raster map <%s> not found"), cmap);
if (Rast_read_colors(cmap, cmapset, &colors) < 0)
G_fatal_error(_("Unable to read color table for raster map <%s>"), cmap);
} else if (opt.volume->answer) {
cmapset = G_find_raster3d(cmap, "");
if (!cmapset)
G_fatal_error(_("3D raster map <%s> not found"), cmap);
if (Rast3d_read_colors(cmap, cmapset, &colors) < 0)
G_fatal_error(_("Unable to read color table for 3D raster map <%s>"), cmap);
}
}
if (flag.n->answer)
Rast_invert_colors(&colors);
/* TODO ?
if (flag.e->answer) {
if (!have_stats)
have_stats = get_stats(name, mapset, &statf);
Rast_histogram_eq_colors(&colors_tmp, &colors, &statf);
colors = colors_tmp;
}
*/
if (flag.g->answer) {
Rast_log_colors(&colors_tmp, &colors, 100);
colors = colors_tmp;
}
if (flag.a->answer) {
Rast_abs_log_colors(&colors_tmp, &colors, 100);
colors = colors_tmp;
}
G_important_message(_("Writing color rules..."));
if (style || rules || opt.rast->answer || opt.volume->answer) {
if (rgbcolumn)
write_rgb_values(&Map, layer, rgbcolumn, &colors);
else
Vect_write_colors(name, mapset, &colors);
}
if (convert) {
/* convert RGB values to color tables */
rgb2colr(&Map, layer, rgbcolumn, &colors);
Vect_write_colors(name, mapset, &colors);
}
Vect_close(&Map);
G_message(_("Color table for vector map <%s> set to '%s'"),
G_fully_qualified_name(name, mapset),
is_from_stdin || convert ? "rules" : style ? style : rules ? rules :
cmap);
exit(EXIT_SUCCESS);
}
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[])
{
RASTER3D_Region region, inputmap_bounds;
struct Cell_head region2d;
struct GModule *module;
struct History history;
void *map = NULL; /*The 3D Rastermap */
int i = 0, changemask = 0;
int *fd = NULL, output_type, cols, rows;
char *RasterFileName;
int overwrite = 0;
/* Initialize GRASS */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster3d"));
G_add_keyword(_("conversion"));
G_add_keyword(_("raster"));
G_add_keyword(_("voxel"));
module->description = _("Converts 3D raster maps to 2D raster maps");
/* Get parameters from user */
set_params();
/* Have GRASS get inputs */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
G_debug(3, "Open 3D raster map <%s>", param.input->answer);
if (NULL == G_find_raster3d(param.input->answer, ""))
Rast3d_fatal_error(_("3D raster map <%s> not found"),
param.input->answer);
/*Set the defaults */
Rast3d_init_defaults();
/*Set the resolution of the output maps */
if (param.res->answer) {
/*Open the map with current region */
map = Rast3d_open_cell_old(param.input->answer,
G_find_raster3d(param.input->answer, ""),
RASTER3D_DEFAULT_WINDOW, RASTER3D_TILE_SAME_AS_FILE,
RASTER3D_USE_CACHE_DEFAULT);
if (map == NULL)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"),
param.input->answer);
/*Get the region of the map */
Rast3d_get_region_struct_map(map, ®ion);
/*set this region as current 3D window for map */
Rast3d_set_window_map(map, ®ion);
/*Set the 2d region appropriate */
Rast3d_extract2d_region(®ion, ®ion2d);
/*Make the new 2d region the default */
Rast_set_window(®ion2d);
} else {
/* Figure out the region from the map */
Rast3d_get_window(®ion);
/*Open the 3d raster map */
map = Rast3d_open_cell_old(param.input->answer,
G_find_raster3d(param.input->answer, ""),
®ion, RASTER3D_TILE_SAME_AS_FILE,
RASTER3D_USE_CACHE_DEFAULT);
if (map == NULL)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"),
param.input->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 3D window 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(®ion2d);
region.ns_res = region2d.ns_res;
region.ew_res = region2d.ew_res;
region.rows = region2d.rows;
region.cols = region2d.cols;
Rast3d_adjust_region(®ion);
Rast3d_set_window_map(map, ®ion);
}
/* save the input map region for later use (history meta-data) */
Rast3d_get_region_struct_map(map, &inputmap_bounds);
/*Get the output type */
output_type = Rast3d_file_type_map(map);
/*prepare the filehandler */
fd = (int *) G_malloc(region.depths * sizeof (int));
if (fd == NULL)
fatal_error(map, NULL, 0, _("Out of memory"));
G_message(_("Creating %i raster maps"), region.depths);
/*Loop over all output maps! open */
for (i = 0; i < region.depths; i++) {
/*Create the outputmaps */
G_asprintf(&RasterFileName, "%s_%05d", param.output->answer, i + 1);
G_message(_("Raster map %i Filename: %s"), i + 1, RasterFileName);
overwrite = G_check_overwrite(argc, argv);
if (G_find_raster2(RasterFileName, "") && !overwrite)
G_fatal_error(_("Raster map %d Filename: %s already exists. Use the flag --o to overwrite."),
i + 1, RasterFileName);
if (output_type == FCELL_TYPE)
fd[i] = open_output_map(RasterFileName, FCELL_TYPE);
else if (output_type == DCELL_TYPE)
fd[i] = open_output_map(RasterFileName, DCELL_TYPE);
}
/*if requested set the Mask on */
if (param.mask->answer) {
if (Rast3d_mask_file_exists()) {
changemask = 0;
if (Rast3d_mask_is_off(map)) {
Rast3d_mask_on(map);
changemask = 1;
}
}
}
/*Create the Rastermaps */
g3d_to_raster(map, region, fd);
/*Loop over all output maps! close */
for (i = 0; i < region.depths; i++) {
close_output_map(fd[i]);
/* write history */
G_asprintf(&RasterFileName, "%s_%i", param.output->answer, i + 1);
G_debug(4, "Raster map %d Filename: %s", i + 1, RasterFileName);
Rast_short_history(RasterFileName, "raster", &history);
Rast_set_history(&history, HIST_DATSRC_1, "3D Raster map:");
Rast_set_history(&history, HIST_DATSRC_2, param.input->answer);
Rast_append_format_history(&history, "Level %d of %d", i + 1, region.depths);
Rast_append_format_history(&history, "Level z-range: %f to %f",
region.bottom + (i * region.tb_res),
region.bottom + (i + 1 * region.tb_res));
Rast_append_format_history(&history, "Input map full z-range: %f to %f",
inputmap_bounds.bottom, inputmap_bounds.top);
Rast_append_format_history(&history, "Input map z-resolution: %f",
inputmap_bounds.tb_res);
if (!param.res->answer) {
Rast_append_format_history(&history, "GIS region full z-range: %f to %f",
region.bottom, region.top);
Rast_append_format_history(&history, "GIS region z-resolution: %f",
region.tb_res);
}
Rast_command_history(&history);
Rast_write_history(RasterFileName, &history);
}
/*We set the Mask off, if it was off before */
if (param.mask->answer) {
if (Rast3d_mask_file_exists())
if (Rast3d_mask_is_on(map) && changemask)
Rast3d_mask_off(map);
}
/*Cleaning */
if (RasterFileName)
G_free(RasterFileName);
if (fd)
G_free(fd);
/* Close files and exit */
if (!Rast3d_close(map))
fatal_error(map, NULL, 0, _("Unable to close 3D raster map"));
map = NULL;
return (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;
}
int main(int argc, char **argv)
{
struct Flag *printattributes, *topo_flag, *shell_flag;
struct Option *map_opt, *field_opt, *coords_opt, *maxdistance;
struct Cell_head window;
struct GModule *module;
char buf[2000];
int i, level, ret;
int *field;
double xval, yval, xres, yres, maxd, x;
double EW_DIST1, EW_DIST2, NS_DIST1, NS_DIST2;
char nsres[30], ewres[30];
char ch;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("position"));
G_add_keyword(_("querying"));
module->description = _("Queries a vector map at given locations.");
map_opt = G_define_standard_option(G_OPT_V_MAPS);
field_opt = G_define_standard_option(G_OPT_V_FIELD_ALL);
coords_opt = G_define_standard_option(G_OPT_M_EN);
coords_opt->label = _("Coordinates for query");
coords_opt->description = _("If not given read from standard input");
maxdistance = G_define_option();
maxdistance->type = TYPE_DOUBLE;
maxdistance->key = "distance";
maxdistance->answer = "0";
maxdistance->multiple = NO;
maxdistance->description = _("Query threshold distance");
topo_flag = G_define_flag();
topo_flag->key = 'd';
topo_flag->description = _("Print topological information (debugging)");
topo_flag->guisection = _("Print");
printattributes = G_define_flag();
printattributes->key = 'a';
printattributes->description = _("Print attribute information");
printattributes->guisection = _("Print");
shell_flag = G_define_flag();
shell_flag->key = 'g';
shell_flag->description = _("Print the stats in shell script style");
shell_flag->guisection = _("Print");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (map_opt->answers && map_opt->answers[0])
vect = map_opt->answers;
maxd = atof(maxdistance->answer);
/*
* fprintf(stdout, maxdistance->answer);
* fprintf(stdout, "Maxd is %f", maxd);
* fprintf(stdout, xcoord->answer);
* fprintf(stdout, "xval is %f", xval);
* fprintf(stdout, ycoord->answer);
* fprintf(stdout, "yval is %f", yval);
*/
if (maxd == 0.0) {
G_get_window(&window);
x = window.proj;
G_format_resolution(window.ew_res, ewres, x);
G_format_resolution(window.ns_res, nsres, x);
EW_DIST1 =
G_distance(window.east, window.north, window.west, window.north);
/* EW Dist at South Edge */
EW_DIST2 =
G_distance(window.east, window.south, window.west, window.south);
/* NS Dist at East edge */
NS_DIST1 =
G_distance(window.east, window.north, window.east, window.south);
/* NS Dist at West edge */
NS_DIST2 =
G_distance(window.west, window.north, window.west, window.south);
xres = ((EW_DIST1 + EW_DIST2) / 2) / window.cols;
yres = ((NS_DIST1 + NS_DIST2) / 2) / window.rows;
if (xres > yres)
maxd = xres;
else
maxd = yres;
}
/* Look at maps given on command line */
if (vect) {
for (i = 0; vect[i]; i++)
;
nvects = i;
for (i = 0; field_opt->answers[i]; i++)
;
if (nvects != i)
G_fatal_error(_("Number of given vector maps (%d) differs from number of layers (%d)"),
nvects, i);
Map = (struct Map_info *) G_malloc(nvects * sizeof(struct Map_info));
field = (int *) G_malloc(nvects * sizeof(int));
for (i = 0; i < nvects; i++) {
level = Vect_open_old2(&Map[i], vect[i], "", field_opt->answers[i]);
if (level < 2)
G_fatal_error(_("You must build topology on vector map <%s>"),
vect[i]);
field[i] = Vect_get_field_number(&Map[i], field_opt->answers[i]);
}
}
if (!coords_opt->answer) {
/* read them from stdin */
setvbuf(stdin, NULL, _IOLBF, 0);
setvbuf(stdout, NULL, _IOLBF, 0);
while (fgets(buf, sizeof(buf), stdin) != NULL) {
ret = sscanf(buf, "%lf%c%lf", &xval, &ch, &yval);
if (ret == 3 && (ch == ',' || ch == ' ' || ch == '\t')) {
what(xval, yval, maxd, topo_flag->answer,
printattributes->answer, shell_flag->answer, field);
}
else {
G_warning(_("Unknown input format, skipping: '%s'"), buf);
continue;
}
}
}
else {
/* use coords given on command line */
for (i = 0; coords_opt->answers[i] != NULL; i += 2) {
xval = atof(coords_opt->answers[i]);
yval = atof(coords_opt->answers[i + 1]);
what(xval, yval, maxd, topo_flag->answer,
printattributes->answer, shell_flag->answer, field);
}
}
for (i = 0; i < nvects; i++)
Vect_close(&Map[i]);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int i, type, stat;
int day, yr, Out_proj;
int out_zone = 0;
int overwrite; /* overwrite output map */
const char *mapset;
const char *omap_name, *map_name, *iset_name, *iloc_name;
struct pj_info info_in;
struct pj_info info_out;
const char *gbase;
char date[40], mon[4];
struct GModule *module;
struct Option *omapopt, *mapopt, *isetopt, *ilocopt, *ibaseopt, *smax;
struct Key_Value *in_proj_keys, *in_unit_keys;
struct Key_Value *out_proj_keys, *out_unit_keys;
struct line_pnts *Points, *Points2;
struct line_cats *Cats;
struct Map_info Map;
struct Map_info Out_Map;
struct bound_box src_box, tgt_box;
int nowrap = 0, recommend_nowrap = 0;
double lmax;
struct
{
struct Flag *list; /* list files in source location */
struct Flag *transformz; /* treat z as ellipsoidal height */
struct Flag *wrap; /* latlon output: wrap to 0,360 */
struct Flag *no_topol; /* do not build topology */
} flag;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("projection"));
G_add_keyword(_("transformation"));
G_add_keyword(_("import"));
module->description = _("Re-projects a vector map from one location to the current location.");
/* set up the options and flags for the command line parser */
ilocopt = G_define_standard_option(G_OPT_M_LOCATION);
ilocopt->required = YES;
ilocopt->label = _("Location containing input vector map");
ilocopt->guisection = _("Source");
isetopt = G_define_standard_option(G_OPT_M_MAPSET);
isetopt->label = _("Mapset containing input vector map");
isetopt->description = _("Default: name of current mapset");
isetopt->guisection = _("Source");
mapopt = G_define_standard_option(G_OPT_V_INPUT);
mapopt->required = NO;
mapopt->label = _("Name of input vector map to re-project");
mapopt->description = NULL;
mapopt->guisection = _("Source");
ibaseopt = G_define_standard_option(G_OPT_M_DBASE);
ibaseopt->label = _("Path to GRASS database of input location");
smax = G_define_option();
smax->key = "smax";
smax->type = TYPE_DOUBLE;
smax->required = NO;
smax->answer = "10000";
smax->label = _("Maximum segment length in meters in output vector map");
smax->description = _("Increases accuracy of reprojected shapes, disable with smax=0");
smax->guisection = _("Target");
omapopt = G_define_standard_option(G_OPT_V_OUTPUT);
omapopt->required = NO;
omapopt->description = _("Name for output vector map (default: input)");
omapopt->guisection = _("Target");
flag.list = G_define_flag();
flag.list->key = 'l';
flag.list->description = _("List vector maps in input mapset and exit");
flag.transformz = G_define_flag();
flag.transformz->key = 'z';
flag.transformz->description = _("3D vector maps only");
flag.transformz->label =
_("Assume z coordinate is ellipsoidal height and "
"transform if possible");
flag.transformz->guisection = _("Target");
flag.wrap = G_define_flag();
flag.wrap->key = 'w';
flag.wrap->description = _("Latlon output only, default is -180,180");
flag.wrap->label =
_("Disable wrapping to -180,180 for latlon output");
flag.transformz->guisection = _("Target");
flag.no_topol = G_define_flag();
flag.no_topol->key = 'b';
flag.no_topol->label = _("Do not build vector topology");
flag.no_topol->description = _("Recommended for massive point projection");
/* The parser checks if the map already exists in current mapset,
we switch out the check and do it
in the module after the parser */
overwrite = G_check_overwrite(argc, argv);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* start checking options and flags */
/* set input vector map name and mapset */
map_name = mapopt->answer;
if (omapopt->answer)
omap_name = omapopt->answer;
else
omap_name = map_name;
if (omap_name && !flag.list->answer && !overwrite &&
G_find_vector2(omap_name, G_mapset()))
G_fatal_error(_("option <%s>: <%s> exists. To overwrite, use the --overwrite flag"), omapopt->key,
omap_name);
if (isetopt->answer)
iset_name = isetopt->answer;
else
iset_name = G_store(G_mapset());
iloc_name = ilocopt->answer;
if (ibaseopt->answer)
gbase = ibaseopt->answer;
else
gbase = G_store(G_gisdbase());
if (!ibaseopt->answer && strcmp(iloc_name, G_location()) == 0)
G_fatal_error(_("Input and output locations can not be the same"));
lmax = atof(smax->answer);
if (lmax < 0)
lmax = 0;
Out_proj = G_projection();
if (Out_proj == PROJECTION_LL && flag.wrap->answer)
nowrap = 1;
G_begin_distance_calculations();
/* Change the location here and then come back */
select_target_env();
G_setenv_nogisrc("GISDBASE", gbase);
G_setenv_nogisrc("LOCATION_NAME", iloc_name);
stat = G_mapset_permissions(iset_name);
if (stat >= 0) { /* yes, we can access the mapset */
/* if requested, list the vector maps in source location - MN 5/2001 */
if (flag.list->answer) {
int i;
char **list;
G_verbose_message(_("Checking location <%s> mapset <%s>"),
iloc_name, iset_name);
list = G_list(G_ELEMENT_VECTOR, G_getenv_nofatal("GISDBASE"),
G_getenv_nofatal("LOCATION_NAME"), iset_name);
if (list[0]) {
for (i = 0; list[i]; i++) {
fprintf(stdout, "%s\n", list[i]);
}
fflush(stdout);
}
else {
G_important_message(_("No vector maps found"));
}
exit(EXIT_SUCCESS); /* leave v.proj after listing */
}
if (mapopt->answer == NULL) {
G_fatal_error(_("Required parameter <%s> not set"), mapopt->key);
}
G_setenv_nogisrc("MAPSET", iset_name);
/* Make sure map is available */
mapset = G_find_vector2(map_name, iset_name);
if (mapset == NULL)
G_fatal_error(_("Vector map <%s> in location <%s> mapset <%s> not found"),
map_name, iloc_name, iset_name);
/*** Get projection info for input mapset ***/
in_proj_keys = G_get_projinfo();
if (in_proj_keys == NULL)
exit(EXIT_FAILURE);
/* apparently the +over switch must be set in the input projection,
* not the output latlon projection */
if (Out_proj == PROJECTION_LL && nowrap == 1)
G_set_key_value("+over", "defined", in_proj_keys);
in_unit_keys = G_get_projunits();
if (in_unit_keys == NULL)
exit(EXIT_FAILURE);
if (pj_get_kv(&info_in, in_proj_keys, in_unit_keys) < 0)
exit(EXIT_FAILURE);
Vect_set_open_level(1);
G_debug(1, "Open old: location: %s mapset : %s", G_location_path(),
G_mapset());
if (Vect_open_old(&Map, map_name, mapset) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), map_name);
}
else if (stat < 0)
{ /* allow 0 (i.e. denied permission) */
/* need to be able to read from others */
if (stat == 0)
G_fatal_error(_("Mapset <%s> in input location <%s> - permission denied"),
iset_name, iloc_name);
else
G_fatal_error(_("Mapset <%s> in input location <%s> not found"),
iset_name, iloc_name);
}
select_current_env();
/****** get the output projection parameters ******/
out_proj_keys = G_get_projinfo();
if (out_proj_keys == NULL)
exit(EXIT_FAILURE);
out_unit_keys = G_get_projunits();
if (out_unit_keys == NULL)
exit(EXIT_FAILURE);
if (pj_get_kv(&info_out, out_proj_keys, out_unit_keys) < 0)
exit(EXIT_FAILURE);
G_free_key_value(in_proj_keys);
G_free_key_value(in_unit_keys);
G_free_key_value(out_proj_keys);
G_free_key_value(out_unit_keys);
if (G_verbose() == G_verbose_max()) {
pj_print_proj_params(&info_in, &info_out);
}
/* Initialize the Point / Cat structure */
Points = Vect_new_line_struct();
Points2 = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
/* test if latlon wrapping to -180,180 should be disabled */
if (Out_proj == PROJECTION_LL && nowrap == 0) {
int first = 1, counter = 0;
double x, y;
/* Cycle through all lines */
Vect_rewind(&Map);
while (1) {
type = Vect_read_next_line(&Map, Points, Cats); /* read line */
if (type == 0)
continue; /* Dead */
if (type == -1)
G_fatal_error(_("Reading input vector map"));
if (type == -2)
break;
if (first && Points->n_points > 0) {
first = 0;
src_box.E = src_box.W = Points->x[0];
src_box.N = src_box.S = Points->y[0];
src_box.T = src_box.B = Points->z[0];
}
for (i = 0; i < Points->n_points; i++) {
if (src_box.E < Points->x[i])
src_box.E = Points->x[i];
if (src_box.W > Points->x[i])
src_box.W = Points->x[i];
if (src_box.N < Points->y[i])
src_box.N = Points->y[i];
if (src_box.S > Points->y[i])
src_box.S = Points->y[i];
}
counter++;
}
if (counter == 0) {
G_warning(_("Input vector map <%s> is empty"), omap_name);
exit(EXIT_SUCCESS);
}
/* NW corner */
x = src_box.W;
y = src_box.N;
if (pj_do_transform(1, &x, &y, NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Error in pj_do_transform"));
}
tgt_box.E = x;
tgt_box.W = x;
tgt_box.N = y;
tgt_box.S = y;
/* SW corner */
x = src_box.W;
y = src_box.S;
if (pj_do_transform(1, &x, &y, NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Error in pj_do_transform"));
}
if (tgt_box.W > x)
tgt_box.W = x;
if (tgt_box.E < x)
tgt_box.E = x;
if (tgt_box.N < y)
tgt_box.N = y;
if (tgt_box.S > y)
tgt_box.S = y;
/* NE corner */
x = src_box.E;
y = src_box.N;
if (pj_do_transform(1, &x, &y, NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Error in pj_do_transform"));
}
if (tgt_box.W > x) {
tgt_box.E = x + 360;
recommend_nowrap = 1;
}
if (tgt_box.N < y)
tgt_box.N = y;
if (tgt_box.S > y)
tgt_box.S = y;
/* SE corner */
x = src_box.E;
y = src_box.S;
if (pj_do_transform(1, &x, &y, NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Error in pj_do_transform"));
}
if (tgt_box.W > x) {
if (tgt_box.E < x + 360)
tgt_box.E = x + 360;
recommend_nowrap = 1;
}
if (tgt_box.N < y)
tgt_box.N = y;
if (tgt_box.S > y)
tgt_box.S = y;
}
G_debug(1, "Open new: location: %s mapset : %s", G_location_path(),
G_mapset());
if (Vect_open_new(&Out_Map, omap_name, Vect_is_3d(&Map)) < 0)
G_fatal_error(_("Unable to create vector map <%s>"), omap_name);
Vect_set_error_handler_io(NULL, &Out_Map); /* register standard i/o error handler */
Vect_copy_head_data(&Map, &Out_Map);
Vect_hist_copy(&Map, &Out_Map);
Vect_hist_command(&Out_Map);
out_zone = info_out.zone;
Vect_set_zone(&Out_Map, out_zone);
/* Read and write header info */
sprintf(date, "%s", G_date());
sscanf(date, "%*s%s%d%*s%d", mon, &day, &yr);
if (yr < 2000)
yr = yr - 1900;
else
yr = yr - 2000;
sprintf(date, "%s %d %d", mon, day, yr);
Vect_set_date(&Out_Map, date);
/* line densification works only with vector topology */
if (Map.format != GV_FORMAT_NATIVE)
lmax = 0;
/* Cycle through all lines */
Vect_rewind(&Map);
i = 0;
G_message(_("Reprojecting primitives ..."));
while (TRUE) {
++i;
G_progress(i, 1e3);
type = Vect_read_next_line(&Map, Points, Cats); /* read line */
if (type == 0)
continue; /* Dead */
if (type == -1)
G_fatal_error(_("Reading input vector map"));
if (type == -2)
break;
Vect_line_prune(Points);
if (lmax > 0 && (type & GV_LINES) && Points->n_points > 1) {
double x1, y1, z1, x2, y2, z2;
double dx, dy, dz;
double l;
int i, n;
Vect_reset_line(Points2);
for (i = 0; i < Points->n_points - 1; i++) {
x1 = Points->x[i];
y1 = Points->y[i];
z1 = Points->z[i];
n = i + 1;
x2 = Points->x[n];
y2 = Points->y[n];
z2 = Points->z[n];
dx = x2 - x1;
dy = y2 - y1;
dz = z2 - z1;
if (pj_do_transform(1, &x1, &y1,
flag.transformz->answer ? &z1 : NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Unable to re-project vector map <%s> from <%s>"),
Vect_get_full_name(&Map), ilocopt->answer);
}
if (pj_do_transform(1, &x2, &y2,
flag.transformz->answer ? &z2 : NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Unable to re-project vector map <%s> from <%s>"),
Vect_get_full_name(&Map), ilocopt->answer);
}
Vect_append_point(Points2, x1, y1, z1);
l = G_distance(x1, y1, x2, y2);
if (l > lmax) {
int j;
double x, y, z;
x1 = Points->x[i];
y1 = Points->y[i];
z1 = Points->z[i];
n = ceil(l / lmax);
for (j = 1; j < n; j++) {
x = x1 + dx * j / n;
y = y1 + dy * j / n;
z = z1 + dz * j / n;
if (pj_do_transform(1, &x, &y,
flag.transformz->answer ? &z : NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Unable to re-project vector map <%s> from <%s>"),
Vect_get_full_name(&Map), ilocopt->answer);
}
Vect_append_point(Points2, x, y, z);
}
}
}
Vect_append_point(Points2, x2, y2, z2);
Vect_write_line(&Out_Map, type, Points2, Cats); /* write line */
}
else {
if (pj_do_transform(Points->n_points, Points->x, Points->y,
flag.transformz->answer ? Points->z : NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Unable to re-project vector map <%s> from <%s>"),
Vect_get_full_name(&Map), ilocopt->answer);
}
Vect_write_line(&Out_Map, type, Points, Cats); /* write line */
}
} /* end lines section */
G_progress(1, 1);
/* Copy tables */
if (Vect_copy_tables(&Map, &Out_Map, 0))
G_warning(_("Failed to copy attribute table to output map"));
Vect_close(&Map);
if (!flag.no_topol->answer)
Vect_build(&Out_Map);
Vect_close(&Out_Map);
if (recommend_nowrap)
G_important_message(_("Try to disable wrapping to -180,180 "
"if topological errors occurred"));
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct GModule *module;
int infile;
const char *mapset;
size_t cell_size;
int ytile, xtile, y, overlap;
int *outfiles;
void *inbuf;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("tiling"));
module->description =
_("Splits a raster map into tiles.");
parm.rastin = G_define_standard_option(G_OPT_R_INPUT);
parm.rastout = G_define_option();
parm.rastout->key = "output";
parm.rastout->type = TYPE_STRING;
parm.rastout->required = YES;
parm.rastout->multiple = NO;
parm.rastout->description = _("Output base name");
parm.width = G_define_option();
parm.width->key = "width";
parm.width->type = TYPE_INTEGER;
parm.width->required = YES;
parm.width->multiple = NO;
parm.width->description = _("Width of tiles (columns)");
parm.height = G_define_option();
parm.height->key = "height";
parm.height->type = TYPE_INTEGER;
parm.height->required = YES;
parm.height->multiple = NO;
parm.height->description = _("Height of tiles (rows)");
parm.overlap = G_define_option();
parm.overlap->key = "overlap";
parm.overlap->type = TYPE_INTEGER;
parm.overlap->required = NO;
parm.overlap->multiple = NO;
parm.overlap->description = _("Overlap of tiles");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
G_get_set_window(&src_w);
overlap = parm.overlap->answer ? atoi(parm.overlap->answer) : 0;
mapset = G_find_raster2(parm.rastin->answer, "");
if (mapset == NULL)
G_fatal_error(_("Raster map <%s> not found"), parm.rastin->answer);
/* set window to old map */
Rast_get_cellhd(parm.rastin->answer, "", &src_w);
dst_w = src_w;
dst_w.cols = atoi(parm.width->answer);
dst_w.rows = atoi(parm.height->answer);
G_adjust_Cell_head(&dst_w, 1, 1);
xtiles = (src_w.cols + dst_w.cols - 1) / dst_w.cols;
ytiles = (src_w.rows + dst_w.rows - 1) / dst_w.rows;
G_debug(1, "X: %d * %d, Y: %d * %d",
xtiles, dst_w.cols, ytiles, dst_w.rows);
src_w.cols = xtiles * dst_w.cols + 2 * overlap;
src_w.rows = ytiles * dst_w.rows + 2 * overlap;
src_w.west = src_w.west - overlap * src_w.ew_res;
src_w.east = src_w.west + (src_w.cols + 2 * overlap) * src_w.ew_res;
src_w.north = src_w.north + overlap * src_w.ns_res;
src_w.south = src_w.north - (src_w.rows + 2 * overlap) * src_w.ns_res;
Rast_set_input_window(&src_w);
/* set the output region */
ovl_w = dst_w;
ovl_w.cols = ovl_w.cols + 2 * overlap;
ovl_w.rows = ovl_w.rows + 2 * overlap;
G_adjust_Cell_head(&ovl_w, 1, 1);
Rast_set_output_window(&ovl_w);
infile = Rast_open_old(parm.rastin->answer, "");
map_type = Rast_get_map_type(infile);
cell_size = Rast_cell_size(map_type);
inbuf = Rast_allocate_input_buf(map_type);
outfiles = G_malloc(xtiles * sizeof(int));
G_debug(1, "X: %d * %d, Y: %d * %d",
xtiles, dst_w.cols, ytiles, dst_w.rows);
G_message(_("Generating %d x %d = %d tiles..."), xtiles, ytiles, xtiles * ytiles);
for (ytile = 0; ytile < ytiles; ytile++) {
G_debug(1, "reading y tile: %d", ytile);
G_percent(ytile, ytiles, 2);
for (xtile = 0; xtile < xtiles; xtile++) {
char name[GNAME_MAX];
sprintf(name, "%s-%03d-%03d", parm.rastout->answer, ytile, xtile);
outfiles[xtile] = Rast_open_new(name, map_type);
}
for (y = 0; y < ovl_w.rows; y++) {
int row = ytile * dst_w.rows + y;
G_debug(1, "reading row: %d", row);
Rast_get_row(infile, inbuf, row, map_type);
for (xtile = 0; xtile < xtiles; xtile++) {
int cells = xtile * dst_w.cols;
void *ptr = G_incr_void_ptr(inbuf, cells * cell_size);
Rast_put_row(outfiles[xtile], ptr, map_type);
}
}
for (xtile = 0; xtile < xtiles; xtile++) {
Rast_close(outfiles[xtile]);
write_support_files(xtile, ytile, overlap);
}
}
Rast_close(infile);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct Option *in_opt, *layer_opt, *out_opt, *length_opt, *units_opt, *vertices_opt;
struct Map_info In, Out;
struct line_pnts *Points, *Points2;
struct line_cats *Cats;
int line, nlines, layer;
double length = -1;
int vertices = 0;
double (*line_length) ();
int latlon = 0;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("geometry"));
module->description = _("Splits vector lines to shorter segments.");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
layer_opt = G_define_standard_option(G_OPT_V_FIELD_ALL);
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
length_opt = G_define_option();
length_opt->key = "length";
length_opt->type = TYPE_DOUBLE;
length_opt->required = NO;
length_opt->multiple = NO;
length_opt->description = _("Maximum segment length");
units_opt = G_define_option();
units_opt->key = "units";
units_opt->type = TYPE_STRING;
units_opt->required = NO;
units_opt->multiple = NO;
units_opt->options = "meters,kilometers,feet,miles,nautmiles";
units_opt->answer = "meters";
units_opt->description = _("Length units");
vertices_opt = G_define_option();
vertices_opt->key = "vertices";
vertices_opt->type = TYPE_INTEGER;
vertices_opt->required = NO;
vertices_opt->multiple = NO;
vertices_opt->description = _("Maximum number of vertices in segment");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if ((length_opt->answer && vertices_opt->answer) ||
!(length_opt->answer || vertices_opt->answer))
G_fatal_error(_("Use either length or vertices"));
line_length = NULL;
if (length_opt->answer) {
length = atof(length_opt->answer);
if (length <= 0)
G_fatal_error(_("Length must be positive but is %g"), length);
/* convert length to meters */
if (strcmp(units_opt->answer, "meters") == 0)
/* do nothing */ ;
else if (strcmp(units_opt->answer, "kilometers") == 0)
length *= FROM_KILOMETERS;
else if (strcmp(units_opt->answer, "feet") == 0)
length *= FROM_FEET;
else if (strcmp(units_opt->answer, "miles") == 0)
length *= FROM_MILES;
else if (strcmp(units_opt->answer, "nautmiles") == 0)
length *= FROM_NAUTMILES;
else
G_fatal_error(_("Unknown unit %s"), units_opt->answer);
/* set line length function */
if ((latlon = (G_projection() == PROJECTION_LL)) == 1)
line_length = Vect_line_geodesic_length;
else {
double factor;
line_length = Vect_line_length;
/* convert length to map units */
if ((factor = G_database_units_to_meters_factor()) == 0)
G_fatal_error(_("Can not get projection units"));
else {
/* meters to units */
length = length / factor;
}
}
G_verbose_message(_("length in %s: %g"), (latlon ? "meters" : "map units"), length);
}
if (vertices_opt->answer) {
vertices = atoi(vertices_opt->answer);
if (vertices < 2)
G_fatal_error(_("Number of vertices must be at least 2"));
}
Vect_set_open_level(2);
Vect_open_old2(&In, in_opt->answer, "", layer_opt->answer);
layer = Vect_get_field_number(&In, layer_opt->answer);
Vect_open_new(&Out, out_opt->answer, Vect_is_3d(&In));
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
Vect_copy_tables(&In, &Out, layer);
Points = Vect_new_line_struct();
Points2 = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
nlines = Vect_get_num_lines(&In);
for (line = 1; line <= nlines; line++) {
int ltype;
G_percent(line, nlines, 1);
if (!Vect_line_alive(&In, line))
continue;
ltype = Vect_read_line(&In, Points, Cats, line);
if (layer != -1 && !Vect_cat_get(Cats, layer, NULL))
continue;
if (ltype & GV_LINES) {
if (length > 0) {
double l, from, to, step;
l = line_length(Points);
if (l <= length) {
Vect_write_line(&Out, ltype, Points, Cats);
}
else {
int n, i;
n = ceil(l / length);
if (latlon)
l = Vect_line_length(Points);
step = l / n;
from = 0.;
for (i = 0; i < n; i++) {
int ret;
double x, y, z;
if (i == n - 1) {
to = l; /* to be sure that it goes to end */
}
else {
to = from + step;
}
ret = Vect_line_segment(Points, from, to, Points2);
if (ret == 0) {
G_warning(_("Unable to make line segment: %f - %f (line length = %f)"),
from, to, l);
continue;
}
/* To be sure that the coordinates are identical */
if (i > 0) {
Points2->x[0] = x;
Points2->y[0] = y;
Points2->z[0] = z;
}
if (i == n - 1) {
Points2->x[Points2->n_points - 1] =
Points->x[Points->n_points - 1];
Points2->y[Points2->n_points - 1] =
Points->y[Points->n_points - 1];
Points2->z[Points2->n_points - 1] =
Points->z[Points->n_points - 1];
}
Vect_write_line(&Out, ltype, Points2, Cats);
/* last point */
x = Points2->x[Points2->n_points - 1];
y = Points2->y[Points2->n_points - 1];
z = Points2->z[Points2->n_points - 1];
from += step;
}
}
}
else {
int start = 0; /* number of coordinates written */
while (start < Points->n_points - 1) {
int i, v;
Vect_reset_line(Points2);
for (i = 0; i < vertices; i++) {
v = start + i;
if (v == Points->n_points)
break;
Vect_append_point(Points2, Points->x[v], Points->y[v],
Points->z[v]);
}
Vect_write_line(&Out, ltype, Points2, Cats);
start = v;
}
}
}
else {
Vect_write_line(&Out, ltype, Points, Cats);
}
}
Vect_close(&In);
Vect_build(&Out);
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
struct Cell_head window;
RASTER_MAP_TYPE raster_type, mag_raster_type = -1;
int layer_fd;
void *raster_row, *ptr;
int nrows, ncols;
int aspect_c = -1;
float aspect_f = -1.0;
double scale;
int skip, no_arrow;
char *mag_map = NULL;
void *mag_raster_row = NULL, *mag_ptr = NULL;
double length = -1;
int mag_fd = -1;
struct FPRange range;
double mag_min, mag_max;
struct GModule *module;
struct Option *opt1, *opt2, *opt3, *opt4, *opt5,
*opt6, *opt7, *opt8, *opt9;
struct Flag *align;
double t, b, l, r;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("raster"));
module->description =
_("Draws arrows representing cell aspect direction "
"for a raster map containing aspect data.");
opt1 = G_define_standard_option(G_OPT_R_MAP);
opt1->description = _("Name of raster aspect map to be displayed");
opt2 = G_define_option();
opt2->key = "type";
opt2->type = TYPE_STRING;
opt2->required = NO;
opt2->answer = "grass";
opt2->options = "grass,compass,agnps,answers";
opt2->description = _("Type of existing raster aspect map");
opt3 = G_define_option();
opt3->key = "arrow_color";
opt3->type = TYPE_STRING;
opt3->required = NO;
opt3->answer = "green";
opt3->gisprompt = "old_color,color,color";
opt3->description = _("Color for drawing arrows");
opt3->guisection = _("Colors");
opt4 = G_define_option();
opt4->key = "grid_color";
opt4->type = TYPE_STRING;
opt4->required = NO;
opt4->answer = "gray";
opt4->gisprompt = "old_color,color,color_none";
opt4->description = _("Color for drawing grid or \"none\"");
opt4->guisection = _("Colors");
opt5 = G_define_option();
opt5->key = "x_color";
opt5->type = TYPE_STRING;
opt5->required = NO;
opt5->answer = DEFAULT_FG_COLOR;
opt5->gisprompt = "old_color,color,color_none";
opt5->description = _("Color for drawing X's (null values)");
opt5->guisection = _("Colors");
opt6 = G_define_option();
opt6->key = "unknown_color";
opt6->type = TYPE_STRING;
opt6->required = NO;
opt6->answer = "red";
opt6->gisprompt = "old_color,color,color_none";
opt6->description = _("Color for showing unknown information");
opt6->guisection = _("Colors");
opt9 = G_define_option();
opt9->key = "skip";
opt9->type = TYPE_INTEGER;
opt9->required = NO;
opt9->answer = "1";
opt9->description = _("Draw arrow every Nth grid cell");
opt7 = G_define_option();
opt7->key = "magnitude_map";
opt7->type = TYPE_STRING;
opt7->required = NO;
opt7->multiple = NO;
opt7->gisprompt = "old,cell,raster";
opt7->description =
_("Raster map containing values used for arrow length");
opt8 = G_define_option();
opt8->key = "scale";
opt8->type = TYPE_DOUBLE;
opt8->required = NO;
opt8->answer = "1.0";
opt8->description = _("Scale factor for arrows (magnitude map)");
align = G_define_flag();
align->key = 'a';
align->description = _("Align grids with raster cells");
/* Check command line */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
layer_name = opt1->answer;
arrow_color = D_translate_color(opt3->answer);
x_color = D_translate_color(opt5->answer);
unknown_color = D_translate_color(opt6->answer);
if (strcmp("none", opt4->answer) == 0)
grid_color = -1;
else
grid_color = D_translate_color(opt4->answer);
if (strcmp("grass", opt2->answer) == 0)
map_type = 1;
else if (strcmp("agnps", opt2->answer) == 0)
map_type = 2;
else if (strcmp("answers", opt2->answer) == 0)
map_type = 3;
else if (strcmp("compass", opt2->answer) == 0)
map_type = 4;
scale = atof(opt8->answer);
if (scale <= 0.0)
G_fatal_error(_("Illegal value for scale factor"));
skip = atoi(opt9->answer);
if (skip <= 0)
G_fatal_error(_("Illegal value for skip factor"));
if (opt7->answer) {
if (map_type != 1 && map_type != 4)
G_fatal_error(_("Magnitude is only supported for GRASS and compass aspect maps."));
mag_map = opt7->answer;
}
else if (scale != 1.0)
G_warning(_("Scale option requires magnitude_map"));
/* Setup driver and check important information */
if (D_open_driver() != 0)
G_fatal_error(_("No graphics device selected. "
"Use d.mon to select graphics device."));
D_setup(0);
/* Read in the map window associated with window */
G_get_window(&window);
if (align->answer) {
struct Cell_head wind;
Rast_get_cellhd(layer_name, "", &wind);
/* expand window extent by one wind resolution */
wind.west += wind.ew_res * ((int)((window.west - wind.west) / wind.ew_res) - (window.west < wind.west));
wind.east += wind.ew_res * ((int)((window.east - wind.east) / wind.ew_res) + (window.east > wind.east));
wind.south += wind.ns_res * ((int)((window.south - wind.south) / wind.ns_res) - (window.south < wind.south));
wind.north += wind.ns_res * ((int)((window.north - wind.north) / wind.ns_res) + (window.north > wind.north));
wind.rows = (wind.north - wind.south) / wind.ns_res;
wind.cols = (wind.east - wind.west) / wind.ew_res;
Rast_set_window(&wind);
nrows = wind.rows;
ncols = wind.cols;
t = (wind.north - window.north) * nrows / (wind.north - wind.south);
b = t + (window.north - window.south) * nrows / (wind.north - wind.south);
l = (window.west - wind.west) * ncols / (wind.east - wind.west);
r = l + (window.east - window.west) * ncols / (wind.east - wind.west);
} else {
nrows = window.rows;
ncols = window.cols;
t = 0;
b = nrows;
l = 0;
r = ncols;
}
D_set_src(t, b, l, r);
D_update_conversions();
/* figure out arrow scaling if using a magnitude map */
if (opt7->answer) {
Rast_init_fp_range(&range); /* really needed? */
if (Rast_read_fp_range(mag_map, "", &range) != 1)
G_fatal_error(_("Problem reading range file"));
Rast_get_fp_range_min_max(&range, &mag_min, &mag_max);
scale *= 1.5 / fabs(mag_max);
G_debug(3, "scaling=%.2f rast_max=%.2f", scale, mag_max);
}
if (grid_color > 0) { /* ie not "none" */
/* Set color */
D_use_color(grid_color);
/* Draw vertical grids */
for (col = 0; col < ncols; col++)
D_line_abs(col, 0, col, nrows);
/* Draw horizontal grids */
for (row = 0; row < nrows; row++)
D_line_abs(0, row, ncols, row);
}
/* open the raster map */
layer_fd = Rast_open_old(layer_name, "");
raster_type = Rast_get_map_type(layer_fd);
/* allocate the cell array */
raster_row = Rast_allocate_buf(raster_type);
if (opt7->answer) {
/* open the magnitude raster map */
mag_fd = Rast_open_old(mag_map, "");
mag_raster_type = Rast_get_map_type(mag_fd);
/* allocate the cell array */
mag_raster_row = Rast_allocate_buf(mag_raster_type);
}
/* loop through cells, find value, determine direction (n,s,e,w,ne,se,sw,nw),
and call appropriate function to draw an arrow on the cell */
for (row = 0; row < nrows; row++) {
Rast_get_row(layer_fd, raster_row, row, raster_type);
ptr = raster_row;
if (opt7->answer) {
Rast_get_row(mag_fd, mag_raster_row, row, mag_raster_type);
mag_ptr = mag_raster_row;
}
for (col = 0; col < ncols; col++) {
if (row % skip != 0)
no_arrow = TRUE;
else
no_arrow = FALSE;
if (col % skip != 0)
no_arrow = TRUE;
/* find aspect direction based on cell value */
if (raster_type == CELL_TYPE)
aspect_f = *((CELL *) ptr);
else if (raster_type == FCELL_TYPE)
aspect_f = *((FCELL *) ptr);
else if (raster_type == DCELL_TYPE)
aspect_f = *((DCELL *) ptr);
if (opt7->answer) {
if (mag_raster_type == CELL_TYPE)
length = *((CELL *) mag_ptr);
else if (mag_raster_type == FCELL_TYPE)
length = *((FCELL *) mag_ptr);
else if (mag_raster_type == DCELL_TYPE)
length = *((DCELL *) mag_ptr);
length *= scale;
if (Rast_is_null_value(mag_ptr, mag_raster_type)) {
G_debug(5, "Invalid arrow length [NULL]. Skipping.");
no_arrow = TRUE;
}
else if (length <= 0.0) { /* use fabs() or theta+=180? */
G_debug(5, "Illegal arrow length [%.3f]. Skipping.",
length);
no_arrow = TRUE;
}
}
if (no_arrow) {
ptr = G_incr_void_ptr(ptr, Rast_cell_size(raster_type));
if (opt7->answer)
mag_ptr =
G_incr_void_ptr(mag_ptr,
Rast_cell_size(mag_raster_type));
no_arrow = FALSE;
continue;
}
/* treat AGNPS and ANSWERS data like old zero-as-null CELL */
/* TODO: update models */
if (map_type == 2 || map_type == 3) {
if (Rast_is_null_value(ptr, raster_type))
aspect_c = 0;
else
aspect_c = (int)(aspect_f + 0.5);
}
/** Now draw the arrows **/
/* case switch for standard GRASS aspect map
measured in degrees counter-clockwise from east */
if (map_type == 1) {
D_use_color(arrow_color);
if (Rast_is_null_value(ptr, raster_type)) {
D_use_color(x_color);
draw_x();
D_use_color(arrow_color);
}
else if (aspect_f >= 0.0 && aspect_f <= 360.0) {
if (opt7->answer)
arrow_mag(aspect_f, length);
else
arrow_360(aspect_f);
}
else {
D_use_color(unknown_color);
unknown_();
D_use_color(arrow_color);
}
}
/* case switch for AGNPS type aspect map */
else if (map_type == 2) {
D_use_color(arrow_color);
switch (aspect_c) {
case 0:
D_use_color(x_color);
draw_x();
D_use_color(arrow_color);
break;
case 1:
arrow_n();
break;
case 2:
arrow_ne();
break;
case 3:
arrow_e();
break;
case 4:
arrow_se();
break;
case 5:
arrow_s();
break;
case 6:
arrow_sw();
break;
case 7:
arrow_w();
break;
case 8:
arrow_nw();
break;
default:
D_use_color(unknown_color);
unknown_();
D_use_color(arrow_color);
break;
}
}
/* case switch for ANSWERS type aspect map */
else if (map_type == 3) {
D_use_color(arrow_color);
if (aspect_c >= 15 && aspect_c <= 360) /* start at zero? */
arrow_360((double)aspect_c);
else if (aspect_c == 400) {
D_use_color(unknown_color);
unknown_();
D_use_color(arrow_color);
}
else {
D_use_color(x_color);
draw_x();
D_use_color(arrow_color);
}
}
/* case switch for compass type aspect map
measured in degrees clockwise from north */
else if (map_type == 4) {
D_use_color(arrow_color);
if (Rast_is_null_value(ptr, raster_type)) {
D_use_color(x_color);
draw_x();
D_use_color(arrow_color);
}
else if (aspect_f >= 0.0 && aspect_f <= 360.0) {
if (opt7->answer)
arrow_mag(90 - aspect_f, length);
else
arrow_360(90 - aspect_f);
}
else {
D_use_color(unknown_color);
unknown_();
D_use_color(arrow_color);
}
}
ptr = G_incr_void_ptr(ptr, Rast_cell_size(raster_type));
if (opt7->answer)
mag_ptr =
G_incr_void_ptr(mag_ptr, Rast_cell_size(mag_raster_type));
}
}
Rast_close(layer_fd);
if (opt7->answer)
Rast_close(mag_fd);
D_save_command(G_recreate_command());
D_close_driver();
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct Option *map_opt, *type_opt, *field_opt, *col_opt, *where_opt,
*percentile;
struct Flag *shell_flag, *extended;
struct Map_info Map;
struct field_info *Fi;
dbDriver *Driver;
dbCatValArray Cvarr;
struct line_pnts *Points;
struct line_cats *Cats;
int otype, ofield;
int compatible = 1; /* types are compatible: point+centroid or line+boundary or area */
int nrec, ctype, nlines, line, nareas, area;
int nmissing = 0; /* number of missing atttributes */
int nnull = 0; /* number of null values */
int first = 1;
/* Statistics */
int count = 0; /* number of features with non-null attribute */
double sum = 0.0;
double sumsq = 0.0;
double sumcb = 0.0;
double sumqt = 0.0;
double sum_abs = 0.0;
double min = 0.0 / 0.0; /* init as nan */
double max = 0.0 / 0.0;
double mean, mean_abs, pop_variance, sample_variance, pop_stdev,
sample_stdev, pop_coeff_variation, kurtosis, skewness;
double total_size = 0.0; /* total size: length/area */
/* Extended statistics */
int perc;
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("statistics"));
module->label =
_("Calculates univariate statistics for attribute.");
module->description = _("Variance and standard "
"deviation is calculated only for points if specified.");
map_opt = G_define_standard_option(G_OPT_V_MAP);
field_opt = G_define_standard_option(G_OPT_V_FIELD);
type_opt = G_define_standard_option(G_OPT_V_TYPE);
type_opt->options = "point,line,boundary,centroid,area";
col_opt = G_define_standard_option(G_OPT_DB_COLUMN);
col_opt->required = YES;
where_opt = G_define_standard_option(G_OPT_DB_WHERE);
percentile = G_define_option();
percentile->key = "percentile";
percentile->type = TYPE_INTEGER;
percentile->required = NO;
percentile->options = "0-100";
percentile->answer = "90";
percentile->description =
_("Percentile to calculate (requires extended statistics flag)");
shell_flag = G_define_flag();
shell_flag->key = 'g';
shell_flag->description = _("Print the stats in shell script style");
extended = G_define_flag();
extended->key = 'e';
extended->description = _("Calculate extended statistics");
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
otype = Vect_option_to_types(type_opt);
perc = atoi(percentile->answer);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
/* open input vector */
Vect_set_open_level(2);
Vect_open_old2(&Map, map_opt->answer, "", field_opt->answer);
ofield = Vect_get_field_number(&Map, field_opt->answer);
/* Check if types are compatible */
if ((otype & GV_POINTS) && ((otype & GV_LINES) || (otype & GV_AREA)))
compatible = 0;
if ((otype & GV_LINES) && (otype & GV_AREA))
compatible = 0;
if (!compatible) {
G_warning(_("Incompatible vector type(s) specified, only number of features, minimum, maximum and range "
"can be calculated"));
}
if (extended->answer && !(otype & GV_POINTS)) {
G_warning(_("Extended statistics is currently supported only for points/centroids"));
}
/* Read attributes */
db_CatValArray_init(&Cvarr);
Fi = Vect_get_field(&Map, ofield);
if (Fi == NULL) {
G_fatal_error(_(" Database connection not defined for layer <%s>"), field_opt->answer);
}
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);
/* Note do not check if the column exists in the table because it may be an expression */
nrec =
db_select_CatValArray(Driver, Fi->table, Fi->key, col_opt->answer,
where_opt->answer, &Cvarr);
G_debug(2, "nrec = %d", nrec);
ctype = Cvarr.ctype;
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Column type not supported"));
if (nrec < 0)
G_fatal_error(_("Unable to select data from table"));
db_close_database_shutdown_driver(Driver);
/* Lines */
nlines = Vect_get_num_lines(&Map);
for (line = 1; line <= nlines; line++) {
int i, type;
G_debug(3, "line = %d", line);
type = Vect_read_line(&Map, Points, Cats, line);
if (!(type & otype))
continue;
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == ofield) {
double val;
dbCatVal *catval;
G_debug(3, "cat = %d", Cats->cat[i]);
if (db_CatValArray_get_value(&Cvarr, Cats->cat[i], &catval) !=
DB_OK) {
G_debug(3, "No record for cat = %d", Cats->cat[i]);
nmissing++;
continue;
}
if (catval->isNull) {
G_debug(3, "NULL value for cat = %d", Cats->cat[i]);
nnull++;
continue;
}
if (ctype == DB_C_TYPE_INT) {
val = catval->val.i;
}
else if (ctype == DB_C_TYPE_DOUBLE) {
val = catval->val.d;
}
count++;
if (first) {
max = val;
min = val;
first = 0;
}
else {
if (val > max)
max = val;
if (val < min)
min = val;
}
if (compatible) {
if (type & GV_POINTS) {
sum += val;
sumsq += val * val;
sumcb += val * val * val;
sumqt += val * val * val * val;
sum_abs += fabs(val);
}
else { /* GV_LINES */
double l;
l = Vect_line_length(Points);
sum += l * val;
sumsq += l * val * val;
sumcb += l * val * val * val;
sumqt += l * val * val * val * val;
sum_abs += l * fabs(val);
total_size += l;
}
}
G_debug(3, "sum = %f total_size = %f", sum, total_size);
}
}
}
if (otype & GV_AREA) {
nareas = Vect_get_num_areas(&Map);
for (area = 1; area <= nareas; area++) {
int i, centr;
G_debug(3, "area = %d", area);
centr = Vect_get_area_centroid(&Map, area);
if (centr < 1)
continue;
G_debug(3, "centr = %d", centr);
Vect_read_line(&Map, NULL, Cats, centr);
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == ofield) {
double val;
dbCatVal *catval;
G_debug(3, "cat = %d", Cats->cat[i]);
if (db_CatValArray_get_value
(&Cvarr, Cats->cat[i], &catval) != DB_OK) {
G_debug(3, "No record for cat = %d", Cats->cat[i]);
nmissing++;
continue;
}
if (catval->isNull) {
G_debug(3, "NULL value for cat = %d", Cats->cat[i]);
nnull++;
continue;
}
if (ctype == DB_C_TYPE_INT) {
val = catval->val.i;
}
else if (ctype == DB_C_TYPE_DOUBLE) {
val = catval->val.d;
}
count++;
if (first) {
max = val;
min = val;
first = 0;
}
else {
if (val > max)
max = val;
if (val < min)
min = val;
}
if (compatible) {
double a;
a = Vect_get_area_area(&Map, area);
sum += a * val;
sumsq += a * val * val;
sumcb += a * val * val * val;
sumqt += a * val * val * val * val;
sum_abs += a * fabs(val);
total_size += a;
}
G_debug(4, "sum = %f total_size = %f", sum, total_size);
}
}
}
}
G_debug(2, "sum = %f total_size = %f", sum, total_size);
if (compatible) {
if ((otype & GV_LINES) || (otype & GV_AREA)) {
mean = sum / total_size;
mean_abs = sum_abs / total_size;
/* Roger Bivand says it is wrong see GRASS devel list 7/2004 */
/*
pop_variance = (sumsq - sum*sum/total_size)/total_size;
pop_stdev = sqrt(pop_variance);
*/
}
else {
double n = count;
mean = sum / count;
mean_abs = sum_abs / count;
pop_variance = (sumsq - sum * sum / count) / count;
pop_stdev = sqrt(pop_variance);
pop_coeff_variation = pop_stdev / (sqrt(sum * sum) / count);
sample_variance = (sumsq - sum * sum / count) / (count - 1);
sample_stdev = sqrt(sample_variance);
kurtosis =
(sumqt / count - 4 * sum * sumcb / (n * n) +
6 * sum * sum * sumsq / (n * n * n) -
3 * sum * sum * sum * sum / (n * n * n * n))
/ (sample_stdev * sample_stdev * sample_stdev *
sample_stdev) - 3;
skewness =
(sumcb / n - 3 * sum * sumsq / (n * n) +
2 * sum * sum * sum / (n * n * n))
/ (sample_stdev * sample_stdev * sample_stdev);
}
}
G_debug(3, "otype %d:", otype);
if (shell_flag->answer) {
fprintf(stdout, "n=%d\n", count);
fprintf(stdout, "nmissing=%d\n", nmissing);
fprintf(stdout, "nnull=%d\n", nnull);
if (count > 0) {
fprintf(stdout, "min=%g\n", min);
fprintf(stdout, "max=%g\n", max);
fprintf(stdout, "range=%g\n", max - min);
if (compatible && (otype & GV_POINTS)) {
fprintf(stdout, "mean=%g\n", mean);
fprintf(stdout, "mean_abs=%g\n", mean_abs);
fprintf(stdout, "population_stddev=%g\n", pop_stdev);
fprintf(stdout, "population_variance=%g\n", pop_variance);
fprintf(stdout, "population_coeff_variation=%g\n",
pop_coeff_variation);
if (otype & GV_POINTS) {
fprintf(stdout, "sample_stddev=%g\n", sample_stdev);
fprintf(stdout, "sample_variance=%g\n", sample_variance);
fprintf(stdout, "kurtosis=%g\n", kurtosis);
fprintf(stdout, "skewness=%g\n", skewness);
}
}
}
}
else {
fprintf(stdout, "number of features with non NULL attribute: %d\n",
count);
fprintf(stdout, "number of missing attributes: %d\n", nmissing);
fprintf(stdout, "number of NULL attributes: %d\n", nnull);
if (count > 0) {
fprintf(stdout, "minimum: %g\n", min);
fprintf(stdout, "maximum: %g\n", max);
fprintf(stdout, "range: %g\n", max - min);
if (compatible && (otype & GV_POINTS)) {
fprintf(stdout, "mean: %g\n", mean);
fprintf(stdout, "mean of absolute values: %g\n", mean_abs);
fprintf(stdout, "population standard deviation: %g\n",
pop_stdev);
fprintf(stdout, "population variance: %g\n", pop_variance);
fprintf(stdout, "population coefficient of variation: %g\n",
pop_coeff_variation);
if (otype & GV_POINTS) {
fprintf(stdout, "sample standard deviation: %g\n",
sample_stdev);
fprintf(stdout, "sample variance: %g\n", sample_variance);
fprintf(stdout, "kurtosis: %g\n", kurtosis);
fprintf(stdout, "skewness: %g\n", skewness);
}
}
}
}
/* TODO: mode, skewness, kurtosis */
if (extended->answer && compatible && (otype & GV_POINTS) && count > 0) {
double quartile_25 = 0.0, quartile_75 = 0.0, quartile_perc = 0.0;
double median = 0.0;
int qpos_25, qpos_75, qpos_perc;
qpos_25 = (int)(count * 0.25 - 0.5);
qpos_75 = (int)(count * 0.75 - 0.5);
qpos_perc = (int)(count * perc / 100. - 0.5);
if (db_CatValArray_sort_by_value(&Cvarr) != DB_OK)
G_fatal_error(_("Cannot sort the key/value array"));
if (Cvarr.ctype == DB_C_TYPE_INT) {
quartile_25 = (Cvarr.value[qpos_25]).val.i;
if (count % 2) /* odd */
median = (Cvarr.value[(int)(count / 2)]).val.i;
else /* even */
median =
((Cvarr.value[count / 2 - 1]).val.i +
(Cvarr.value[count / 2]).val.i) / 2.0;
quartile_75 = (Cvarr.value[qpos_75]).val.i;
quartile_perc = (Cvarr.value[qpos_perc]).val.i;
}
else { /* must be DB_C_TYPE_DOUBLE */
quartile_25 = (Cvarr.value[qpos_25]).val.d;
if (count % 2) /* odd */
median = (Cvarr.value[(int)(count / 2)]).val.d;
else /* even */
median =
((Cvarr.value[count / 2 - 1]).val.d +
(Cvarr.value[count / 2]).val.d) / 2.0;
quartile_75 = (Cvarr.value[qpos_75]).val.d;
quartile_perc = (Cvarr.value[qpos_perc]).val.d;
}
if (shell_flag->answer) {
fprintf(stdout, "first_quartile=%g\n", quartile_25);
fprintf(stdout, "median=%g\n", median);
fprintf(stdout, "third_quartile=%g\n", quartile_75);
fprintf(stdout, "percentile_%d=%g\n", perc, quartile_perc);
}
else {
fprintf(stdout, "1st quartile: %g\n", quartile_25);
if (count % 2)
fprintf(stdout, "median (odd number of cells): %g\n", median);
else
fprintf(stdout, "median (even number of cells): %g\n",
median);
fprintf(stdout, "3rd quartile: %g\n", quartile_75);
if (perc % 10 == 1 && perc != 11)
fprintf(stdout, "%dst percentile: %g\n", perc, quartile_perc);
else if (perc % 10 == 2 && perc != 12)
fprintf(stdout, "%dnd percentile: %g\n", perc, quartile_perc);
else if (perc % 10 == 3 && perc != 13)
fprintf(stdout, "%drd percentile: %g\n", perc, quartile_perc);
else
fprintf(stdout, "%dth percentile: %g\n", perc, quartile_perc);
}
}
Vect_close(&Map);
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
struct Flag *printattributes, *topo_flag, *shell_flag;
struct Option *opt1, *coords_opt, *maxdistance;
struct Cell_head window;
struct GModule *module;
char *mapset;
char *str;
char buf[2000];
int i, j, level, width = 0, mwidth = 0, ret;
double xval, yval, xres, yres, maxd, x;
double EW_DIST1, EW_DIST2, NS_DIST1, NS_DIST2;
char nsres[30], ewres[30];
char ch;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("vector, querying");
module->description = _("Queries a vector map layer at given locations.");
opt1 = G_define_standard_option(G_OPT_V_MAP);
opt1->multiple = YES;
opt1->required = YES;
coords_opt = G_define_option();
coords_opt->key = "east_north";
coords_opt->type = TYPE_DOUBLE;
coords_opt->key_desc = "east,north";
coords_opt->required = NO;
coords_opt->multiple = YES;
coords_opt->label = _("Coordinates for query");
coords_opt->description = _("If not given reads from standard input");
maxdistance = G_define_option();
maxdistance->type = TYPE_DOUBLE;
maxdistance->key = "distance";
maxdistance->answer = "0";
maxdistance->multiple = NO;
maxdistance->description = _("Query threshold distance");
topo_flag = G_define_flag();
topo_flag->key = 'd';
topo_flag->description = _("Print topological information (debugging)");
printattributes = G_define_flag();
printattributes->key = 'a';
printattributes->description = _("Print attribute information");
shell_flag = G_define_flag();
shell_flag->key = 'g';
shell_flag->description = _("Print the stats in shell script style");
if ((argc > 1 || !vect) && G_parser(argc, argv))
exit(EXIT_FAILURE);
if (opt1->answers && opt1->answers[0])
vect = opt1->answers;
maxd = atof(maxdistance->answer);
/*
* fprintf(stdout, maxdistance->answer);
* fprintf(stdout, "Maxd is %f", maxd);
* fprintf(stdout, xcoord->answer);
* fprintf(stdout, "xval is %f", xval);
* fprintf(stdout, ycoord->answer);
* fprintf(stdout, "yval is %f", yval);
*/
if (maxd == 0.0) {
G_get_window(&window);
x = window.proj;
G_format_resolution(window.ew_res, ewres, x);
G_format_resolution(window.ns_res, nsres, x);
EW_DIST1 =
G_distance(window.east, window.north, window.west, window.north);
/* EW Dist at South Edge */
EW_DIST2 =
G_distance(window.east, window.south, window.west, window.south);
/* NS Dist at East edge */
NS_DIST1 =
G_distance(window.east, window.north, window.east, window.south);
/* NS Dist at West edge */
NS_DIST2 =
G_distance(window.west, window.north, window.west, window.south);
xres = ((EW_DIST1 + EW_DIST2) / 2) / window.cols;
yres = ((NS_DIST1 + NS_DIST2) / 2) / window.rows;
if (xres > yres)
maxd = xres;
else
maxd = yres;
}
/* Look at maps given on command line */
if (vect) {
for (i = 0; vect[i]; i++) ;
nvects = i;
Map = (struct Map_info *)G_malloc(nvects * sizeof(struct Map_info));
width = mwidth = 0;
for (i = 0; i < nvects; i++) {
str = strchr(vect[i], '@');
if (str)
j = str - vect[i];
else
j = strlen(vect[i]);
if (j > width)
width = j;
mapset = G_find_vector2(vect[i], "");
if (!mapset)
G_fatal_error(_("Vector map <%s> not found"), vect[i]);
j = strlen(mapset);
if (j > mwidth)
mwidth = j;
level = Vect_open_old(&Map[i], vect[i], mapset);
if (level < 2)
G_fatal_error(_("You must build topology on vector map <%s>"),
vect[i]);
G_verbose_message(_("Building spatial index..."));
Vect_build_spatial_index(&Map[i]);
}
}
if (!coords_opt->answer) {
/* if coords are not given on command line, read them from stdin */
setvbuf(stdin, NULL, _IOLBF, 0);
setvbuf(stdout, NULL, _IOLBF, 0);
while (fgets(buf, sizeof(buf), stdin) != NULL) {
ret = sscanf(buf, "%lf%c%lf", &xval, &ch, &yval);
if (ret == 3 && (ch == ',' || ch == ' ' || ch == '\t')) {
what(xval, yval, maxd, width, mwidth, topo_flag->answer,
printattributes->answer, shell_flag->answer);
}
else {
G_warning(_("Unknown input format, skipping: '%s'"), buf);
continue;
}
}
}
else {
/* use coords given on command line */
for (i = 0; coords_opt->answers[i] != NULL; i += 2) {
xval = atof(coords_opt->answers[i]);
yval = atof(coords_opt->answers[i + 1]);
what(xval, yval, maxd, width, mwidth, topo_flag->answer,
printattributes->answer, shell_flag->answer);
}
}
for (i = 0; i < nvects; i++)
Vect_close(&Map[i]);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
const char *input, *source, *output;
char *title;
struct Cell_head cellhd;
GDALDatasetH hDS;
GDALRasterBandH hBand;
struct GModule *module;
struct {
struct Option *input, *source, *output, *band, *title;
} parm;
struct {
struct Flag *o, *f, *e, *r, *h, *v;
} flag;
int min_band, max_band, band;
struct band_info info;
int flip;
struct Ref reference;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("import"));
G_add_keyword(_("input"));
G_add_keyword(_("external"));
module->description =
_("Links GDAL supported raster data as a pseudo GRASS raster map.");
parm.input = G_define_standard_option(G_OPT_F_INPUT);
parm.input->description = _("Name of raster file to be linked");
parm.input->required = NO;
parm.input->guisection = _("Input");
parm.source = G_define_option();
parm.source->key = "source";
parm.source->description = _("Name of non-file GDAL data source");
parm.source->required = NO;
parm.source->type = TYPE_STRING;
parm.source->key_desc = "name";
parm.source->guisection = _("Input");
parm.output = G_define_standard_option(G_OPT_R_OUTPUT);
parm.band = G_define_option();
parm.band->key = "band";
parm.band->type = TYPE_INTEGER;
parm.band->required = NO;
parm.band->description = _("Band to select (default: all)");
parm.band->guisection = _("Input");
parm.title = G_define_option();
parm.title->key = "title";
parm.title->key_desc = "phrase";
parm.title->type = TYPE_STRING;
parm.title->required = NO;
parm.title->description = _("Title for resultant raster map");
parm.title->guisection = _("Metadata");
flag.f = G_define_flag();
flag.f->key = 'f';
flag.f->description = _("List supported formats and exit");
flag.f->guisection = _("Print");
flag.f->suppress_required = YES;
flag.o = G_define_flag();
flag.o->key = 'o';
flag.o->description =
_("Override projection (use location's projection)");
flag.e = G_define_flag();
flag.e->key = 'e';
flag.e->description = _("Extend location extents based on new dataset");
flag.r = G_define_flag();
flag.r->key = 'r';
flag.r->description = _("Require exact range");
flag.h = G_define_flag();
flag.h->key = 'h';
flag.h->description = _("Flip horizontally");
flag.v = G_define_flag();
flag.v->key = 'v';
flag.v->description = _("Flip vertically");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
GDALAllRegister();
if (flag.f->answer) {
list_formats();
exit(EXIT_SUCCESS);
}
input = parm.input->answer;
source = parm.source->answer;
output = parm.output->answer;
flip = 0;
if (flag.h->answer)
flip |= FLIP_H;
if (flag.v->answer)
flip |= FLIP_V;
if (parm.title->answer) {
title = G_store(parm.title->answer);
G_strip(title);
}
else
title = NULL;
if (!input && !source)
G_fatal_error(_("One of options <%s> or <%s> must be given"),
parm.input->key, parm.source->key);
if (input && source)
G_fatal_error(_("Option <%s> and <%s> are mutually exclusive"),
parm.input->key, parm.source->key);
if (input && !G_is_absolute_path(input)) {
char path[GPATH_MAX];
getcwd(path, sizeof(path));
strcat(path, "/");
strcat(path, input);
input = G_store(path);
}
if (!input)
input = source;
hDS = GDALOpen(input, GA_ReadOnly);
if (hDS == NULL)
return 1;
setup_window(&cellhd, hDS, &flip);
check_projection(&cellhd, hDS, flag.o->answer);
Rast_set_window(&cellhd);
if (parm.band->answer)
min_band = max_band = atoi(parm.band->answer);
else
min_band = 1, max_band = GDALGetRasterCount(hDS);
G_verbose_message(_("Proceeding with import..."));
if (max_band > min_band) {
if (I_find_group(output) == 1)
G_warning(_("Imagery group <%s> already exists and will be overwritten."), output);
I_init_group_ref(&reference);
}
for (band = min_band; band <= max_band; band++) {
char *output2, *title2 = NULL;
G_message(_("Reading band %d of %d..."),
band, GDALGetRasterCount( hDS ));
hBand = GDALGetRasterBand(hDS, band);
if (!hBand)
G_fatal_error(_("Selected band (%d) does not exist"), band);
if (max_band > min_band) {
G_asprintf(&output2, "%s.%d", output, band);
if (title)
G_asprintf(&title2, "%s (band %d)", title, band);
G_debug(1, "Adding raster map <%s> to group <%s>", output2, output);
I_add_file_to_group_ref(output2, G_mapset(), &reference);
}
else {
output2 = G_store(output);
if (title)
title2 = G_store(title);
}
query_band(hBand, output2, flag.r->answer, &cellhd, &info);
create_map(input, band, output2, &cellhd, &info, title, flip);
G_free(output2);
G_free(title2);
}
if (flag.e->answer)
update_default_window(&cellhd);
/* Create the imagery group if multiple bands are imported */
if (max_band > min_band) {
I_put_group_ref(output, &reference);
I_put_group(output);
G_message(_("Imagery group <%s> created"), output);
}
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct Map_info in, out, vis;
struct GModule *module; /* GRASS module for parsing arguments */
struct Option *input, *output; /* The input map */
struct Option *coor, *ovis;
char *mapset;
struct Point *points;
struct Line *lines;
int num_points, num_lines;
int n = 0;
/* initialize GIS environment */
G_gisinit(argv[0]); /* reads grass env, stores program name to G_program_name() */
/* initialize module */
module = G_define_module();
module->keywords = _("vector, path, visibility");
module->description = _("Visibility graph construction.");
/* define the arguments needed */
input = G_define_standard_option(G_OPT_V_INPUT);
output = G_define_standard_option(G_OPT_V_OUTPUT);
coor = G_define_option();
coor->key = "coordinate";
coor->key_desc = "x,y";
coor->type = TYPE_STRING;
coor->required = NO;
coor->multiple = YES;
coor->description = _("One or more coordinates");
ovis = G_define_option();
ovis->key = "vis";
ovis->type = TYPE_STRING;
ovis->required = NO;
ovis->description = _("Add points after computing the vis graph");
/* options and flags parser */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
Vect_check_input_output_name(input->answer, output->answer,
GV_FATAL_EXIT);
Vect_set_open_level(2);
mapset = G_find_vector2(input->answer, NULL); /* finds the map */
if (mapset == NULL)
G_fatal_error("Vector map <%s> not found", input->answer);
if (Vect_open_old(&in, input->answer, mapset) < 1) /* opens the map */
G_fatal_error(_("Unable to open vector map <%s>"),
G_fully_qualified_name(input->answer, mapset));
if (Vect_open_new(&out, output->answer, WITHOUT_Z) < 0) {
Vect_close(&in);
G_fatal_error(_("Unable to create vector map <%s>"), output->answer);
}
if (ovis->answer != NULL) {
mapset = G_find_vector2(ovis->answer, NULL);
if (Vect_open_old(&vis, ovis->answer, mapset) < 1)
G_fatal_error(_("Unable to open vector map <%s>"),
G_fully_qualified_name(ovis->answer, mapset));
if (Vect_copy_map_lines(&vis, &out) > 0)
G_fatal_error(_("Unable to copy elements from vector map <%s>"),
G_fully_qualified_name(ovis->answer, mapset));
}
if (G_projection() == PROJECTION_LL)
G_warning(_("Lat-long projection"));
/* counting how many points and lines we have to allocate */
count(&in, &num_points, &num_lines);
/* modify the number if we have new points to add */
if (coor->answers != NULL)
num_points += count_new(coor->answers);
/* and allocate */
points = G_malloc(num_points * sizeof(struct Point));
lines = G_malloc(num_lines * sizeof(struct Line));
/* and finally set the lines */
load_lines(&in, &points, &num_points, &lines, &num_lines);
if (coor->answers != NULL)
add_points(coor->answers, &points, &num_points);
if (ovis->answer == NULL)
construct_visibility(points, num_points, lines, num_lines, &out);
else
visibility_points(points, num_points, lines, num_lines, &out, n);
G_free(points);
G_free(lines);
Vect_build(&out);
Vect_close(&out);
Vect_close(&in);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int ii;
int ret_val;
double x_orig, y_orig;
static int rand1 = 12345;
static int rand2 = 67891;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("hydrology"));
G_add_keyword(_("sediment flow"));
G_add_keyword(_("erosion"));
G_add_keyword(_("deposition"));
module->description =
_("Sediment transport and erosion/deposition simulation "
"using path sampling method (SIMWE).");
parm.elevin = G_define_standard_option(G_OPT_R_ELEV);
parm.wdepth = G_define_standard_option(G_OPT_R_INPUT);
parm.wdepth->key = "wdepth";
parm.wdepth->description = _("Name of water depth raster map [m]");
parm.dxin = G_define_standard_option(G_OPT_R_INPUT);
parm.dxin->key = "dx";
parm.dxin->description = _("Name of x-derivatives raster map [m/m]");
parm.dyin = G_define_standard_option(G_OPT_R_INPUT);
parm.dyin->key = "dy";
parm.dyin->description = _("Name of y-derivatives raster map [m/m]");
parm.detin = G_define_standard_option(G_OPT_R_INPUT);
parm.detin->key = "det";
parm.detin->description =
_("Name of detachment capacity coefficient raster map [s/m]");
parm.tranin = G_define_standard_option(G_OPT_R_INPUT);
parm.tranin->key = "tran";
parm.tranin->description =
_("Name of transport capacity coefficient raster map [s]");
parm.tauin = G_define_standard_option(G_OPT_R_INPUT);
parm.tauin->key = "tau";
parm.tauin->description =
_("Name of critical shear stress raster map [Pa]");
parm.manin = G_define_standard_option(G_OPT_R_INPUT);
parm.manin->key = "man";
parm.manin->required = NO;
parm.manin->description = _("Name of Manning's n raster map");
parm.manin->guisection = _("Input");
parm.maninval = G_define_option();
parm.maninval->key = "man_value";
parm.maninval->type = TYPE_DOUBLE;
parm.maninval->answer = MANINVAL;
parm.maninval->required = NO;
parm.maninval->description = _("Manning's n unique value");
parm.maninval->guisection = _("Input");
parm.outwalk = G_define_standard_option(G_OPT_V_OUTPUT);
parm.outwalk->key = "outwalk";
parm.outwalk->required = NO;
parm.outwalk->description =
_("Base name of the output walkers vector points map");
parm.outwalk->guisection = _("Output options");
parm.observation = G_define_standard_option(G_OPT_V_INPUT);
parm.observation->key = "observation";
parm.observation->required = NO;
parm.observation->description =
_("Name of sampling locations vector points map");
parm.observation->guisection = _("Input options");
parm.logfile = G_define_standard_option(G_OPT_F_OUTPUT);
parm.logfile->key = "logfile";
parm.logfile->required = NO;
parm.logfile->description =
_("Name for sampling points output text file. For each observation vector point the time series of sediment transport is stored.");
parm.logfile->guisection = _("Output");
parm.tc = G_define_standard_option(G_OPT_R_OUTPUT);
parm.tc->key = "tc";
parm.tc->required = NO;
parm.tc->description = _("Name for output transport capacity raster map [kg/ms]");
parm.tc->guisection = _("Output");
parm.et = G_define_standard_option(G_OPT_R_OUTPUT);
parm.et->key = "et";
parm.et->required = NO;
parm.et->description =
_("Name for output transport limited erosion-deposition raster map [kg/m2s]");
parm.et->guisection = _("Output");
parm.conc = G_define_standard_option(G_OPT_R_OUTPUT);
parm.conc->key = "conc";
parm.conc->required = NO;
parm.conc->description =
_("Name for output sediment concentration raster map [particle/m3]");
parm.conc->guisection = _("Output");
parm.flux = G_define_standard_option(G_OPT_R_OUTPUT);
parm.flux->key = "flux";
parm.flux->required = NO;
parm.flux->description = _("Name for output sediment flux raster map [kg/ms]");
parm.flux->guisection = _("Output");
parm.erdep = G_define_standard_option(G_OPT_R_OUTPUT);
parm.erdep->key = "erdep";
parm.erdep->required = NO;
parm.erdep->description =
_("Name for output erosion-deposition raster map [kg/m2s]");
parm.erdep->guisection = _("Output");
parm.nwalk = G_define_option();
parm.nwalk->key = "nwalk";
parm.nwalk->type = TYPE_INTEGER;
parm.nwalk->required = NO;
parm.nwalk->description = _("Number of walkers");
parm.nwalk->guisection = _("Parameters");
parm.niter = G_define_option();
parm.niter->key = "niter";
parm.niter->type = TYPE_INTEGER;
parm.niter->answer = NITER;
parm.niter->required = NO;
parm.niter->description = _("Time used for iterations [minutes]");
parm.niter->guisection = _("Parameters");
parm.outiter = G_define_option();
parm.outiter->key = "outiter";
parm.outiter->type = TYPE_INTEGER;
parm.outiter->answer = ITEROUT;
parm.outiter->required = NO;
parm.outiter->description =
_("Time interval for creating output maps [minutes]");
parm.outiter->guisection = _("Parameters");
/*
parm.density = G_define_option();
parm.density->key = "density";
parm.density->type = TYPE_INTEGER;
parm.density->answer = DENSITY;
parm.density->required = NO;
parm.density->description = _("Density of output walkers");
parm.density->guisection = _("Parameters");
*/
parm.diffc = G_define_option();
parm.diffc->key = "diffc";
parm.diffc->type = TYPE_DOUBLE;
parm.diffc->answer = DIFFC;
parm.diffc->required = NO;
parm.diffc->description = _("Water diffusion constant");
parm.diffc->guisection = _("Parameters");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
G_get_set_window(&cellhd);
conv = G_database_units_to_meters_factor();
mixx = cellhd.west * conv;
maxx = cellhd.east * conv;
miyy = cellhd.south * conv;
mayy = cellhd.north * conv;
stepx = cellhd.ew_res * conv;
stepy = cellhd.ns_res * conv;
/* step = amin1(stepx,stepy); */
step = (stepx + stepy) / 2.;
mx = cellhd.cols;
my = cellhd.rows;
x_orig = cellhd.west * conv;
y_orig = cellhd.south * conv; /* do we need this? */
xmin = 0.;
ymin = 0.;
xp0 = xmin + stepx / 2.;
yp0 = ymin + stepy / 2.;
xmax = xmin + stepx * (float)mx;
ymax = ymin + stepy * (float)my;
hhc = hhmax = 0.;
#if 0
bxmi = 2093113. * conv;
bymi = 731331. * conv;
bxma = 2093461. * conv;
byma = 731529. * conv;
bresx = 2. * conv;
bresy = 2. * conv;
maxwab = 100000;
mx2o = (int)((bxma - bxmi) / bresx);
my2o = (int)((byma - bymi) / bresy);
/* relative small box coordinates: leave 1 grid layer for overlap */
bxmi = bxmi - mixx + stepx;
bymi = bymi - miyy + stepy;
bxma = bxma - mixx - stepx;
byma = byma - miyy - stepy;
mx2 = mx2o - 2 * ((int)(stepx / bresx));
my2 = my2o - 2 * ((int)(stepy / bresy));
#endif
elevin = parm.elevin->answer;
wdepth = parm.wdepth->answer;
dxin = parm.dxin->answer;
dyin = parm.dyin->answer;
detin = parm.detin->answer;
tranin = parm.tranin->answer;
tauin = parm.tauin->answer;
manin = parm.manin->answer;
tc = parm.tc->answer;
et = parm.et->answer;
conc = parm.conc->answer;
flux = parm.flux->answer;
erdep = parm.erdep->answer;
outwalk = parm.outwalk->answer;
/* sscanf(parm.nwalk->answer, "%d", &maxwa); */
sscanf(parm.niter->answer, "%d", ×ec);
sscanf(parm.outiter->answer, "%d", &iterout);
/* sscanf(parm.density->answer, "%d", &ldemo); */
sscanf(parm.diffc->answer, "%lf", &frac);
sscanf(parm.maninval->answer, "%lf", &manin_val);
/* Recompute timesec from user input in minutes
* to real timesec in seconds */
timesec = timesec * 60.0;
iterout = iterout * 60.0;
if ((timesec / iterout) > 100.0)
G_message(_("More than 100 files are going to be created !!!!!"));
/* compute how big the raster is and set this to appr 2 walkers per cell */
if (parm.nwalk->answer == NULL) {
maxwa = mx * my * 2;
rwalk = (double)(mx * my * 2.);
G_message(_("default nwalk=%d, rwalk=%f"), maxwa, rwalk);
}
else {
sscanf(parm.nwalk->answer, "%d", &maxwa);
rwalk = (double)maxwa;
}
/*rwalk = (double) maxwa; */
if (conv != 1.0)
G_message(_("Using metric conversion factor %f, step=%f"), conv,
step);
if ((tc == NULL) && (et == NULL) && (conc == NULL) && (flux == NULL) &&
(erdep == NULL))
G_warning(_("You are not outputting any raster or site files"));
ret_val = input_data();
if (ret_val != 1)
G_fatal_error(_("Input failed"));
/* mandatory for si,sigma */
si = G_alloc_matrix(my, mx);
sigma = G_alloc_matrix(my, mx);
/* memory allocation for output grids */
dif = G_alloc_fmatrix(my, mx);
if (erdep != NULL || et != NULL)
er = G_alloc_fmatrix(my, mx);
seeds(rand1, rand2);
grad_check();
if (et != NULL)
erod(si);
/* treba dat output pre topoerdep */
main_loop();
if (tserie == NULL) {
ii = output_data(0, 1.);
if (ii != 1)
G_fatal_error(_("Cannot write raster maps"));
}
/* Exit with Success */
exit(EXIT_SUCCESS);
}
int main( int argc, char **argv )
{
struct GModule *module;
struct Option *info_opt, *rast_opt, *vect_opt, *coor_opt, *north_opt, *south_opt, *east_opt, *west_opt, *rows_opt, *cols_opt;
struct Cell_head window;
/* Initialize the GIS calls */
G_gisinit( argv[0] );
module = G_define_module();
module->description = ( "Get info about locations,mapsets,maps" );
info_opt = G_define_option();
info_opt->key = "info";
info_opt->type = TYPE_STRING;
info_opt->description = "info key";
info_opt->options = "proj,window,size,query,info,colors,stats";
rast_opt = G_define_standard_option( G_OPT_R_INPUT );
rast_opt->key = "rast";
rast_opt->required = NO;
vect_opt = G_define_standard_option( G_OPT_V_INPUT );
vect_opt->key = "vect";
vect_opt->required = NO;
coor_opt = G_define_option();
coor_opt->key = "coor";
coor_opt->type = TYPE_DOUBLE;
coor_opt->multiple = YES;
north_opt = G_define_option();
north_opt->key = "north";
north_opt->type = TYPE_STRING;
south_opt = G_define_option();
south_opt->key = "south";
south_opt->type = TYPE_STRING;
east_opt = G_define_option();
east_opt->key = "east";
east_opt->type = TYPE_STRING;
west_opt = G_define_option();
west_opt->key = "west";
west_opt->type = TYPE_STRING;
rows_opt = G_define_option();
rows_opt->key = "rows";
rows_opt->type = TYPE_INTEGER;
cols_opt = G_define_option();
cols_opt->key = "cols";
cols_opt->type = TYPE_INTEGER;
if ( G_parser( argc, argv ) )
exit( EXIT_FAILURE );
if ( strcmp( "proj", info_opt->answer ) == 0 )
{
G_get_window( &window );
/* code from g.proj */
if ( window.proj != PROJECTION_XY )
{
struct Key_Value *projinfo, *projunits;
char *wkt;
projinfo = G_get_projinfo();
projunits = G_get_projunits();
wkt = GPJ_grass_to_wkt( projinfo, projunits, 0, 0 );
fprintf( stdout, "%s", wkt );
}
}
else if ( strcmp( "window", info_opt->answer ) == 0 )
{
if ( rast_opt->answer )
{
G_get_cellhd( rast_opt->answer, "", &window );
fprintf( stdout, "%f,%f,%f,%f", window.west, window.south, window.east, window.north );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
// raster width and height
else if ( strcmp( "size", info_opt->answer ) == 0 )
{
if ( rast_opt->answer )
{
G_get_cellhd( rast_opt->answer, "", &window );
fprintf( stdout, "%d,%d", window.cols, window.rows );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
// raster informations
else if ( strcmp( "info", info_opt->answer ) == 0 )
{
struct FPRange range;
double zmin, zmax;
// Data type
RASTER_MAP_TYPE raster_type = G_raster_map_type( rast_opt->answer, "" );
fprintf( stdout, "TYPE:%d\n", raster_type );
// Statistics
if ( G_read_fp_range( rast_opt->answer, "", &range ) < 0 )
{
G_fatal_error(( "Unable to read range file" ) );
}
G_get_fp_range_min_max( &range, &zmin, &zmax );
fprintf( stdout, "MIN_VALUE:%.17e\n", zmin );
fprintf( stdout, "MAX_VALUE:%.17e\n", zmax );
}
else if ( strcmp( "colors", info_opt->answer ) == 0 )
{
// Color table
struct Colors colors;
int i, ccount;
if ( G_read_colors( rast_opt->answer, "", &colors ) == 1 )
{
//int maxcolor;
//CELL min, max;
//G_get_color_range ( &min, &max, &colors);
ccount = G_colors_count( &colors );
for ( i = ccount - 1; i >= 0; i-- )
{
DCELL val1, val2;
unsigned char r1, g1, b1, r2, g2, b2;
G_get_f_color_rule( &val1, &r1, &g1, &b1, &val2, &r2, &g2, &b2, &colors, i );
fprintf( stdout, "%.17e %.17e %d %d %d %d %d %d\n", val1, val2, r1, g1, b1, r2, g2, b2 );
}
}
}
else if ( strcmp( "query", info_opt->answer ) == 0 )
{
double x, y;
int row, col;
//x = atof( coor_opt->answers[0] );
//y = atof( coor_opt->answers[1] );
if ( rast_opt->answer )
{
int fd;
RASTER_MAP_TYPE rast_type;
DCELL *dcell;
CELL *cell;
char buff[101];
G_get_cellhd( rast_opt->answer, "", &window );
G_set_window( &window );
fd = G_open_cell_old( rast_opt->answer, "" );
// wait for coors from stdin
while ( fgets( buff, 100, stdin ) != 0 )
{
if ( sscanf( buff, "%lf%lf", &x, &y ) != 2 )
{
fprintf( stdout, "value:error\n" );
}
else
{
col = ( int ) G_easting_to_col( x, &window );
row = ( int ) G_northing_to_row( y, &window );
if ( col == window.cols )
col--;
if ( row == window.rows )
row--;
if ( col < 0 || col > window.cols || row < 0 || row > window.rows )
{
fprintf( stdout, "value:out\n" );
}
else
{
void *ptr;
double val;
#if defined(GRASS_VERSION_MAJOR) && defined(GRASS_VERSION_MINOR) && \
( ( GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR > 2 ) || GRASS_VERSION_MAJOR > 6 )
rast_type = G_get_raster_map_type( fd );
#else
rast_type = G_raster_map_type( rast_opt->answer, "" );
#endif
cell = G_allocate_c_raster_buf();
dcell = G_allocate_d_raster_buf();
if ( rast_type == CELL_TYPE )
{
if ( G_get_c_raster_row( fd, cell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
val = cell[col];
ptr = &( cell[col] );
}
else
{
if ( G_get_d_raster_row( fd, dcell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
val = dcell[col];
ptr = &( dcell[col] );
}
if ( G_is_null_value( ptr, rast_type ) )
{
fprintf( stdout, "value:null\n" );
}
else
{
fprintf( stdout, "value:%f\n", val );
}
}
}
fflush( stdout );
}
G_close_cell( fd );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
else if ( strcmp( "stats", info_opt->answer ) == 0 )
{
if ( rast_opt->answer )
{
int fd;
RASTER_MAP_TYPE rast_type;
DCELL *dcell;
CELL *cell;
int ncols, nrows;
int row, col;
void *ptr;
double val;
double min = DBL_MAX;
double max = -DBL_MAX;
double sum = 0; // sum of values
int count = 0; // count of non null values
double mean = 0;
double squares_sum = 0; // sum of squares
double stdev = 0; // standard deviation
G_get_cellhd( rast_opt->answer, "", &window );
window.north = atof( north_opt->answer );
window.south = atof( south_opt->answer );
window.east = atof( east_opt->answer );
window.west = atof( west_opt->answer );
window.rows = ( int ) atoi( rows_opt->answer );
window.cols = ( int ) atoi( cols_opt->answer );
G_set_window( &window );
fd = G_open_cell_old( rast_opt->answer, "" );
ncols = G_window_cols();
nrows = G_window_rows();
#if defined(GRASS_VERSION_MAJOR) && defined(GRASS_VERSION_MINOR) && \
( ( GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR > 2 ) || GRASS_VERSION_MAJOR > 6 )
rast_type = G_get_raster_map_type( fd );
#else
rast_type = G_raster_map_type( rast_opt->answer, "" );
#endif
cell = G_allocate_c_raster_buf();
dcell = G_allocate_d_raster_buf();
// Calc stats is very slow for large rasters -> prefer optimization for speed over
// code length and readability (which is not currently true)
for ( row = 0; row < nrows; row++ )
{
if ( rast_type == CELL_TYPE )
{
if ( G_get_c_raster_row( fd, cell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
}
else
{
if ( G_get_d_raster_row( fd, dcell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
}
for ( col = 0; col < ncols; col++ )
{
if ( rast_type == CELL_TYPE )
{
val = cell[col];
ptr = &( cell[col] );
}
else
{
val = dcell[col];
ptr = &( dcell[col] );
}
if ( ! G_is_null_value( ptr, rast_type ) )
{
if ( val < min ) min = val;
if ( val > max ) max = val;
sum += val;
count++;
squares_sum += pow( val, 2 );
}
}
}
mean = sum / count;
squares_sum -= count * pow( mean, 2 );
stdev = sqrt( squares_sum / ( count - 1 ) );
fprintf( stdout, "MIN:%.17e\n", min );
fprintf( stdout, "MAX:%.17e\n", max );
fprintf( stdout, "SUM:%.17e\n", sum );
fprintf( stdout, "MEAN:%.17e\n", mean );
fprintf( stdout, "COUNT:%d\n", count );
fprintf( stdout, "STDEV:%.17e\n", stdev );
fprintf( stdout, "SQSUM:%.17e\n", squares_sum );
G_close_cell( fd );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
exit( EXIT_SUCCESS );
}
int main(int argc, char **argv)
{
char *mapname, /* ptr to name of output layer */
*setname, /* ptr to name of input mapset */
*ipolname; /* name of interpolation method */
int fdi, /* input map file descriptor */
fdo, /* output map file descriptor */
method, /* position of method in table */
permissions, /* mapset permissions */
cell_type, /* output celltype */
cell_size, /* size of a cell in bytes */
row, col, /* counters */
irows, icols, /* original rows, cols */
orows, ocols, have_colors, /* Input map has a colour table */
overwrite, /* Overwrite */
curr_proj; /* output projection (see gis.h) */
void *obuffer, /* buffer that holds one output row */
*obufptr; /* column ptr in output buffer */
struct cache *ibuffer; /* buffer that holds the input map */
func interpolate; /* interpolation routine */
double xcoord1, xcoord2, /* temporary x coordinates */
ycoord1, ycoord2, /* temporary y coordinates */
col_idx, /* column index in input matrix */
row_idx, /* row index in input matrix */
onorth, osouth, /* save original border coords */
oeast, owest, inorth, isouth, ieast, iwest;
char north_str[30], south_str[30], east_str[30], west_str[30];
struct Colors colr; /* Input map colour table */
struct History history;
struct pj_info iproj, /* input map proj parameters */
oproj; /* output map proj parameters */
struct Key_Value *in_proj_info, /* projection information of */
*in_unit_info, /* input and output mapsets */
*out_proj_info, *out_unit_info;
struct GModule *module;
struct Flag *list, /* list files in source location */
*nocrop, /* don't crop output map */
*print_bounds, /* print output bounds and exit */
*gprint_bounds; /* same but print shell style */
struct Option *imapset, /* name of input mapset */
*inmap, /* name of input layer */
*inlocation, /* name of input location */
*outmap, /* name of output layer */
*indbase, /* name of input database */
*interpol, /* interpolation method:
nearest neighbor, bilinear, cubic */
*memory, /* amount of memory for cache */
*res; /* resolution of target map */
struct Cell_head incellhd, /* cell header of input map */
outcellhd; /* and output map */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("projection"));
G_add_keyword(_("transformation"));
module->description =
_("Re-projects a raster map from given location to the current location.");
inmap = G_define_standard_option(G_OPT_R_INPUT);
inmap->description = _("Name of input raster map to re-project");
inmap->required = NO;
inmap->guisection = _("Source");
inlocation = G_define_option();
inlocation->key = "location";
inlocation->type = TYPE_STRING;
inlocation->required = YES;
inlocation->description = _("Location containing input raster map");
inlocation->gisprompt = "old,location,location";
inlocation->key_desc = "name";
imapset = G_define_standard_option(G_OPT_M_MAPSET);
imapset->label = _("Mapset containing input raster map");
imapset->description = _("default: name of current mapset");
imapset->guisection = _("Source");
indbase = G_define_option();
indbase->key = "dbase";
indbase->type = TYPE_STRING;
indbase->required = NO;
indbase->description = _("Path to GRASS database of input location");
indbase->gisprompt = "old,dbase,dbase";
indbase->key_desc = "path";
indbase->guisection = _("Source");
outmap = G_define_standard_option(G_OPT_R_OUTPUT);
outmap->required = NO;
outmap->description = _("Name for output raster map (default: same as 'input')");
outmap->guisection = _("Target");
ipolname = make_ipol_list();
interpol = G_define_option();
interpol->key = "method";
interpol->type = TYPE_STRING;
interpol->required = NO;
interpol->answer = "nearest";
interpol->options = ipolname;
interpol->description = _("Interpolation method to use");
interpol->guisection = _("Target");
interpol->descriptions = make_ipol_desc();
memory = G_define_option();
memory->key = "memory";
memory->type = TYPE_INTEGER;
memory->required = NO;
memory->description = _("Cache size (MiB)");
res = G_define_option();
res->key = "resolution";
res->type = TYPE_DOUBLE;
res->required = NO;
res->description = _("Resolution of output raster map");
res->guisection = _("Target");
list = G_define_flag();
list->key = 'l';
list->description = _("List raster maps in input location and exit");
nocrop = G_define_flag();
nocrop->key = 'n';
nocrop->description = _("Do not perform region cropping optimization");
print_bounds = G_define_flag();
print_bounds->key = 'p';
print_bounds->description =
_("Print input map's bounds in the current projection and exit");
print_bounds->guisection = _("Target");
gprint_bounds = G_define_flag();
gprint_bounds->key = 'g';
gprint_bounds->description =
_("Print input map's bounds in the current projection and exit (shell style)");
gprint_bounds->guisection = _("Target");
/* The parser checks if the map already exists in current mapset,
we switch out the check and do it
in the module after the parser */
overwrite = G_check_overwrite(argc, argv);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* get the method */
for (method = 0; (ipolname = menu[method].name); method++)
if (strcmp(ipolname, interpol->answer) == 0)
break;
if (!ipolname)
G_fatal_error(_("<%s=%s> unknown %s"),
interpol->key, interpol->answer, interpol->key);
interpolate = menu[method].method;
mapname = outmap->answer ? outmap->answer : inmap->answer;
if (mapname && !list->answer && !overwrite &&
G_find_raster(mapname, G_mapset()))
G_fatal_error(_("option <%s>: <%s> exists."), "output", mapname);
setname = imapset->answer ? imapset->answer : G_store(G_mapset());
if (strcmp(inlocation->answer, G_location()) == 0 &&
(!indbase->answer || strcmp(indbase->answer, G_gisdbase()) == 0))
#if 0
G_fatal_error(_("Input and output locations can not be the same"));
#else
G_warning(_("Input and output locations are the same"));
#endif
G_get_window(&outcellhd);
if(gprint_bounds->answer && !print_bounds->answer)
print_bounds->answer = gprint_bounds->answer;
curr_proj = G_projection();
/* Get projection info for output mapset */
if ((out_proj_info = G_get_projinfo()) == NULL)
G_fatal_error(_("Unable to get projection info of output raster map"));
if ((out_unit_info = G_get_projunits()) == NULL)
G_fatal_error(_("Unable to get projection units of output raster map"));
if (pj_get_kv(&oproj, out_proj_info, out_unit_info) < 0)
G_fatal_error(_("Unable to get projection key values of output raster map"));
/* Change the location */
G__create_alt_env();
G__setenv("GISDBASE", indbase->answer ? indbase->answer : G_gisdbase());
G__setenv("LOCATION_NAME", inlocation->answer);
permissions = G__mapset_permissions(setname);
if (permissions < 0) /* can't access mapset */
G_fatal_error(_("Mapset <%s> in input location <%s> - %s"),
setname, inlocation->answer,
permissions == 0 ? _("permission denied")
: _("not found"));
/* if requested, list the raster maps in source location - MN 5/2001 */
if (list->answer) {
int i;
char **list;
G_verbose_message(_("Checking location <%s> mapset <%s>"),
inlocation->answer, setname);
list = G_list(G_ELEMENT_RASTER, G__getenv("GISDBASE"),
G__getenv("LOCATION_NAME"), setname);
for (i = 0; list[i]; i++) {
fprintf(stdout, "%s\n", list[i]);
}
fflush(stdout);
exit(EXIT_SUCCESS); /* leave r.proj after listing */
}
if (!inmap->answer)
G_fatal_error(_("Required parameter <%s> not set"), inmap->key);
if (!G_find_raster(inmap->answer, setname))
G_fatal_error(_("Raster map <%s> in location <%s> in mapset <%s> not found"),
inmap->answer, inlocation->answer, setname);
/* Read input map colour table */
have_colors = Rast_read_colors(inmap->answer, setname, &colr);
/* Get projection info for input mapset */
if ((in_proj_info = G_get_projinfo()) == NULL)
G_fatal_error(_("Unable to get projection info of input map"));
if ((in_unit_info = G_get_projunits()) == NULL)
G_fatal_error(_("Unable to get projection units of input map"));
if (pj_get_kv(&iproj, in_proj_info, in_unit_info) < 0)
G_fatal_error(_("Unable to get projection key values of input map"));
G_free_key_value(in_proj_info);
G_free_key_value(in_unit_info);
G_free_key_value(out_proj_info);
G_free_key_value(out_unit_info);
if (G_verbose() > G_verbose_std())
pj_print_proj_params(&iproj, &oproj);
/* this call causes r.proj to read the entire map into memeory */
Rast_get_cellhd(inmap->answer, setname, &incellhd);
Rast_set_input_window(&incellhd);
if (G_projection() == PROJECTION_XY)
G_fatal_error(_("Unable to work with unprojected data (xy location)"));
/* Save default borders so we can show them later */
inorth = incellhd.north;
isouth = incellhd.south;
ieast = incellhd.east;
iwest = incellhd.west;
irows = incellhd.rows;
icols = incellhd.cols;
onorth = outcellhd.north;
osouth = outcellhd.south;
oeast = outcellhd.east;
owest = outcellhd.west;
orows = outcellhd.rows;
ocols = outcellhd.cols;
if (print_bounds->answer) {
G_message(_("Input map <%s@%s> in location <%s>:"),
inmap->answer, setname, inlocation->answer);
if (pj_do_proj(&iwest, &isouth, &iproj, &oproj) < 0)
G_fatal_error(_("Error in pj_do_proj (projection of input coordinate pair)"));
if (pj_do_proj(&ieast, &inorth, &iproj, &oproj) < 0)
G_fatal_error(_("Error in pj_do_proj (projection of input coordinate pair)"));
G_format_northing(inorth, north_str, curr_proj);
G_format_northing(isouth, south_str, curr_proj);
G_format_easting(ieast, east_str, curr_proj);
G_format_easting(iwest, west_str, curr_proj);
if(gprint_bounds->answer) {
fprintf(stdout, "n=%s s=%s w=%s e=%s rows=%d cols=%d\n",
north_str, south_str, west_str, east_str, irows, icols);
}
else {
fprintf(stdout, "Source cols: %d\n", icols);
fprintf(stdout, "Source rows: %d\n", irows);
fprintf(stdout, "Local north: %s\n", north_str);
fprintf(stdout, "Local south: %s\n", south_str);
fprintf(stdout, "Local west: %s\n", west_str);
fprintf(stdout, "Local east: %s\n", east_str);
}
/* somehow approximate local ewres, nsres ?? (use 'g.region -m' on lat/lon side) */
exit(EXIT_SUCCESS);
}
/* Cut non-overlapping parts of input map */
if (!nocrop->answer)
bordwalk(&outcellhd, &incellhd, &oproj, &iproj);
/* Add 2 cells on each side for bilinear/cubic & future interpolation methods */
/* (should probably be a factor based on input and output resolution) */
incellhd.north += 2 * incellhd.ns_res;
incellhd.east += 2 * incellhd.ew_res;
incellhd.south -= 2 * incellhd.ns_res;
incellhd.west -= 2 * incellhd.ew_res;
if (incellhd.north > inorth)
incellhd.north = inorth;
if (incellhd.east > ieast)
incellhd.east = ieast;
if (incellhd.south < isouth)
incellhd.south = isouth;
if (incellhd.west < iwest)
incellhd.west = iwest;
Rast_set_input_window(&incellhd);
/* And switch back to original location */
G__switch_env();
/* Adjust borders of output map */
if (!nocrop->answer)
bordwalk(&incellhd, &outcellhd, &iproj, &oproj);
#if 0
outcellhd.west = outcellhd.south = HUGE_VAL;
outcellhd.east = outcellhd.north = -HUGE_VAL;
for (row = 0; row < incellhd.rows; row++) {
ycoord1 = Rast_row_to_northing((double)(row + 0.5), &incellhd);
for (col = 0; col < incellhd.cols; col++) {
xcoord1 = Rast_col_to_easting((double)(col + 0.5), &incellhd);
pj_do_proj(&xcoord1, &ycoord1, &iproj, &oproj);
if (xcoord1 > outcellhd.east)
outcellhd.east = xcoord1;
if (ycoord1 > outcellhd.north)
outcellhd.north = ycoord1;
if (xcoord1 < outcellhd.west)
outcellhd.west = xcoord1;
if (ycoord1 < outcellhd.south)
outcellhd.south = ycoord1;
}
}
#endif
if (res->answer != NULL) /* set user defined resolution */
outcellhd.ns_res = outcellhd.ew_res = atof(res->answer);
G_adjust_Cell_head(&outcellhd, 0, 0);
Rast_set_output_window(&outcellhd);
G_message(" ");
G_message(_("Input:"));
G_message(_("Cols: %d (%d)"), incellhd.cols, icols);
G_message(_("Rows: %d (%d)"), incellhd.rows, irows);
G_message(_("North: %f (%f)"), incellhd.north, inorth);
G_message(_("South: %f (%f)"), incellhd.south, isouth);
G_message(_("West: %f (%f)"), incellhd.west, iwest);
G_message(_("East: %f (%f)"), incellhd.east, ieast);
G_message(_("EW-res: %f"), incellhd.ew_res);
G_message(_("NS-res: %f"), incellhd.ns_res);
G_message(" ");
G_message(_("Output:"));
G_message(_("Cols: %d (%d)"), outcellhd.cols, ocols);
G_message(_("Rows: %d (%d)"), outcellhd.rows, orows);
G_message(_("North: %f (%f)"), outcellhd.north, onorth);
G_message(_("South: %f (%f)"), outcellhd.south, osouth);
G_message(_("West: %f (%f)"), outcellhd.west, owest);
G_message(_("East: %f (%f)"), outcellhd.east, oeast);
G_message(_("EW-res: %f"), outcellhd.ew_res);
G_message(_("NS-res: %f"), outcellhd.ns_res);
G_message(" ");
/* open and read the relevant parts of the input map and close it */
G__switch_env();
Rast_set_input_window(&incellhd);
fdi = Rast_open_old(inmap->answer, setname);
cell_type = Rast_get_map_type(fdi);
ibuffer = readcell(fdi, memory->answer);
Rast_close(fdi);
G__switch_env();
Rast_set_output_window(&outcellhd);
if (strcmp(interpol->answer, "nearest") == 0) {
fdo = Rast_open_new(mapname, cell_type);
obuffer = (CELL *) Rast_allocate_output_buf(cell_type);
}
else {
fdo = Rast_open_fp_new(mapname);
cell_type = FCELL_TYPE;
obuffer = (FCELL *) Rast_allocate_output_buf(cell_type);
}
cell_size = Rast_cell_size(cell_type);
xcoord1 = xcoord2 = outcellhd.west + (outcellhd.ew_res / 2);
/**/ ycoord1 = ycoord2 = outcellhd.north - (outcellhd.ns_res / 2);
/**/ G_important_message(_("Projecting..."));
G_percent(0, outcellhd.rows, 2);
for (row = 0; row < outcellhd.rows; row++) {
obufptr = obuffer;
for (col = 0; col < outcellhd.cols; col++) {
/* project coordinates in output matrix to */
/* coordinates in input matrix */
if (pj_do_proj(&xcoord1, &ycoord1, &oproj, &iproj) < 0)
Rast_set_null_value(obufptr, 1, cell_type);
else {
/* convert to row/column indices of input matrix */
col_idx = (xcoord1 - incellhd.west) / incellhd.ew_res;
row_idx = (incellhd.north - ycoord1) / incellhd.ns_res;
/* and resample data point */
interpolate(ibuffer, obufptr, cell_type,
&col_idx, &row_idx, &incellhd);
}
obufptr = G_incr_void_ptr(obufptr, cell_size);
xcoord2 += outcellhd.ew_res;
xcoord1 = xcoord2;
ycoord1 = ycoord2;
}
Rast_put_row(fdo, obuffer, cell_type);
xcoord1 = xcoord2 = outcellhd.west + (outcellhd.ew_res / 2);
ycoord2 -= outcellhd.ns_res;
ycoord1 = ycoord2;
G_percent(row, outcellhd.rows - 1, 2);
}
Rast_close(fdo);
if (have_colors > 0) {
Rast_write_colors(mapname, G_mapset(), &colr);
Rast_free_colors(&colr);
}
Rast_short_history(mapname, "raster", &history);
Rast_command_history(&history);
Rast_write_history(mapname, &history);
G_done_msg(NULL);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct Map_info In, Out;
static struct line_pnts *Points;
struct line_cats *Cats;
struct GModule *module; /* GRASS module for parsing arguments */
struct Option *map_in, *map_out;
struct Option *cat_opt, *field_opt, *where_opt, *abcol, *afcol;
struct Option *iter_opt, *error_opt;
struct Flag *geo_f, *add_f;
int chcat, with_z;
int layer, mask_type;
struct varray *varray;
dglGraph_s *graph;
int i, geo, nnodes, nlines, j, max_cat;
char buf[2000], *covered;
/* initialize GIS environment */
G_gisinit(argv[0]); /* reads grass env, stores program name to G_program_name() */
/* initialize module */
module = G_define_module();
module->keywords = _("vector, network, centrality measures");
module->description =
_("Computes degree, centrality, betweeness, closeness and eigenvector "
"centrality measures in the network.");
/* Define the different options as defined in gis.h */
map_in = G_define_standard_option(G_OPT_V_INPUT);
field_opt = G_define_standard_option(G_OPT_V_FIELD);
map_out = G_define_standard_option(G_OPT_V_OUTPUT);
cat_opt = G_define_standard_option(G_OPT_V_CATS);
cat_opt->guisection = _("Selection");
where_opt = G_define_standard_option(G_OPT_WHERE);
where_opt->guisection = _("Selection");
afcol = G_define_standard_option(G_OPT_COLUMN);
afcol->key = "afcolumn";
afcol->required = NO;
afcol->description =
_("Name of arc forward/both direction(s) cost column");
afcol->guisection = _("Cost");
abcol = G_define_standard_option(G_OPT_COLUMN);
abcol->key = "abcolumn";
abcol->required = NO;
abcol->description = _("Name of arc backward direction cost column");
abcol->guisection = _("Cost");
deg_opt = G_define_standard_option(G_OPT_COLUMN);
deg_opt->key = "degree";
deg_opt->required = NO;
deg_opt->description = _("Name of degree centrality column");
deg_opt->guisection = _("Columns");
close_opt = G_define_standard_option(G_OPT_COLUMN);
close_opt->key = "closeness";
close_opt->required = NO;
close_opt->description = _("Name of closeness centrality column");
close_opt->guisection = _("Columns");
betw_opt = G_define_standard_option(G_OPT_COLUMN);
betw_opt->key = "betweenness";
betw_opt->required = NO;
betw_opt->description = _("Name of betweenness centrality column");
betw_opt->guisection = _("Columns");
eigen_opt = G_define_standard_option(G_OPT_COLUMN);
eigen_opt->key = "eigenvector";
eigen_opt->required = NO;
eigen_opt->description = _("Name of eigenvector centrality column");
eigen_opt->guisection = _("Columns");
iter_opt = G_define_option();
iter_opt->key = "iterations";
iter_opt->answer = "1000";
iter_opt->type = TYPE_INTEGER;
iter_opt->required = NO;
iter_opt->description =
_("Maximum number of iterations to compute eigenvector centrality");
error_opt = G_define_option();
error_opt->key = "error";
error_opt->answer = "0.1";
error_opt->type = TYPE_DOUBLE;
error_opt->required = NO;
error_opt->description =
_("Cummulative error tolerance for eigenvector centrality");
geo_f = G_define_flag();
geo_f->key = 'g';
geo_f->description =
_("Use geodesic calculation for longitude-latitude locations");
add_f = G_define_flag();
add_f->key = 'a';
add_f->description = _("Add points on nodes");
/* options and flags parser */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* TODO: make an option for this */
mask_type = GV_LINE | GV_BOUNDARY;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_check_input_output_name(map_in->answer, map_out->answer,
GV_FATAL_EXIT);
Vect_set_open_level(2);
if (1 > Vect_open_old(&In, map_in->answer, ""))
G_fatal_error(_("Unable to open vector map <%s>"), map_in->answer);
with_z = Vect_is_3d(&In);
if (0 > Vect_open_new(&Out, map_out->answer, with_z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create vector map <%s>"), map_out->answer);
}
if (geo_f->answer) {
geo = 1;
if (G_projection() != PROJECTION_LL)
G_warning(_("The current projection is not longitude-latitude"));
}
else
geo = 0;
/* parse filter option and select appropriate lines */
layer = atoi(field_opt->answer);
chcat =
(NetA_initialise_varray
(&In, layer, mask_type, where_opt->answer, cat_opt->answer,
&varray) == 1);
/* Create table */
Fi = Vect_default_field_info(&Out, 1, NULL, GV_1TABLE);
Vect_map_add_dblink(&Out, 1, NULL, Fi->table, "cat", Fi->database,
Fi->driver);
db_init_string(&sql);
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);
db_init_string(&tmp);
if (deg_opt->answer)
append_string(&tmp, deg_opt->answer);
if (close_opt->answer)
append_string(&tmp, close_opt->answer);
if (betw_opt->answer)
append_string(&tmp, betw_opt->answer);
if (eigen_opt->answer)
append_string(&tmp, eigen_opt->answer);
sprintf(buf,
"create table %s(cat integer%s)", Fi->table, db_get_string(&tmp));
db_set_string(&sql, buf);
G_debug(2, db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
db_close_database_shutdown_driver(driver);
G_fatal_error(_("Unable to create table: '%s'"), db_get_string(&sql));
}
if (db_create_index2(driver, Fi->table, "cat") != DB_OK)
G_warning(_("Cannot create index"));
if (db_grant_on_table
(driver, Fi->table, DB_PRIV_SELECT, DB_GROUP | DB_PUBLIC) != DB_OK)
G_fatal_error(_("Cannot grant privileges on table <%s>"), Fi->table);
db_begin_transaction(driver);
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
Vect_net_build_graph(&In, mask_type, atoi(field_opt->answer), 0,
afcol->answer, abcol->answer, NULL, geo, 0);
graph = &(In.graph);
nnodes = dglGet_NodeCount(graph);
deg = closeness = betw = eigen = NULL;
covered = (char *)G_calloc(nnodes + 1, sizeof(char));
if (!covered)
G_fatal_error(_("Out of memory"));
if (deg_opt->answer) {
deg = (double *)G_calloc(nnodes + 1, sizeof(double));
if (!deg)
G_fatal_error(_("Out of memory"));
}
if (close_opt->answer) {
closeness = (double *)G_calloc(nnodes + 1, sizeof(double));
if (!closeness)
G_fatal_error(_("Out of memory"));
}
if (betw_opt->answer) {
betw = (double *)G_calloc(nnodes + 1, sizeof(double));
if (!betw)
G_fatal_error(_("Out of memory"));
}
if (eigen_opt->answer) {
eigen = (double *)G_calloc(nnodes + 1, sizeof(double));
if (!eigen)
G_fatal_error(_("Out of memory"));
}
if (deg_opt->answer) {
G_message(_("Computing degree centrality measure"));
NetA_degree_centrality(graph, deg);
}
if (betw_opt->answer || close_opt->answer) {
G_message(_("Computing betweenness and/or closeness centrality measure"));
NetA_betweenness_closeness(graph, betw, closeness);
if (closeness)
for (i = 1; i <= nnodes; i++)
closeness[i] /= (double)In.cost_multip;
}
if (eigen_opt->answer) {
G_message(_("Computing eigenvector centrality measure"));
NetA_eigenvector_centrality(graph, atoi(iter_opt->answer),
atof(error_opt->answer), eigen);
}
nlines = Vect_get_num_lines(&In);
G_message(_("Writing data into the table..."));
G_percent_reset();
for (i = 1; i <= nlines; i++) {
G_percent(i, nlines, 1);
int type = Vect_read_line(&In, Points, Cats, i);
if (type == GV_POINT && (!chcat || varray->c[i])) {
int cat, node;
if (!Vect_cat_get(Cats, layer, &cat))
continue;
Vect_reset_cats(Cats);
Vect_cat_set(Cats, 1, cat);
Vect_write_line(&Out, type, Points, Cats);
Vect_get_line_nodes(&In, i, &node, NULL);
process_node(node, cat);
covered[node] = 1;
}
}
if (add_f->answer && !chcat) {
max_cat = 0;
for (i = 1; i <= nlines; i++) {
Vect_read_line(&In, NULL, Cats, i);
for (j = 0; j < Cats->n_cats; j++)
if (Cats->cat[j] > max_cat)
max_cat = Cats->cat[j];
}
max_cat++;
for (i = 1; i <= nnodes; i++)
if (!covered[i]) {
Vect_reset_cats(Cats);
Vect_cat_set(Cats, 1, max_cat);
NetA_add_point_on_node(&In, &Out, i, Cats);
process_node(i, max_cat);
max_cat++;
}
}
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
G_free(covered);
if (deg)
G_free(deg);
if (closeness)
G_free(closeness);
if (betw)
G_free(betw);
if (eigen)
G_free(eigen);
Vect_build(&Out);
Vect_close(&In);
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
int main( int argc, char **argv )
{
struct GModule *module;
struct Option *info_opt, *rast_opt, *vect_opt, *coor_opt;
struct Cell_head window;
/* Initialize the GIS calls */
G_gisinit( argv[0] );
module = G_define_module();
module->description = ( "Get info about locations,mapsets,maps" );
info_opt = G_define_option();
info_opt->key = "info";
info_opt->type = TYPE_STRING;
info_opt->description = "info key";
info_opt->options = "proj,window,query";
rast_opt = G_define_standard_option( G_OPT_R_INPUT );
rast_opt->key = "rast";
rast_opt->required = NO;
vect_opt = G_define_standard_option( G_OPT_V_INPUT );
vect_opt->key = "vect";
vect_opt->required = NO;
coor_opt = G_define_option();
coor_opt->key = "coor";
coor_opt->type = TYPE_DOUBLE;
coor_opt->multiple = YES;
if ( G_parser( argc, argv ) )
exit( EXIT_FAILURE );
if ( strcmp( "proj", info_opt->answer ) == 0 )
{
G_get_window( &window );
/* code from g.proj */
if ( window.proj != PROJECTION_XY )
{
struct Key_Value *projinfo, *projunits;
char *wkt;
projinfo = G_get_projinfo();
projunits = G_get_projunits();
wkt = GPJ_grass_to_wkt( projinfo, projunits, 0, 0 );
fprintf( stdout, "%s", wkt );
}
}
else if ( strcmp( "window", info_opt->answer ) == 0 )
{
if ( rast_opt->answer )
{
G_get_cellhd( rast_opt->answer, "", &window );
fprintf( stdout, "%f,%f,%f,%f", window.west, window.south, window.east, window.north );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
else if ( strcmp( "query", info_opt->answer ) == 0 )
{
double x, y;
int row, col;
x = atof( coor_opt->answers[0] );
y = atof( coor_opt->answers[1] );
if ( rast_opt->answer )
{
int fd;
RASTER_MAP_TYPE rast_type;
DCELL *dcell;
CELL *cell;
G_get_cellhd( rast_opt->answer, "", &window );
G_set_window( &window );
fd = G_open_cell_old( rast_opt->answer, "" );
col = ( int ) G_easting_to_col( x, &window );
row = ( int ) G_northing_to_row( y, &window );
if ( col == window.cols ) col--;
if ( row == window.rows ) row--;
if ( col < 0 || col > window.cols || row < 0 || row > window.rows )
{
fprintf( stdout, "value:null\n" );
}
else
{
void *ptr;
double val;
#if defined(GRASS_VERSION_MAJOR) && defined(GRASS_VERSION_MINOR) && \
( ( GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR > 2 ) || GRASS_VERSION_MAJOR > 6 )
rast_type = G_get_raster_map_type( fd );
#else
rast_type = G_raster_map_type( rast_opt->answer, "" );
#endif
cell = G_allocate_c_raster_buf();
dcell = G_allocate_d_raster_buf();
if ( rast_type == CELL_TYPE )
{
if ( G_get_c_raster_row( fd, cell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
val = cell[col];
ptr = &( cell[col] );
}
else
{
if ( G_get_d_raster_row( fd, dcell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
val = dcell[col];
ptr = &( dcell[col] );
}
if ( G_is_null_value( ptr, rast_type ) )
{
fprintf( stdout, "value:null\n" );
}
else
{
fprintf( stdout, "value:%f\n", val );
}
}
G_close_cell( fd );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
exit( EXIT_SUCCESS );
}
int main(int argc, char *argv[])
{
int i, j, nlines, type, field, cat;
int fd;
/* struct Categories RCats; *//* TODO */
struct Cell_head window;
RASTER_MAP_TYPE out_type;
CELL *cell;
DCELL *dcell;
double drow, dcol;
char buf[2000];
struct Option *vect_opt, *rast_opt, *field_opt, *col_opt, *where_opt;
int Cache_size;
struct order *cache;
int cur_row;
struct GModule *module;
struct Map_info Map;
struct line_pnts *Points;
struct line_cats *Cats;
int point;
int point_cnt; /* number of points in cache */
int outside_cnt; /* points outside region */
int nocat_cnt; /* points inside region but without category */
int dupl_cnt; /* duplicate categories */
struct bound_box box;
int *catexst, *cex;
struct field_info *Fi;
dbString stmt;
dbDriver *driver;
int select, norec_cnt, update_cnt, upderr_cnt, col_type;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("raster"));
G_add_keyword(_("position"));
G_add_keyword(_("querying"));
G_add_keyword(_("attribute table"));
module->description =
_("Uploads raster values at positions of vector points to the table.");
vect_opt = G_define_standard_option(G_OPT_V_INPUT);
vect_opt->key = "vector";
vect_opt->description =
_("Name of input vector points map for which to edit attribute table");
rast_opt = G_define_standard_option(G_OPT_R_INPUT);
rast_opt->key = "raster";
rast_opt->description = _("Name of existing raster map to be queried");
field_opt = G_define_standard_option(G_OPT_V_FIELD);
col_opt = G_define_option();
col_opt->key = "column";
col_opt->type = TYPE_STRING;
col_opt->required = YES;
col_opt->description =
_("Column name (will be updated by raster values)");
where_opt = G_define_standard_option(G_OPT_DB_WHERE);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
field = atoi(field_opt->answer);
db_init_string(&stmt);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
G_get_window(&window);
Vect_region_box(&window, &box); /* T and B set to +/- PORT_DOUBLE_MAX */
/* Open vector */
Vect_set_open_level(2);
Vect_open_old(&Map, vect_opt->answer, "");
Fi = Vect_get_field(&Map, field);
if (Fi == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
field);
/* Open driver */
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);
}
/* Open raster */
fd = Rast_open_old(rast_opt->answer, "");
out_type = Rast_get_map_type(fd);
/* TODO: Later possibly category labels */
/*
if ( Rast_read_cats (name, "", &RCats) < 0 )
G_fatal_error ( "Cannot read category file");
*/
/* Check column type */
col_type = db_column_Ctype(driver, Fi->table, col_opt->answer);
if (col_type == -1)
G_fatal_error(_("Column <%s> not found"), col_opt->answer);
if (col_type != DB_C_TYPE_INT && col_type != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Column type not supported"));
if (out_type == CELL_TYPE && col_type == DB_C_TYPE_DOUBLE)
G_warning(_("Raster type is integer and column type is float"));
if (out_type != CELL_TYPE && col_type == DB_C_TYPE_INT)
G_warning(_("Raster type is float and column type is integer, some data lost!!"));
/* Read vector points to cache */
Cache_size = Vect_get_num_primitives(&Map, GV_POINT);
/* Note: Some space may be wasted (outside region or no category) */
cache = (struct order *)G_calloc(Cache_size, sizeof(struct order));
point_cnt = outside_cnt = nocat_cnt = 0;
nlines = Vect_get_num_lines(&Map);
G_debug(1, "Reading %d vector features fom map", nlines);
for (i = 1; i <= nlines; i++) {
type = Vect_read_line(&Map, Points, Cats, i);
G_debug(4, "line = %d type = %d", i, type);
/* check type */
if (!(type & GV_POINT))
continue; /* Points only */
/* check region */
if (!Vect_point_in_box(Points->x[0], Points->y[0], 0.0, &box)) {
outside_cnt++;
continue;
}
Vect_cat_get(Cats, field, &cat);
if (cat < 0) { /* no category of given field */
nocat_cnt++;
continue;
}
G_debug(4, " cat = %d", cat);
/* Add point to cache */
drow = Rast_northing_to_row(Points->y[0], &window);
dcol = Rast_easting_to_col(Points->x[0], &window);
/* a special case.
* if north falls at southern edge, or east falls on eastern edge,
* the point will appear outside the window.
* So, for these edges, bring the point inside the window
*/
if (drow == window.rows)
drow--;
if (dcol == window.cols)
dcol--;
cache[point_cnt].row = (int)drow;
cache[point_cnt].col = (int)dcol;
cache[point_cnt].cat = cat;
cache[point_cnt].count = 1;
point_cnt++;
}
Vect_set_db_updated(&Map);
Vect_hist_command(&Map);
Vect_close(&Map);
G_debug(1, "Read %d vector points", point_cnt);
/* Cache may contain duplicate categories, sort by cat, find and remove duplicates
* and recalc count and decrease point_cnt */
qsort(cache, point_cnt, sizeof(struct order), by_cat);
G_debug(1, "Points are sorted, starting duplicate removal loop");
for (i = 0, j = 1; j < point_cnt; j++)
if (cache[i].cat != cache[j].cat)
cache[++i] = cache[j];
else
cache[i].count++;
point_cnt = i + 1;
G_debug(1, "%d vector points left after removal of duplicates",
point_cnt);
/* Report number of points not used */
if (outside_cnt)
G_warning(_("%d points outside current region were skipped"),
outside_cnt);
if (nocat_cnt)
G_warning(_("%d points without category were skipped"), nocat_cnt);
/* Sort cache by current region row */
qsort(cache, point_cnt, sizeof(struct order), by_row);
/* Allocate space for raster row */
if (out_type == CELL_TYPE)
cell = Rast_allocate_c_buf();
else
dcell = Rast_allocate_d_buf();
/* Extract raster values from file and store in cache */
G_debug(1, "Extracting raster values");
cur_row = -1;
for (point = 0; point < point_cnt; point++) {
if (cache[point].count > 1)
continue; /* duplicate cats */
if (cur_row != cache[point].row) {
if (out_type == CELL_TYPE)
Rast_get_c_row(fd, cell, cache[point].row);
else
Rast_get_d_row(fd, dcell, cache[point].row);
}
cur_row = cache[point].row;
if (out_type == CELL_TYPE) {
cache[point].value = cell[cache[point].col];
}
else {
cache[point].dvalue = dcell[cache[point].col];
}
} /* point loop */
/* Update table from cache */
G_debug(1, "Updating db table");
/* select existing categories to array (array is sorted) */
select = db_select_int(driver, Fi->table, Fi->key, NULL, &catexst);
db_begin_transaction(driver);
norec_cnt = update_cnt = upderr_cnt = dupl_cnt = 0;
for (point = 0; point < point_cnt; point++) {
if (cache[point].count > 1) {
G_warning(_("More points (%d) of category %d, value set to 'NULL'"),
cache[point].count, cache[point].cat);
dupl_cnt++;
}
/* category exist in DB ? */
cex =
(int *)bsearch((void *)&(cache[point].cat), catexst, select,
sizeof(int), srch_cat);
if (cex == NULL) { /* cat does not exist in DB */
norec_cnt++;
G_warning(_("No record for category %d in table <%s>"),
cache[point].cat, Fi->table);
continue;
}
sprintf(buf, "update %s set %s = ", Fi->table, col_opt->answer);
db_set_string(&stmt, buf);
if (out_type == CELL_TYPE) {
if (cache[point].count > 1 ||
Rast_is_c_null_value(&cache[point].value)) {
sprintf(buf, "NULL");
}
else {
sprintf(buf, "%d ", cache[point].value);
}
}
else { /* FCELL or DCELL */
if (cache[point].count > 1 ||
Rast_is_d_null_value(&cache[point].dvalue)) {
sprintf(buf, "NULL");
}
else {
sprintf(buf, "%.10f", cache[point].dvalue);
}
}
db_append_string(&stmt, buf);
sprintf(buf, " where %s = %d", Fi->key, cache[point].cat);
db_append_string(&stmt, buf);
/* user provides where condition: */
if (where_opt->answer) {
sprintf(buf, " AND %s", where_opt->answer);
db_append_string(&stmt, buf);
}
G_debug(3, db_get_string(&stmt));
/* Update table */
if (db_execute_immediate(driver, &stmt) == DB_OK) {
update_cnt++;
}
else {
upderr_cnt++;
}
}
G_debug(1, "Committing DB transaction");
db_commit_transaction(driver);
G_free(catexst);
db_close_database_shutdown_driver(driver);
db_free_string(&stmt);
/* Report */
G_message(_("%d categories loaded from table"), select);
G_message(_("%d categories loaded from vector"), point_cnt);
G_message(_("%d categories from vector missing in table"), norec_cnt);
G_message(_("%d duplicate categories in vector"), dupl_cnt);
if (!where_opt->answer)
G_message(_("%d records updated"), update_cnt);
G_message(_("%d update errors"), upderr_cnt);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int i, row, col; /* counters */
unsigned long filesize;
int endianness; /* 0=little, 1=big */
int data_format; /* 0=double 1=float 2=32bit signed int 5=8bit unsigned int (ie text) */
int data_type; /* 0=numbers 1=text */
int format_block; /* combo of endianness, 0, data_format, and type */
int realflag = 0; /* 0=only real values used */
/* should type be specifically uint32 ??? */
char array_name[32]; /* variable names must start with a letter (case
sensitive) followed by letters, numbers, or
underscores. 31 chars max. */
int name_len;
int mrows, ncols; /* text/data/map array dimensions */
int val_i; /* for misc use */
float val_f; /* for misc use */
double val_d; /* for misc use */
char *infile, *outfile, *maptitle, *basename;
struct Cell_head region;
void *raster, *ptr;
RASTER_MAP_TYPE map_type;
struct Option *inputfile, *outputfile;
struct GModule *module;
int fd;
FILE *fp1;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("export"));
module->description = _("Exports a GRASS raster to a binary MAT-File.");
/* Define the different options */
inputfile = G_define_standard_option(G_OPT_R_INPUT);
outputfile = G_define_option();
outputfile->key = "output";
outputfile->type = TYPE_STRING;
outputfile->required = YES;
outputfile->gisprompt = "new_file,file,output";
outputfile->description = _("Name for the output binary MAT-File");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
infile = inputfile->answer;
basename = G_store(outputfile->answer);
G_basename(basename, "mat");
outfile = G_malloc(strlen(basename) + 5);
sprintf(outfile, "%s.mat", basename);
fd = Rast_open_old(infile, "");
map_type = Rast_get_map_type(fd);
/* open bin file for writing */
fp1 = fopen(outfile, "wb");
if (NULL == fp1)
G_fatal_error(_("Unable to open output file <%s>"), outfile);
/* Check Endian State of Host Computer */
if (G_is_little_endian())
endianness = 0; /* ie little endian */
else
endianness = 1; /* ie big endian */
G_debug(1, "Machine is %s endian.\n", endianness ? "big" : "little");
G_get_window(®ion);
/********** Write map **********/
/** write text element (map name) **/
strncpy(array_name, "map_name", 31);
mrows = 1;
ncols = strlen(infile);
data_format = 5; /* 0=double 1=float 2=32bit signed int 5=8bit unsigned int(text) */
data_type = 1; /* 0=numbers 1=text */
G_verbose_message(_("Exporting <%s>"), infile);
/* 4 byte data format */
format_block = endianness * 1000 + data_format * 10 + data_type;
fwrite(&format_block, sizeof(int), 1, fp1);
/* fprintf(stderr, "name data format is [%04ld]\n", format_block); */
/* 4 byte number of rows & columns */
fwrite(&mrows, sizeof(int), 1, fp1);
fwrite(&ncols, sizeof(int), 1, fp1);
/* 4 byte real/imag flag 0=real vals only */
fwrite(&realflag, sizeof(int), 1, fp1);
/* length of array_name+1 */
name_len = strlen(array_name) + 1;
fwrite(&name_len, sizeof(int), 1, fp1);
/* array name */
fprintf(fp1, "%s%c", array_name, '\0');
/* array data */
fprintf(fp1, "%s", infile);
/********** Write title (if there is one) **********/
maptitle = Rast_get_cell_title(infile, "");
if (strlen(maptitle) >= 1) {
/** write text element (map title) **/
strncpy(array_name, "map_title", 31);
mrows = 1;
ncols = strlen(maptitle);
data_format = 5; /* 0=double 1=float 2=32bit signed int 5=8bit unsigned int(text) */
data_type = 1; /* 0=numbers 1=text */
/* 4 byte data format */
format_block = endianness * 1000 + data_format * 10 + data_type;
fwrite(&format_block, sizeof(int), 1, fp1);
/* 4 byte number of rows & columns */
fwrite(&mrows, sizeof(int), 1, fp1);
fwrite(&ncols, sizeof(int), 1, fp1);
/* 4 byte real/imag flag 0=real vals only */
fwrite(&realflag, sizeof(int), 1, fp1);
/* length of array_name+1 */
name_len = strlen(array_name) + 1;
fwrite(&name_len, sizeof(int), 1, fp1);
/* array name */
fprintf(fp1, "%s%c", array_name, '\0');
/* array data */
fprintf(fp1, "%s", maptitle);
}
/***** Write bounds *****/
G_verbose_message("");
G_verbose_message(_("Using the Current Region settings:"));
G_verbose_message(_("northern edge=%f"), region.north);
G_verbose_message(_("southern edge=%f"), region.south);
G_verbose_message(_("eastern edge=%f"), region.east);
G_verbose_message(_("western edge=%f"), region.west);
G_verbose_message(_("nsres=%f"), region.ns_res);
G_verbose_message(_("ewres=%f"), region.ew_res);
G_verbose_message(_("rows=%d"), region.rows);
G_verbose_message(_("cols=%d"), region.cols);
G_verbose_message("");
for (i = 0; i < 4; i++) {
switch (i) {
case 0:
strncpy(array_name, "map_northern_edge", 31);
val_d = region.north;
break;
case 1:
strncpy(array_name, "map_southern_edge", 31);
val_d = region.south;
break;
case 2:
strncpy(array_name, "map_eastern_edge", 31);
val_d = region.east;
break;
case 3:
strncpy(array_name, "map_western_edge", 31);
val_d = region.west;
break;
default:
fclose(fp1);
G_fatal_error("please contact development team");
break;
}
/** write data element **/
data_format = 0; /* 0=double 1=float 2=32bit signed int 5=8bit unsigned int(text) */
data_type = 0; /* 0=numbers 1=text */
mrows = 1;
ncols = 1;
/* 4 byte data format */
format_block = endianness * 1000 + data_format * 10 + data_type;
fwrite(&format_block, sizeof(int), 1, fp1);
/* fprintf(stderr, "bounds data format is [%04ld]\n", format_block); */
/* 4 byte number of rows , 4 byte number of colums */
fwrite(&mrows, sizeof(int), 1, fp1);
fwrite(&ncols, sizeof(int), 1, fp1);
/* 4 byte real/imag flag 0=only real */
fwrite(&realflag, sizeof(int), 1, fp1);
/* length of array_name+1 */
name_len = strlen(array_name) + 1;
fwrite(&name_len, sizeof(int), 1, fp1);
/* array name */
fprintf(fp1, "%s%c", array_name, '\0');
/* write array data, by increasing column */
fwrite(&val_d, sizeof(double), 1, fp1);
/** end of data element **/
}
/***** Write map data *****/
strncpy(array_name, "map_data", 31);
switch (map_type) { /* data_format: 0=double 1=float 2=32bit signed int 5=8bit unsigned int (ie text) */
case CELL_TYPE:
data_format = 2;
G_verbose_message(_("Exporting raster as integer values"));
break;
case FCELL_TYPE:
data_format = 1;
G_verbose_message(_("Exporting raster as floating point values"));
break;
case DCELL_TYPE:
data_format = 0;
G_verbose_message(_("Exporting raster as double FP values"));
break;
default:
fclose(fp1);
G_fatal_error("Please contact development team");
break;
}
data_type = 0; /* 0=numbers 1=text */
mrows = region.rows;
ncols = region.cols;
/* 4 byte data format */
format_block = (endianness * 1000) + (data_format * 10) + data_type;
fwrite(&format_block, sizeof(int), 1, fp1);
G_debug(3, "map data format is [%04d]\n", format_block);
/* 4 byte number of rows & columns */
fwrite(&mrows, sizeof(int), 1, fp1);
fwrite(&ncols, sizeof(int), 1, fp1);
/* 4 byte real/imag flag 0=only real */
fwrite(&realflag, sizeof(int), 1, fp1);
/* length of array_name+1 */
name_len = strlen(array_name) + 1;
fwrite(&name_len, sizeof(int), 1, fp1);
/* array name */
fprintf(fp1, "%s%c", array_name, '\0');
/* data array, by increasing column */
raster =
G_calloc((Rast_window_rows() + 1) * (Rast_window_cols() + 1),
Rast_cell_size(map_type));
G_debug(1, "mem alloc is %d bytes\n", /* I think _cols()+1 is unneeded? */
Rast_cell_size(map_type) * (Rast_window_rows() +
1) * (Rast_window_cols() + 1));
G_verbose_message(_("Reading in map ... "));
/* load entire map into memory */
for (row = 0, ptr = raster; row < mrows; row++,
ptr =
G_incr_void_ptr(ptr,
(Rast_window_cols() + 1) * Rast_cell_size(map_type))) {
Rast_get_row(fd, ptr, row, map_type);
G_percent(row, mrows, 2);
}
G_percent(row, mrows, 2); /* finish it off */
G_verbose_message(_("Writing out map..."));
/* then write it to disk */
/* NoGood: fwrite(raster, Rast_cell_size(map_type), mrows*ncols, fp1); */
for (col = 0; col < ncols; col++) {
for (row = 0; row < mrows; row++) {
ptr = raster;
ptr =
G_incr_void_ptr(ptr,
(col +
row * (ncols +
1)) * Rast_cell_size(map_type));
if (!Rast_is_null_value(ptr, map_type)) {
if (map_type == CELL_TYPE) {
val_i = *((CELL *) ptr);
fwrite(&val_i, sizeof(int), 1, fp1);
}
else if (map_type == FCELL_TYPE) {
val_f = *((FCELL *) ptr);
fwrite(&val_f, sizeof(float), 1, fp1);
}
else if (map_type == DCELL_TYPE) {
val_d = *((DCELL *) ptr);
fwrite(&val_d, sizeof(double), 1, fp1);
}
}
else { /* ie if NULL cell -> write IEEE NaN value */
if (map_type == CELL_TYPE) {
val_i = *((CELL *) ptr); /* int has no NaN value, so use whatever GRASS uses */
fwrite(&val_i, sizeof(int), 1, fp1);
}
else if (map_type == FCELL_TYPE) {
if (endianness) /* ie big */
fprintf(fp1, "%c%c%c%c", 0xff, 0xf8, 0, 0);
else /* ie little */
fprintf(fp1, "%c%c%c%c", 0, 0, 0xf8, 0xff);
}
else if (map_type == DCELL_TYPE) {
if (endianness)
fprintf(fp1, "%c%c%c%c%c%c%c%c", 0xff, 0xf8, 0, 0, 0,
0, 0, 0);
else
fprintf(fp1, "%c%c%c%c%c%c%c%c", 0, 0, 0, 0, 0, 0,
0xf8, 0xff);
}
}
}
G_percent(col, ncols, 2);
}
G_percent(col, ncols, 2); /* finish it off */
/*** end of data element ***/
/* done! */
filesize = G_ftell(fp1);
fclose(fp1);
G_verbose_message(_("%ld bytes written to '%s'"), filesize, outfile);
G_done_msg("");
G_free(basename);
G_free(outfile);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct Option *input, *vect;
struct Cell_head window;
int bot, right, t0, b0, l0, r0, clear = 0;
double Rw_l, Rscr_wl;
char *map_name = NULL, *v_name = NULL, *s_name = NULL;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
/* must run in a term window */
G_putenv("GRASS_UI_TERM", "1");
module = G_define_module();
module->keywords = _("raster, landscape structure analysis, patch index");
module->description =
_("Interactive tool used to setup the sampling and analysis framework "
"that will be used by the other r.le programs.");
input = G_define_standard_option(G_OPT_R_MAP);
input->description = _("Raster map to use to setup sampling");
vect = G_define_standard_option(G_OPT_V_INPUT);
vect->key = "vect";
vect->description = _("Vector map to overlay");
vect->required = NO;
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
setbuf(stdout, NULL); /* unbuffered */
setbuf(stderr, NULL);
G_sleep_on_error(1); /* error messages get lost on clear screen */
map_name = input->answer;
v_name = vect->answer;
s_name = NULL; /* sites not used in GRASS 6 */
/* setup the r.le.para directory */
get_pwd();
/* query for the map to be setup */
if (R_open_driver() != 0)
G_fatal_error("No graphics device selected");
/* setup the current window for display & clear screen */
D_setup(1);
Rw_l = (double)G_window_cols() / G_window_rows();
/*R_open_driver(); */
/* R_font("romant"); */
G_get_set_window(&window);
t0 = R_screen_top();
b0 = R_screen_bot();
l0 = R_screen_left();
r0 = R_screen_rite();
Rscr_wl = (double)(r0 - l0) / (b0 - t0);
if (Rscr_wl > Rw_l) {
bot = b0;
right = l0 + (b0 - t0) * Rw_l;
}
else {
right = r0;
bot = t0 + (r0 - l0) / Rw_l;
}
D_new_window("a", t0, bot, l0, right);
D_set_cur_wind("a");
D_show_window(D_translate_color("green"));
D_setup(clear);
R_close_driver();
/* invoke the setup modules */
set_map(map_name, v_name, s_name, window, t0, bot, l0, right);
return (EXIT_SUCCESS);
}