int main(int argc, char *argv[])
{
int nlines;
double textsize;
char *dxf_file;
struct Map_info In;
struct GModule *module;
struct Option *input, *output, *field;
G_gisinit(argv[0]);
/* Set description */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("export"));
G_add_keyword(_("DXF"));
module->description =
_("Exports vector map to DXF file format.");
input = G_define_standard_option(G_OPT_V_INPUT);
field = G_define_standard_option(G_OPT_V_FIELD_ALL);
output = G_define_standard_option(G_OPT_F_OUTPUT);
output->required = YES;
output->description = _("Name for DXF output file");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
overwrite = module->overwrite;
/* open input vector */
dxf_file = G_store(output->answer);
Vect_set_open_level(2);
if (Vect_open_old2(&In, input->answer, "", field->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), input->answer);
dxf_open(dxf_file); /* open output */
textsize = do_limits(&In); /* does header in dxf_fp */
make_layername();
dxf_entities();
nlines = add_plines(&In, Vect_get_field_number(&In, field->answer),
textsize); /* puts plines in dxf_fp */
dxf_endsec();
dxf_eof(); /* puts final stuff in dxf_fp, closes file */
G_done_msg(_("%d features written to '%s'."), nlines, dxf_file);
G_free(dxf_file);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int i, j, k;
int print_as_matrix; /* only for all */
int all; /* calculate from each to each within the threshold */
struct GModule *module;
struct Option *from_opt, *to_opt, *from_type_opt, *to_type_opt,
*from_field_opt, *to_field_opt;
struct Option *out_opt, *max_opt, *min_opt, *table_opt;
struct Option *upload_opt, *column_opt, *to_column_opt;
struct Flag *print_flag, *all_flag;
struct Map_info From, To, Out, *Outp;
int from_type, to_type, from_field, to_field;
double max, min;
double *max_step;
int n_max_steps, curr_step;
struct line_pnts *FPoints, *TPoints;
struct line_cats *FCats, *TCats;
NEAR *Near, *near;
int anear; /* allocated space, used only for all */
UPLOAD *Upload; /* zero terminated */
int ftype, fcat, tcat, count;
int nfrom, nto, nfcats, fline, tline, tseg, tarea, area, isle, nisles;
double tx, ty, tz, dist, talong, tmp_tx, tmp_ty, tmp_tz, tmp_dist,
tmp_talong;
struct field_info *Fi, *toFi;
dbString stmt, dbstr;
dbDriver *driver, *to_driver;
int *catexist, ncatexist, *cex;
char buf1[2000], buf2[2000];
int update_ok, update_err, update_exist, update_notexist, update_dupl,
update_notfound;
struct boxlist *List;
struct bound_box box;
dbCatValArray cvarr;
dbColumn *column;
all = 0;
print_as_matrix = 0;
column = NULL;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("database"));
G_add_keyword(_("attribute table"));
module->description =
_("Finds the nearest element in vector map 'to' for elements in vector map 'from'.");
from_opt = G_define_standard_option(G_OPT_V_INPUT);
from_opt->key = "from";
from_opt->description = _("Name of existing vector map (from)");
from_opt->guisection = _("From");
from_field_opt = G_define_standard_option(G_OPT_V_FIELD);
from_field_opt->key = "from_layer";
from_field_opt->label = _("Layer number or name (from)");
from_field_opt->guisection = _("From");
from_type_opt = G_define_standard_option(G_OPT_V_TYPE);
from_type_opt->key = "from_type";
from_type_opt->options = "point,centroid";
from_type_opt->answer = "point";
from_type_opt->label = _("Feature type (from)");
from_type_opt->guisection = _("From");
to_opt = G_define_standard_option(G_OPT_V_INPUT);
to_opt->key = "to";
to_opt->description = _("Name of existing vector map (to)");
to_opt->guisection = _("To");
to_field_opt = G_define_standard_option(G_OPT_V_FIELD);
to_field_opt->key = "to_layer";
to_field_opt->label = _("Layer number or name (to)");
to_field_opt->guisection = _("To");
to_type_opt = G_define_standard_option(G_OPT_V_TYPE);
to_type_opt->key = "to_type";
to_type_opt->options = "point,line,boundary,centroid,area";
to_type_opt->answer = "point,line,area";
to_type_opt->label = _("Feature type (to)");
to_type_opt->guisection = _("To");
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
out_opt->key = "output";
out_opt->required = NO;
out_opt->description = _("Name for output vector map containing lines "
"connecting nearest elements");
max_opt = G_define_option();
max_opt->key = "dmax";
max_opt->type = TYPE_DOUBLE;
max_opt->required = NO;
max_opt->answer = "-1";
max_opt->description = _("Maximum distance or -1 for no limit");
min_opt = G_define_option();
min_opt->key = "dmin";
min_opt->type = TYPE_DOUBLE;
min_opt->required = NO;
min_opt->answer = "-1";
min_opt->description = _("Minimum distance or -1 for no limit");
upload_opt = G_define_option();
upload_opt->key = "upload";
upload_opt->type = TYPE_STRING;
upload_opt->required = YES;
upload_opt->multiple = YES;
upload_opt->options = "cat,dist,to_x,to_y,to_along,to_angle,to_attr";
upload_opt->description =
_("Values describing the relation between two nearest features");
upload_opt->descriptions =
_("cat;category of the nearest feature;"
"dist;minimum distance to nearest feature;"
"to_x;x coordinate of the nearest point on 'to' feature;"
"to_y;y coordinate of the nearest point on 'to' feature;"
"to_along;distance between points/centroids in 'from' map and the linear feature's "
"start point in 'to' map, along this linear feature;"
"to_angle;angle between the linear feature in 'to' map and the positive x axis, at "
"the location of point/centroid in 'from' map, counterclockwise, in radians, which "
"is between -PI and PI inclusive;"
"to_attr;attribute of nearest feature given by to_column option");
/* "from_x - x coordinate of the nearest point on 'from' feature;" */
/* "from_y - y coordinate of the nearest point on 'from' feature;" */
/* "from_along - distance to the nearest point on 'from' feature along linear feature;" */
column_opt = G_define_standard_option(G_OPT_DB_COLUMN);
column_opt->required = YES;
column_opt->multiple = YES;
column_opt->description =
_("Column name(s) where values specified by 'upload' option will be uploaded");
column_opt->guisection = _("From_map");
to_column_opt = G_define_standard_option(G_OPT_DB_COLUMN);
to_column_opt->key = "to_column";
to_column_opt->description =
_("Column name of nearest feature (used with upload=to_attr)");
to_column_opt->guisection = _("To");
table_opt = G_define_standard_option(G_OPT_DB_TABLE);
table_opt->gisprompt = "new_dbtable,dbtable,dbtable";
table_opt->description =
_("Name of table created for output when the distance to all flag is used");
print_flag = G_define_flag();
print_flag->key = 'p';
print_flag->label =
_("Print output to stdout, don't update attribute table");
print_flag->description =
_("First column is always category of 'from' feature called from_cat");
all_flag = G_define_flag();
all_flag->key = 'a';
all_flag->label =
_("Calculate distances to all features within the threshold");
all_flag->description = _("The output is written to stdout but may be uploaded "
"to a new table created by this module. "
"From categories are may be multiple."); /* huh? */
/* GUI dependency */
from_opt->guidependency = G_store(from_field_opt->key);
sprintf(buf1, "%s,%s", to_field_opt->key, to_column_opt->key);
to_opt->guidependency = G_store(buf1);
to_field_opt->guidependency = G_store(to_column_opt->key);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
from_type = Vect_option_to_types(from_type_opt);
to_type = Vect_option_to_types(to_type_opt);
from_field = atoi(from_field_opt->answer);
max = atof(max_opt->answer);
min = atof(min_opt->answer);
if (all_flag->answer)
all = 1;
/* Read upload and column options */
/* count */
i = 0;
while (upload_opt->answers[i])
i++;
if (strcmp(from_opt->answer, to_opt->answer) == 0 &&
all && !table_opt->answer && i == 1)
print_as_matrix = 1;
/* alloc */
Upload = (UPLOAD *) G_calloc(i + 1, sizeof(UPLOAD));
/* read upload */
i = 0;
while (upload_opt->answers[i]) {
if (strcmp(upload_opt->answers[i], "cat") == 0)
Upload[i].upload = CAT;
else if (strcmp(upload_opt->answers[i], "from_x") == 0)
Upload[i].upload = FROM_X;
else if (strcmp(upload_opt->answers[i], "from_y") == 0)
Upload[i].upload = FROM_Y;
else if (strcmp(upload_opt->answers[i], "to_x") == 0)
Upload[i].upload = TO_X;
else if (strcmp(upload_opt->answers[i], "to_y") == 0)
Upload[i].upload = TO_Y;
else if (strcmp(upload_opt->answers[i], "from_along") == 0)
Upload[i].upload = FROM_ALONG;
else if (strcmp(upload_opt->answers[i], "to_along") == 0)
Upload[i].upload = TO_ALONG;
else if (strcmp(upload_opt->answers[i], "dist") == 0)
Upload[i].upload = DIST;
else if (strcmp(upload_opt->answers[i], "to_angle") == 0)
Upload[i].upload = TO_ANGLE;
else if (strcmp(upload_opt->answers[i], "to_attr") == 0) {
if (!(to_column_opt->answer)) {
G_fatal_error(_("to_column option missing"));
}
Upload[i].upload = TO_ATTR;
}
i++;
}
Upload[i].upload = END;
/* read columns */
i = 0;
while (column_opt->answers[i]) {
if (Upload[i].upload == END) {
G_warning(_("Too many column names"));
break;
}
Upload[i].column = G_store(column_opt->answers[i]);
i++;
}
if (Upload[i].upload != END)
G_fatal_error(_("Not enough column names"));
/* Open 'from' vector */
Vect_set_open_level(2);
Vect_open_old(&From, from_opt->answer, G_mapset());
/* Open 'to' vector */
Vect_set_open_level(2);
Vect_open_old2(&To, to_opt->answer, "", to_field_opt->answer);
to_field = Vect_get_field_number(&To, to_field_opt->answer);
/* Open output vector */
if (out_opt->answer) {
Vect_open_new(&Out, out_opt->answer, WITHOUT_Z);
Vect_hist_command(&Out);
Outp = &Out;
}
else {
Outp = NULL;
}
/* TODO: add maxdist = -1 to Vect_select_ !!! */
/* Calc maxdist */
n_max_steps = 1;
if (max != 0) {
struct bound_box fbox, tbox;
double dx, dy, dz, tmp_max;
int n_features = 0;
Vect_get_map_box(&From, &fbox);
Vect_get_map_box(&To, &tbox);
Vect_box_extend(&fbox, &tbox);
dx = fbox.E - fbox.W;
dy = fbox.N - fbox.S;
if (Vect_is_3d(&From))
dz = fbox.T - fbox.B;
else
dz = 0.0;
tmp_max = sqrt(dx * dx + dy * dy + dz * dz);
if (max < 0)
max = tmp_max;
/* how to determine a reasonable number of steps to increase the search box? */
/* with max > 0 but max <<< tmp_max, 2 steps are sufficient, first 0 then max
* a reasonable number of steps also depends on the number of features in To
* e.g. only one area in To, no need to step */
nto = Vect_get_num_lines(&To);
for (tline = 1; tline <= nto; tline++) {
/* TODO: Vect_get_line_type() */
n_features += ((to_type & To.plus.Line[tline]->type) != 0);
}
if (to_type & GV_AREA) {
if (Vect_get_num_areas(&To) > n_features)
n_features = Vect_get_num_areas(&To);
}
if (n_features == 0)
G_fatal_error(_("No features of selected type in To vector <%s>"),
to_opt->answer);
n_max_steps = sqrt(n_features) * max / tmp_max;
/* max 9 steps from testing */
if (n_max_steps > 9)
n_max_steps = 9;
if (n_max_steps < 2)
n_max_steps = 2;
if (n_max_steps > n_features)
n_max_steps = n_features;
G_debug(2, "max = %f", max);
G_debug(2, "maximum reasonable search distance = %f", tmp_max);
G_debug(2, "n_features = %d", n_features);
G_debug(2, "n_max_steps = %d", n_max_steps);
}
if (min > max)
G_fatal_error("dmin can not be larger than dmax");
if (n_max_steps > 1) {
/* set up steps to increase search box */
max_step = G_malloc(n_max_steps * sizeof(double));
/* first step always 0 */
max_step[0] = 0;
for (curr_step = 1; curr_step < n_max_steps - 1; curr_step++) {
/* for 9 steps, this would be max / [128, 64, 32, 16, 8, 4, 2] */
max_step[curr_step] = max / (2 << (n_max_steps - 1 - curr_step));
}
/* last step always max */
max_step[n_max_steps - 1] = max;
}
else {
max_step = G_malloc(sizeof(double));
max_step[0] = max;
}
/* Open database driver */
db_init_string(&stmt);
db_init_string(&dbstr);
driver = NULL;
if (!print_flag->answer) {
if (!all) {
Fi = Vect_get_field(&From, from_field);
if (Fi == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
from_field);
driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (driver == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
/* check if column exists */
i = 0;
while (column_opt->answers[i]) {
db_get_column(driver, Fi->table, column_opt->answers[i],
&column);
if (column) {
db_free_column(column);
column = NULL;
}
else {
G_fatal_error(_("Column <%s> not found in table <%s>"),
column_opt->answers[i], Fi->table);
}
i++;
}
}
else {
driver = db_start_driver_open_database(NULL, NULL);
if (driver == NULL)
G_fatal_error(_("Unable to open default database"));
}
}
to_driver = NULL;
if (to_column_opt->answer) {
toFi = Vect_get_field(&To, to_field);
if (toFi == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
to_field);
to_driver =
db_start_driver_open_database(toFi->driver, toFi->database);
if (to_driver == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
toFi->database, toFi->driver);
/* check if to_column exists */
db_get_column(to_driver, toFi->table, to_column_opt->answer, &column);
if (column) {
db_free_column(column);
column = NULL;
}
else {
G_fatal_error(_("Column <%s> not found in table <%s>"),
to_column_opt->answer, toFi->table);
}
/* Check column types */
if (!print_flag->answer && !all) {
char *fcname = NULL;
int fctype, tctype;
i = 0;
while (column_opt->answers[i]) {
if (Upload[i].upload == TO_ATTR) {
fcname = column_opt->answers[i];
break;
}
i++;
}
if (fcname) {
fctype = db_column_Ctype(driver, Fi->table, fcname);
tctype =
db_column_Ctype(to_driver, toFi->table,
to_column_opt->answer);
if (((tctype == DB_C_TYPE_STRING ||
tctype == DB_C_TYPE_DATETIME)
&& (fctype == DB_C_TYPE_INT ||
fctype == DB_C_TYPE_DOUBLE)) ||
((tctype == DB_C_TYPE_INT || tctype == DB_C_TYPE_DOUBLE)
&& (fctype == DB_C_TYPE_STRING ||
fctype == DB_C_TYPE_DATETIME))
) {
G_fatal_error(_("Incompatible column types"));
}
}
}
}
FPoints = Vect_new_line_struct();
TPoints = Vect_new_line_struct();
FCats = Vect_new_cats_struct();
TCats = Vect_new_cats_struct();
List = Vect_new_boxlist(1);
/* Allocate space ( may be more than needed (duplicate cats and elements without cats) ) */
nfrom = Vect_get_num_lines(&From);
nto = Vect_get_num_lines(&To);
if (all) {
/* Attention with space for all, it can easily run out of memory */
anear = 2 * nfrom;
Near = (NEAR *) G_calloc(anear, sizeof(NEAR));
}
else {
Near = (NEAR *) G_calloc(nfrom, sizeof(NEAR));
}
/* Read all cats from 'from' */
if (!all) {
nfcats = 0;
for (i = 1; i <= nfrom; i++) {
ftype = Vect_read_line(&From, NULL, FCats, i);
/* This keeps also categories of areas for future (if area s in from_type) */
if (!(ftype & from_type) &&
(ftype != GV_CENTROID || !(from_type & GV_AREA)))
continue;
Vect_cat_get(FCats, from_field, &fcat);
if (fcat < 0)
continue;
Near[nfcats].from_cat = fcat;
nfcats++;
}
G_debug(1, "%d cats loaded from vector (including duplicates)",
nfcats);
/* Sort by cats and remove duplicates */
qsort((void *)Near, nfcats, sizeof(NEAR), cmp_near);
/* remove duplicates */
for (i = 1; i < nfcats; i++) {
if (Near[i].from_cat == Near[i - 1].from_cat) {
for (j = i; j < nfcats - 1; j++) {
Near[j].from_cat = Near[j + 1].from_cat;
}
nfcats--;
}
}
G_debug(1, "%d cats loaded from vector (unique)", nfcats);
}
/* Go through all lines in 'from' and find nearest in 'to' for each */
/* Note: as from_type is restricted to GV_POINTS (for now) everything is simple */
count = 0; /* count of distances in 'all' mode */
/* Find nearest lines */
if (to_type & (GV_POINTS | GV_LINES)) {
struct line_pnts *LLPoints;
if (G_projection() == PROJECTION_LL) {
LLPoints = Vect_new_line_struct();
}
else {
LLPoints = NULL;
}
G_message(_("Finding nearest feature..."));
for (fline = 1; fline <= nfrom; fline++) {
int tmp_tcat;
double tmp_tangle, tangle;
double tmp_min = (min < 0 ? 0 : min);
double box_edge = 0;
int done = 0;
curr_step = 0;
G_debug(3, "fline = %d", fline);
G_percent(fline, nfrom, 2);
ftype = Vect_read_line(&From, FPoints, FCats, fline);
if (!(ftype & from_type))
continue;
Vect_cat_get(FCats, from_field, &fcat);
if (fcat < 0 && !all)
continue;
while (!done) {
done = 1;
if (!all) {
/* enlarge search box until we get a hit */
/* the objective is to enlarge the search box
* in the first iterations just a little bit
* to keep the number of hits low */
Vect_reset_boxlist(List);
while (curr_step < n_max_steps) {
box_edge = max_step[curr_step];
if (box_edge < tmp_min)
continue;
box.E = FPoints->x[0] + box_edge;
box.W = FPoints->x[0] - box_edge;
box.N = FPoints->y[0] + box_edge;
box.S = FPoints->y[0] - box_edge;
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
Vect_select_lines_by_box(&To, &box, to_type, List);
curr_step++;
if (List->n_values > 0)
break;
}
}
else {
box.E = FPoints->x[0] + max;
box.W = FPoints->x[0] - max;
box.N = FPoints->y[0] + max;
box.S = FPoints->y[0] - max;
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
Vect_select_lines_by_box(&To, &box, to_type, List);
}
G_debug(3, " %d lines in box", List->n_values);
tline = 0;
dist = PORT_DOUBLE_MAX;
for (i = 0; i < List->n_values; i++) {
tmp_tcat = -1;
Vect_read_line(&To, TPoints, TCats, List->id[i]);
tseg =
Vect_line_distance(TPoints, FPoints->x[0], FPoints->y[0],
FPoints->z[0], (Vect_is_3d(&From) &&
Vect_is_3d(&To)) ?
WITH_Z : WITHOUT_Z, &tmp_tx, &tmp_ty,
&tmp_tz, &tmp_dist, NULL, &tmp_talong);
Vect_point_on_line(TPoints, tmp_talong, NULL, NULL, NULL,
&tmp_tangle, NULL);
if (tmp_dist > max || tmp_dist < min)
continue; /* not in threshold */
/* TODO: more cats of the same field */
Vect_cat_get(TCats, to_field, &tmp_tcat);
if (G_projection() == PROJECTION_LL) {
/* calculate distances in meters not degrees (only 2D) */
Vect_reset_line(LLPoints);
Vect_append_point(LLPoints, FPoints->x[0], FPoints->y[0],
FPoints->z[0]);
Vect_append_point(LLPoints, tmp_tx, tmp_ty, tmp_tz);
tmp_dist = Vect_line_geodesic_length(LLPoints);
Vect_reset_line(LLPoints);
for (k = 0; k < tseg; k++)
Vect_append_point(LLPoints, TPoints->x[k],
TPoints->y[k], TPoints->z[k]);
Vect_append_point(LLPoints, tmp_tx, tmp_ty, tmp_tz);
tmp_talong = Vect_line_geodesic_length(LLPoints);
}
G_debug(4, " tmp_dist = %f tmp_tcat = %d", tmp_dist,
tmp_tcat);
if (all) {
if (anear <= count) {
anear += 10 + nfrom / 10;
Near = (NEAR *) G_realloc(Near, anear * sizeof(NEAR));
}
near = &(Near[count]);
/* store info about relation */
near->from_cat = fcat;
near->to_cat = tmp_tcat; /* -1 is OK */
near->dist = tmp_dist;
near->from_x = FPoints->x[0];
near->from_y = FPoints->y[0];
near->from_z = FPoints->z[0];
near->to_x = tmp_tx;
near->to_y = tmp_ty;
near->to_z = tmp_tz;
near->to_along = tmp_talong; /* 0 for points */
near->to_angle = tmp_tangle;
near->count++;
count++;
}
else {
if (tline == 0 || (tmp_dist < dist)) {
tline = List->id[i];
tcat = tmp_tcat;
dist = tmp_dist;
tx = tmp_tx;
ty = tmp_ty;
tz = tmp_tz;
talong = tmp_talong;
tangle = tmp_tangle;
}
}
}
G_debug(4, " dist = %f", dist);
if (curr_step < n_max_steps) {
/* enlarging the search box is possible */
if (tline > 0 && dist > box_edge) {
/* line found but distance > search edge:
* line bbox overlaps with search box, line itself is outside search box */
done = 0;
}
else if (tline == 0) {
/* no line within max dist, but search box can still be enlarged */
done = 0;
}
}
if (done && !all && tline > 0) {
/* find near by cat */
near =
(NEAR *) bsearch((void *)&fcat, Near, nfcats,
sizeof(NEAR), cmp_near);
G_debug(4, " near.from_cat = %d near.count = %d",
near->from_cat, near->count);
/* store info about relation */
if (near->count == 0 || near->dist > dist) {
near->to_cat = tcat; /* -1 is OK */
near->dist = dist;
near->from_x = FPoints->x[0];
near->from_y = FPoints->y[0];
near->from_z = FPoints->z[0];
near->to_x = tx;
near->to_y = ty;
near->to_z = tz;
near->to_along = talong; /* 0 for points */
near->to_angle = tangle;
}
near->count++;
}
} /* done */
} /* next feature */
if (LLPoints) {
Vect_destroy_line_struct(LLPoints);
}
}
/* Find nearest areas */
if (to_type & GV_AREA) {
G_message(_("Finding nearest areas..."));
for (fline = 1; fline <= nfrom; fline++) {
double tmp_min = (min < 0 ? 0 : min);
double box_edge = 0;
int done = 0;
curr_step = 0;
G_debug(3, "fline = %d", fline);
G_percent(fline, nfrom, 2);
ftype = Vect_read_line(&From, FPoints, FCats, fline);
if (!(ftype & from_type))
continue;
Vect_cat_get(FCats, from_field, &fcat);
if (fcat < 0 && !all)
continue;
while (!done) {
done = 1;
if (!all) {
/* enlarge search box until we get a hit */
/* the objective is to enlarge the search box
* in the first iterations just a little bit
* to keep the number of hits low */
Vect_reset_boxlist(List);
while (curr_step < n_max_steps) {
box_edge = max_step[curr_step];
if (box_edge < tmp_min)
continue;
box.E = FPoints->x[0] + box_edge;
box.W = FPoints->x[0] - box_edge;
box.N = FPoints->y[0] + box_edge;
box.S = FPoints->y[0] - box_edge;
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
Vect_select_areas_by_box(&To, &box, List);
curr_step++;
if (List->n_values > 0)
break;
}
}
else {
box.E = FPoints->x[0] + max;
box.W = FPoints->x[0] - max;
box.N = FPoints->y[0] + max;
box.S = FPoints->y[0] - max;
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
Vect_select_areas_by_box(&To, &box, List);
}
G_debug(4, "%d areas selected by box", List->n_values);
/* For each area in box check the distance */
tarea = 0;
dist = PORT_DOUBLE_MAX;
for (i = 0; i < List->n_values; i++) {
int tmp_tcat;
area = List->id[i];
G_debug(4, "%d: area %d", i, area);
Vect_get_area_points(&To, area, TPoints);
/* Find the distance to this area */
if (Vect_point_in_area(FPoints->x[0], FPoints->y[0], &To, area, List->box[i])) { /* in area */
tmp_dist = 0;
tmp_tx = FPoints->x[0];
tmp_ty = FPoints->y[0];
}
else if (Vect_point_in_poly(FPoints->x[0], FPoints->y[0], TPoints) > 0) { /* in isle */
nisles = Vect_get_area_num_isles(&To, area);
for (j = 0; j < nisles; j++) {
double tmp2_dist, tmp2_tx, tmp2_ty;
isle = Vect_get_area_isle(&To, area, j);
Vect_get_isle_points(&To, isle, TPoints);
Vect_line_distance(TPoints, FPoints->x[0],
FPoints->y[0], FPoints->z[0],
WITHOUT_Z, &tmp2_tx, &tmp2_ty,
NULL, &tmp2_dist, NULL, NULL);
if (j == 0 || tmp2_dist < tmp_dist) {
tmp_dist = tmp2_dist;
tmp_tx = tmp2_tx;
tmp_ty = tmp2_ty;
}
}
}
else { /* outside area */
Vect_line_distance(TPoints, FPoints->x[0], FPoints->y[0],
FPoints->z[0], WITHOUT_Z, &tmp_tx,
&tmp_ty, NULL, &tmp_dist, NULL, NULL);
}
if (tmp_dist > max || tmp_dist < min)
continue; /* not in threshold */
Vect_get_area_cats(&To, area, TCats);
tmp_tcat = -1;
/* TODO: all cats of given field ? */
for (j = 0; j < TCats->n_cats; j++) {
if (TCats->field[j] == to_field) {
if (tmp_tcat >= 0)
G_warning(_("More cats found in to_layer (area=%d)"),
area);
tmp_tcat = TCats->cat[j];
}
}
G_debug(4, " tmp_dist = %f tmp_tcat = %d", tmp_dist,
tmp_tcat);
if (all) {
if (anear <= count) {
anear += 10 + nfrom / 10;
Near = (NEAR *) G_realloc(Near, anear * sizeof(NEAR));
}
near = &(Near[count]);
/* store info about relation */
near->from_cat = fcat;
near->to_cat = tmp_tcat; /* -1 is OK */
near->dist = tmp_dist;
near->from_x = FPoints->x[0];
near->from_y = FPoints->y[0];
near->to_x = tmp_tx;
near->to_y = tmp_ty;
near->to_along = 0; /* nonsense for areas */
near->to_angle = 0; /* not supported for areas */
near->count++;
count++;
}
else if (tarea == 0 || tmp_dist < dist) {
tarea = area;
tcat = tmp_tcat;
dist = tmp_dist;
tx = tmp_tx;
ty = tmp_ty;
}
}
if (curr_step < n_max_steps) {
/* enlarging the search box is possible */
if (tarea > 0 && dist > box_edge) {
/* area found but distance > search edge:
* area bbox overlaps with search box, area itself is outside search box */
done = 0;
}
else if (tarea == 0) {
/* no area within max dist, but search box can still be enlarged */
done = 0;
}
}
if (done && !all && tarea > 0) {
/* find near by cat */
near =
(NEAR *) bsearch((void *)&fcat, Near, nfcats,
sizeof(NEAR), cmp_near);
G_debug(4, "near.from_cat = %d near.count = %d dist = %f",
near->from_cat, near->count, near->dist);
/* store info about relation */
if (near->count == 0 || near->dist > dist) {
near->to_cat = tcat; /* -1 is OK */
near->dist = dist;
near->from_x = FPoints->x[0];
near->from_y = FPoints->y[0];
near->to_x = tx;
near->to_y = ty;
near->to_along = 0; /* nonsense for areas */
near->to_angle = 0; /* not supported for areas */
}
near->count++;
}
} /* done */
} /* next feature */
}
G_debug(3, "count = %d", count);
/* Update database / print to stdout / create output map */
if (print_flag->answer) { /* print header */
fprintf(stdout, "from_cat");
i = 0;
while (Upload[i].upload != END) {
fprintf(stdout, "|%s", Upload[i].column);
i++;
}
fprintf(stdout, "\n");
}
else if (all && table_opt->answer) { /* create new table */
db_set_string(&stmt, "create table ");
db_append_string(&stmt, table_opt->answer);
db_append_string(&stmt, " (from_cat integer");
j = 0;
while (Upload[j].upload != END) {
db_append_string(&stmt, ", ");
switch (Upload[j].upload) {
case CAT:
sprintf(buf2, "%s integer", Upload[j].column);
break;
case DIST:
case FROM_X:
case FROM_Y:
case TO_X:
case TO_Y:
case FROM_ALONG:
case TO_ALONG:
case TO_ANGLE:
sprintf(buf2, "%s double precision", Upload[j].column);
}
db_append_string(&stmt, buf2);
j++;
}
db_append_string(&stmt, " )");
G_debug(3, "SQL: %s", db_get_string(&stmt));
if (db_execute_immediate(driver, &stmt) != DB_OK)
G_fatal_error(_("Unable to create table: '%s'"),
db_get_string(&stmt));
if (db_grant_on_table(driver, table_opt->answer, DB_PRIV_SELECT,
DB_GROUP | DB_PUBLIC) != DB_OK)
G_fatal_error(_("Unable to grant privileges on table <%s>"),
table_opt->answer);
}
else if (!all) { /* read existing cats from table */
ncatexist =
db_select_int(driver, Fi->table, Fi->key, NULL, &catexist);
G_debug(1, "%d cats selected from the table", ncatexist);
}
update_ok = update_err = update_exist = update_notexist = update_dupl =
update_notfound = 0;
if (!all) {
count = nfcats;
}
else if (print_as_matrix) {
qsort((void *)Near, count, sizeof(NEAR), cmp_near_to);
}
if (driver)
db_begin_transaction(driver);
/* select 'to' attributes */
if (to_column_opt->answer) {
int nrec;
db_CatValArray_init(&cvarr);
nrec = db_select_CatValArray(to_driver, toFi->table, toFi->key,
to_column_opt->answer, NULL, &cvarr);
G_debug(3, "selected values = %d", nrec);
if (cvarr.ctype == DB_C_TYPE_DATETIME) {
G_warning(_("DATETIME type not yet supported, no attributes will be uploaded"));
}
db_close_database_shutdown_driver(to_driver);
}
if (!(print_flag->answer || (all && !table_opt->answer))) /* no printing */
G_message("Update database...");
for (i = 0; i < count; i++) {
dbCatVal *catval = 0;
if (!(print_flag->answer || (all && !table_opt->answer))) /* no printing */
G_percent(i, count, 1);
/* Write line connecting nearest points */
if (Outp != NULL) {
Vect_reset_line(FPoints);
Vect_reset_cats(FCats);
Vect_append_point(FPoints, Near[i].from_x, Near[i].from_y, 0);
if (Near[i].dist == 0) {
Vect_write_line(Outp, GV_POINT, FPoints, FCats);
}
else {
Vect_append_point(FPoints, Near[i].to_x, Near[i].to_y, 0);
Vect_write_line(Outp, GV_LINE, FPoints, FCats);
}
}
if (Near[i].count > 1)
update_dupl++;
if (Near[i].count == 0)
update_notfound++;
if (to_column_opt->answer && Near[i].count > 0) {
db_CatValArray_get_value(&cvarr, Near[i].to_cat, &catval);
}
if (print_flag->answer || (all && !table_opt->answer)) { /* print only */
/*
input and output is the same &&
calculate distances &&
only one upload option given ->
print as a matrix
*/
if (print_as_matrix) {
if (i == 0) {
for (j = 0; j < nfrom; j++) {
if (j == 0)
fprintf(stdout, " ");
fprintf(stdout, "|%d", Near[j].to_cat);
}
fprintf(stdout, "\n");
}
if (i % nfrom == 0) {
fprintf(stdout, "%d", Near[i].from_cat);
for (j = 0; j < nfrom; j++) {
print_upload(Near, Upload, i + j, &cvarr, catval);
}
fprintf(stdout, "\n");
}
}
else {
fprintf(stdout, "%d", Near[i].from_cat);
print_upload(Near, Upload, i, &cvarr, catval);
fprintf(stdout, "\n");
}
}
else if (all) { /* insert new record */
sprintf(buf1, "insert into %s values ( %d ", table_opt->answer,
Near[i].from_cat);
db_set_string(&stmt, buf1);
j = 0;
while (Upload[j].upload != END) {
db_append_string(&stmt, ",");
switch (Upload[j].upload) {
case CAT:
sprintf(buf2, " %d", Near[i].to_cat);
break;
case DIST:
sprintf(buf2, " %f", Near[i].dist);
break;
case FROM_X:
sprintf(buf2, " %f", Near[i].from_x);
break;
case FROM_Y:
sprintf(buf2, " %f", Near[i].from_y);
break;
case TO_X:
sprintf(buf2, " %f", Near[i].to_x);
break;
case TO_Y:
sprintf(buf2, " %f", Near[i].to_y);
break;
case FROM_ALONG:
sprintf(buf2, " %f", Near[i].from_along);
break;
case TO_ALONG:
sprintf(buf2, " %f", Near[i].to_along);
break;
case TO_ANGLE:
sprintf(buf2, " %f", Near[i].to_angle);
break;
case TO_ATTR:
if (catval) {
switch (cvarr.ctype) {
case DB_C_TYPE_INT:
sprintf(buf2, " %d", catval->val.i);
break;
case DB_C_TYPE_DOUBLE:
sprintf(buf2, " %.15e", catval->val.d);
break;
case DB_C_TYPE_STRING:
db_set_string(&dbstr,
db_get_string(catval->val.s));
db_double_quote_string(&dbstr);
sprintf(buf2, " '%s'", db_get_string(&dbstr));
break;
case DB_C_TYPE_DATETIME:
/* TODO: formating datetime */
sprintf(buf2, " null");
break;
}
}
else {
sprintf(buf2, " null");
}
break;
}
db_append_string(&stmt, buf2);
j++;
}
db_append_string(&stmt, " )");
G_debug(3, "SQL: %s", db_get_string(&stmt));
if (db_execute_immediate(driver, &stmt) == DB_OK) {
update_ok++;
}
else {
update_err++;
}
}
else { /* update table */
/* check if exists in table */
cex =
(int *)bsearch((void *)&(Near[i].from_cat), catexist,
ncatexist, sizeof(int), cmp_exist);
if (cex == NULL) { /* cat does not exist in DB */
update_notexist++;
continue;
}
update_exist++;
sprintf(buf1, "update %s set", Fi->table);
db_set_string(&stmt, buf1);
j = 0;
while (Upload[j].upload != END) {
if (j > 0)
db_append_string(&stmt, ",");
sprintf(buf2, " %s =", Upload[j].column);
db_append_string(&stmt, buf2);
if (Near[i].count == 0) { /* no nearest found */
db_append_string(&stmt, " null");
}
else {
switch (Upload[j].upload) {
case CAT:
if (Near[i].to_cat > 0)
sprintf(buf2, " %d", Near[i].to_cat);
else
sprintf(buf2, " null");
break;
case DIST:
sprintf(buf2, " %f", Near[i].dist);
break;
case FROM_X:
sprintf(buf2, " %f", Near[i].from_x);
break;
case FROM_Y:
sprintf(buf2, " %f", Near[i].from_y);
break;
case TO_X:
sprintf(buf2, " %f", Near[i].to_x);
break;
case TO_Y:
sprintf(buf2, " %f", Near[i].to_y);
break;
case FROM_ALONG:
sprintf(buf2, " %f", Near[i].from_along);
break;
case TO_ALONG:
sprintf(buf2, " %f", Near[i].to_along);
break;
case TO_ANGLE:
sprintf(buf2, " %f", Near[i].to_angle);
break;
case TO_ATTR:
if (catval) {
switch (cvarr.ctype) {
case DB_C_TYPE_INT:
sprintf(buf2, " %d", catval->val.i);
break;
case DB_C_TYPE_DOUBLE:
sprintf(buf2, " %.15e", catval->val.d);
break;
case DB_C_TYPE_STRING:
db_set_string(&dbstr,
db_get_string(catval->val.s));
db_double_quote_string(&dbstr);
sprintf(buf2, " '%s'", db_get_string(&dbstr));
break;
case DB_C_TYPE_DATETIME:
/* TODO: formating datetime */
sprintf(buf2, " null");
break;
}
}
else {
sprintf(buf2, " null");
}
break;
}
db_append_string(&stmt, buf2);
}
j++;
}
sprintf(buf2, " where %s = %d", Fi->key, Near[i].from_cat);
db_append_string(&stmt, buf2);
G_debug(2, "SQL: %s", db_get_string(&stmt));
if (db_execute_immediate(driver, &stmt) == DB_OK) {
update_ok++;
}
else {
update_err++;
}
}
}
G_percent(count, count, 1);
if (driver)
db_commit_transaction(driver);
/* print stats */
if (update_dupl > 0)
G_message(_("%d categories with more than 1 feature in vector map <%s>"),
update_dupl, from_opt->answer);
if (update_notfound > 0)
G_message(_("%d categories - no nearest feature found"),
update_notfound);
if (!print_flag->answer) {
db_close_database_shutdown_driver(driver);
db_free_string(&stmt);
/* print stats */
if (all && table_opt->answer) {
G_message(_("%d distances calculated"), count);
G_message(_("%d records inserted"), update_ok);
if (update_err > 0)
G_message(_("%d insert errors"), update_err);
}
else if (!all) {
if (nfcats > 0)
G_message(_("%d categories read from the map"), nfcats);
if (ncatexist > 0)
G_message(_("%d categories exist in the table"), ncatexist);
if (update_exist > 0)
G_message(_("%d categories read from the map exist in the table"),
update_exist);
if (update_notexist > 0)
G_message(_("%d categories read from the map don't exist in the table"),
update_notexist);
G_message(_("%d records updated"), update_ok);
if (update_err > 0)
G_message(_("%d update errors"), update_err);
G_free(catexist);
}
Vect_set_db_updated(&From);
}
Vect_close(&From);
if (Outp != NULL) {
Vect_build(Outp);
Vect_close(Outp);
}
G_done_msg(" ");
exit(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 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)
{
double radius;
double fisher, david, douglas, lloyd, lloydip, morisita;
int i, nquads, *counts;
struct Cell_head window;
struct GModule *module;
struct
{
struct Option *input, *field, *output, *n, *r;
} parm;
struct
{
struct Flag *g;
} flag;
COOR *quads;
struct Map_info Map;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("statistics"));
G_add_keyword(_("point pattern"));
module->description = _("Indices for quadrat counts of vector point lists.");
parm.input = G_define_standard_option(G_OPT_V_INPUT);
parm.field = G_define_standard_option(G_OPT_V_FIELD_ALL);
parm.output = G_define_standard_option(G_OPT_V_OUTPUT);
parm.output->required = NO;
parm.output->description =
_("Name for output quadrat centers map (number of points is written as category)");
parm.n = G_define_option();
parm.n->key = "nquadrats";
parm.n->type = TYPE_INTEGER;
parm.n->required = YES;
parm.n->description = _("Number of quadrats");
parm.r = G_define_option();
parm.r->key = "radius";
parm.r->type = TYPE_DOUBLE;
parm.r->required = YES;
parm.r->description = _("Quadrat radius");
flag.g = G_define_flag();
flag.g->key = 'g';
flag.g->description = _("Print results in shell script style");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
sscanf(parm.n->answer, "%d", &nquads);
sscanf(parm.r->answer, "%lf", &radius);
G_get_window(&window);
/* Open input */
Vect_set_open_level(2);
if (Vect_open_old2(&Map, parm.input->answer, "", parm.field->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), parm.input->answer);
/* Get the quadrats */
G_message(_("Finding quadrats..."));
quads = find_quadrats(nquads, radius, window);
/* Get the counts per quadrat */
G_message(_("Counting points quadrats..."));
counts = (int *)G_malloc(nquads * (sizeof(int)));
count_sites(quads, nquads, counts, radius, &Map,
Vect_get_field_number(&Map, parm.field->answer));
Vect_close(&Map);
/* output if requested */
if (parm.output->answer) {
struct Map_info Out;
struct line_pnts *Points;
struct line_cats *Cats;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
if (Vect_open_new(&Out, parm.output->answer, 0) < 0)
G_fatal_error(_("Unable to create vector map <%s>"),
parm.output->answer);
Vect_hist_command(&Out);
for (i = 0; i < nquads; i++) {
Vect_reset_line(Points);
Vect_reset_cats(Cats);
Vect_append_point(Points, quads[i].x, quads[i].y, 0.0);
Vect_cat_set(Cats, 1, counts[i]);
Vect_write_line(&Out, GV_POINT, Points, Cats);
}
Vect_build(&Out);
Vect_close(&Out);
}
/* Indices if requested */
qindices(counts, nquads, &fisher, &david, &douglas, &lloyd, &lloydip,
&morisita);
if (!flag.g->answer) {
fprintf(stdout,
"-----------------------------------------------------------\n");
fprintf(stdout,
"Index Realization\n");
fprintf(stdout,
"-----------------------------------------------------------\n");
fprintf(stdout,
"Fisher el al (1922) Relative Variance %g\n",
fisher);
fprintf(stdout,
"David & Moore (1954) Index of Cluster Size %g\n",
david);
fprintf(stdout,
"Douglas (1975) Index of Cluster Frequency %g\n",
douglas);
fprintf(stdout,
"Lloyd (1967) \"mean crowding\" %g\n",
lloyd);
fprintf(stdout,
"Lloyd (1967) Index of patchiness %g\n",
lloydip);
fprintf(stdout,
"Morisita's (1959) I (variability b/n patches) %g\n",
morisita);
fprintf(stdout,
"-----------------------------------------------------------\n");
}
else {
fprintf(stdout, "fisher=%g\n", fisher);
fprintf(stdout, "david=%g\n", david);
fprintf(stdout, "douglas=%g\n", douglas);
fprintf(stdout, "lloyd=%g\n", lloyd);
fprintf(stdout, "lloydip=%g\n", lloydip);
fprintf(stdout, "morisita=%g\n", morisita);
}
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct GModule *module;
char *input_opt, *field_opt;
int hist_flag, col_flag, shell_flag;
struct Map_info Map;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("metadata"));
G_add_keyword(_("topology"));
G_add_keyword(_("extent"));
G_add_keyword(_("history"));
G_add_keyword(_("attribute columns"));
module->description =
_("Outputs basic information about a vector map.");
G_debug(1, "LFS is %s", sizeof(off_t) == 8 ? "available" : "not available");
parse_args(argc, argv,
&input_opt, &field_opt,
&hist_flag, &col_flag, &shell_flag);
/* try to open head-only on level 2 */
if (Vect_open_old_head2(&Map, input_opt, "", field_opt) < 2) {
/* force level 1, open fully
* NOTE: number of points, lines, boundaries, centroids, faces, kernels is still available */
Vect_close(&Map);
Vect_set_open_level(1); /* no topology */
if (Vect_open_old2(&Map, input_opt, "", field_opt) < 1)
G_fatal_error(_("Unable to open vector map <%s>"), Vect_get_full_name(&Map));
/* level one info not needed for history, title, columns */
if (!hist_flag && !col_flag)
level_one_info(&Map);
}
if (hist_flag || col_flag) {
if (hist_flag) {
char buf[1001];
Vect_hist_rewind(&Map);
while (Vect_hist_read(buf, 1000, &Map) != NULL) {
fprintf(stdout, "%s\n", buf);
}
}
else if (col_flag) {
print_columns(&Map, input_opt, field_opt);
}
Vect_close(&Map);
return (EXIT_SUCCESS);
}
if (shell_flag & SHELL_BASIC) {
print_shell(&Map);
}
if (shell_flag & SHELL_REGION) {
print_region(&Map);
}
if (shell_flag & SHELL_TOPO) {
print_topo(&Map);
}
if (shell_flag == 0) {
print_info(&Map);
}
Vect_close(&Map);
return (EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct Map_info In, Out, Error;
struct line_pnts *Points;
struct line_cats *Cats;
int i, type, iter;
struct GModule *module; /* GRASS module for parsing arguments */
struct Option *map_in, *map_out, *error_out, *thresh_opt, *method_opt,
*look_ahead_opt;
struct Option *iterations_opt, *cat_opt, *alpha_opt, *beta_opt, *type_opt;
struct Option *field_opt, *where_opt, *reduction_opt, *slide_opt;
struct Option *angle_thresh_opt, *degree_thresh_opt,
*closeness_thresh_opt;
struct Option *betweeness_thresh_opt;
struct Flag *notab_flag, *loop_support_flag;
int with_z;
int total_input, total_output; /* Number of points in the input/output map respectively */
double thresh, alpha, beta, reduction, slide, angle_thresh;
double degree_thresh, closeness_thresh, betweeness_thresh;
int method;
int look_ahead, iterations;
int loop_support;
int layer;
int n_lines;
int simplification, mask_type;
struct cat_list *cat_list = NULL;
char *s, *descriptions;
/* initialize GIS environment */
G_gisinit(argv[0]); /* reads grass env, stores program name to G_program_name() */
/* initialize module */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("generalization"));
G_add_keyword(_("simplification"));
G_add_keyword(_("smoothing"));
G_add_keyword(_("displacement"));
G_add_keyword(_("network generalization"));
module->description = _("Performs vector based generalization.");
/* 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_ALL);
type_opt = G_define_standard_option(G_OPT_V_TYPE);
type_opt->options = "line,boundary,area";
type_opt->answer = "line,boundary,area";
type_opt->guisection = _("Selection");
map_out = G_define_standard_option(G_OPT_V_OUTPUT);
error_out = G_define_standard_option(G_OPT_V_OUTPUT);
error_out->key = "error";
error_out->required = NO;
error_out->description =
_("Error map of all lines and boundaries not being generalized due to topology issues or over-simplification");
method_opt = G_define_option();
method_opt->key = "method";
method_opt->type = TYPE_STRING;
method_opt->required = YES;
method_opt->multiple = NO;
method_opt->options =
"douglas,douglas_reduction,lang,reduction,reumann,boyle,sliding_averaging,distance_weighting,chaiken,hermite,snakes,network,displacement";
descriptions = NULL;
G_asprintf(&descriptions,
"douglas;%s;"
"douglas_reduction;%s;"
"lang;%s;"
"reduction;%s;"
"reumann;%s;"
"boyle;%s;"
"sliding_averaging;%s;"
"distance_weighting;%s;"
"chaiken;%s;"
"hermite;%s;"
"snakes;%s;"
"network;%s;"
"displacement;%s;",
_("Douglas-Peucker Algorithm"),
_("Douglas-Peucker Algorithm with reduction parameter"),
_("Lang Simplification Algorithm"),
_("Vertex Reduction Algorithm eliminates points close to each other"),
_("Reumann-Witkam Algorithm"),
_("Boyle's Forward-Looking Algorithm"),
_("McMaster's Sliding Averaging Algorithm"),
_("McMaster's Distance-Weighting Algorithm"),
_("Chaiken's Algorithm"),
_("Interpolation by Cubic Hermite Splines"),
_("Snakes method for line smoothing"),
_("Network generalization"),
_("Displacement of lines close to each other"));
method_opt->descriptions = G_store(descriptions);
method_opt->description = _("Generalization algorithm");
thresh_opt = G_define_option();
thresh_opt->key = "threshold";
thresh_opt->type = TYPE_DOUBLE;
thresh_opt->required = YES;
thresh_opt->options = "0-1000000000";
thresh_opt->description = _("Maximal tolerance value");
look_ahead_opt = G_define_option();
look_ahead_opt->key = "look_ahead";
look_ahead_opt->type = TYPE_INTEGER;
look_ahead_opt->required = NO;
look_ahead_opt->answer = "7";
look_ahead_opt->description = _("Look-ahead parameter");
reduction_opt = G_define_option();
reduction_opt->key = "reduction";
reduction_opt->type = TYPE_DOUBLE;
reduction_opt->required = NO;
reduction_opt->answer = "50";
reduction_opt->options = "0-100";
reduction_opt->description =
_("Percentage of the points in the output of 'douglas_reduction' algorithm");
slide_opt = G_define_option();
slide_opt->key = "slide";
slide_opt->type = TYPE_DOUBLE;
slide_opt->required = NO;
slide_opt->answer = "0.5";
slide_opt->options = "0-1";
slide_opt->description =
_("Slide of computed point toward the original point");
angle_thresh_opt = G_define_option();
angle_thresh_opt->key = "angle_thresh";
angle_thresh_opt->type = TYPE_DOUBLE;
angle_thresh_opt->required = NO;
angle_thresh_opt->answer = "3";
angle_thresh_opt->options = "0-180";
angle_thresh_opt->description =
_("Minimum angle between two consecutive segments in Hermite method");
degree_thresh_opt = G_define_option();
degree_thresh_opt->key = "degree_thresh";
degree_thresh_opt->type = TYPE_INTEGER;
degree_thresh_opt->required = NO;
degree_thresh_opt->answer = "0";
degree_thresh_opt->description =
_("Degree threshold in network generalization");
closeness_thresh_opt = G_define_option();
closeness_thresh_opt->key = "closeness_thresh";
closeness_thresh_opt->type = TYPE_DOUBLE;
closeness_thresh_opt->required = NO;
closeness_thresh_opt->answer = "0";
closeness_thresh_opt->options = "0-1";
closeness_thresh_opt->description =
_("Closeness threshold in network generalization");
betweeness_thresh_opt = G_define_option();
betweeness_thresh_opt->key = "betweeness_thresh";
betweeness_thresh_opt->type = TYPE_DOUBLE;
betweeness_thresh_opt->required = NO;
betweeness_thresh_opt->answer = "0";
betweeness_thresh_opt->description =
_("Betweeness threshold in network generalization");
alpha_opt = G_define_option();
alpha_opt->key = "alpha";
alpha_opt->type = TYPE_DOUBLE;
alpha_opt->required = NO;
alpha_opt->answer = "1.0";
alpha_opt->description = _("Snakes alpha parameter");
beta_opt = G_define_option();
beta_opt->key = "beta";
beta_opt->type = TYPE_DOUBLE;
beta_opt->required = NO;
beta_opt->answer = "1.0";
beta_opt->description = _("Snakes beta parameter");
iterations_opt = G_define_option();
iterations_opt->key = "iterations";
iterations_opt->type = TYPE_INTEGER;
iterations_opt->required = NO;
iterations_opt->answer = "1";
iterations_opt->description = _("Number of iterations");
cat_opt = G_define_standard_option(G_OPT_V_CATS);
cat_opt->guisection = _("Selection");
where_opt = G_define_standard_option(G_OPT_DB_WHERE);
where_opt->guisection = _("Selection");
loop_support_flag = G_define_flag();
loop_support_flag->key = 'l';
loop_support_flag->label = _("Disable loop support");
loop_support_flag->description = _("Do not modify end points of lines forming a closed loop");
notab_flag = G_define_standard_flag(G_FLG_V_TABLE);
notab_flag->description = _("Do not copy attributes");
notab_flag->guisection = _("Attributes");
/* options and flags parser */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
thresh = atof(thresh_opt->answer);
look_ahead = atoi(look_ahead_opt->answer);
alpha = atof(alpha_opt->answer);
beta = atof(beta_opt->answer);
reduction = atof(reduction_opt->answer);
iterations = atoi(iterations_opt->answer);
slide = atof(slide_opt->answer);
angle_thresh = atof(angle_thresh_opt->answer);
degree_thresh = atof(degree_thresh_opt->answer);
closeness_thresh = atof(closeness_thresh_opt->answer);
betweeness_thresh = atof(betweeness_thresh_opt->answer);
mask_type = type_mask(type_opt);
G_debug(3, "Method: %s", method_opt->answer);
s = method_opt->answer;
if (strcmp(s, "douglas") == 0)
method = DOUGLAS;
else if (strcmp(s, "lang") == 0)
method = LANG;
else if (strcmp(s, "reduction") == 0)
method = VERTEX_REDUCTION;
else if (strcmp(s, "reumann") == 0)
method = REUMANN;
else if (strcmp(s, "boyle") == 0)
method = BOYLE;
else if (strcmp(s, "distance_weighting") == 0)
method = DISTANCE_WEIGHTING;
else if (strcmp(s, "chaiken") == 0)
method = CHAIKEN;
else if (strcmp(s, "hermite") == 0)
method = HERMITE;
else if (strcmp(s, "snakes") == 0)
method = SNAKES;
else if (strcmp(s, "douglas_reduction") == 0)
method = DOUGLAS_REDUCTION;
else if (strcmp(s, "sliding_averaging") == 0)
method = SLIDING_AVERAGING;
else if (strcmp(s, "network") == 0)
method = NETWORK;
else if (strcmp(s, "displacement") == 0) {
method = DISPLACEMENT;
/* we can displace only the lines */
mask_type = GV_LINE;
}
else {
G_fatal_error(_("Unknown method"));
exit(EXIT_FAILURE);
}
/* simplification or smoothing? */
switch (method) {
case DOUGLAS:
case DOUGLAS_REDUCTION:
case LANG:
case VERTEX_REDUCTION:
case REUMANN:
simplification = 1;
break;
default:
simplification = 0;
break;
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_check_input_output_name(map_in->answer, map_out->answer,
G_FATAL_EXIT);
Vect_set_open_level(2);
if (Vect_open_old2(&In, map_in->answer, "", field_opt->answer) < 1)
G_fatal_error(_("Unable to open vector map <%s>"), map_in->answer);
if (Vect_get_num_primitives(&In, mask_type) == 0) {
G_warning(_("No lines found in input map <%s>"), map_in->answer);
Vect_close(&In);
exit(EXIT_SUCCESS);
}
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 (error_out->answer) {
if (0 > Vect_open_new(&Error, error_out->answer, with_z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create error vector map <%s>"), error_out->answer);
}
}
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
total_input = total_output = 0;
layer = Vect_get_field_number(&In, field_opt->answer);
/* parse filter options */
if (layer > 0)
cat_list = Vect_cats_set_constraint(&In, layer,
where_opt->answer, cat_opt->answer);
if (method == DISPLACEMENT) {
/* modifies only lines, all other features including boundaries are preserved */
/* options where, cats, and layer are respected */
G_message(_("Displacement..."));
snakes_displacement(&In, &Out, thresh, alpha, beta, 1.0, 10.0,
iterations, cat_list, layer);
}
/* TODO: rearrange code below. It's really messy */
if (method == NETWORK) {
/* extracts lines of selected type, all other features are discarded */
/* options where, cats, and layer are ignored */
G_message(_("Network generalization..."));
total_output =
graph_generalization(&In, &Out, mask_type, degree_thresh,
closeness_thresh, betweeness_thresh);
}
/* copy tables here because method == NETWORK is complete and
* tables for Out may be needed for parse_filter_options() below */
if (!notab_flag->answer) {
if (method == NETWORK)
copy_tables_by_cats(&In, &Out);
else
Vect_copy_tables(&In, &Out, -1);
}
else if (where_opt->answer && method < NETWORK) {
G_warning(_("Attributes are needed for 'where' option, copying table"));
Vect_copy_tables(&In, &Out, -1);
}
/* smoothing/simplification */
if (method < NETWORK) {
/* modifies only lines of selected type, all other features are preserved */
int not_modified_boundaries = 0, n_oversimplified = 0;
struct line_pnts *APoints; /* original Points */
set_topo_debug();
Vect_copy_map_lines(&In, &Out);
Vect_build_partial(&Out, GV_BUILD_CENTROIDS);
G_message("-----------------------------------------------------");
G_message(_("Generalization (%s)..."), method_opt->answer);
G_message(_("Using threshold: %g %s"), thresh, G_database_unit_name(1));
G_percent_reset();
APoints = Vect_new_line_struct();
n_lines = Vect_get_num_lines(&Out);
for (i = 1; i <= n_lines; i++) {
int after = 0;
G_percent(i, n_lines, 1);
type = Vect_read_line(&Out, APoints, Cats, i);
if (!(type & GV_LINES) || !(mask_type & type))
continue;
if (layer > 0) {
if ((type & GV_LINE) &&
!Vect_cats_in_constraint(Cats, layer, cat_list))
continue;
else if ((type & GV_BOUNDARY)) {
int do_line = 0;
int left, right;
do_line = Vect_cats_in_constraint(Cats, layer, cat_list);
if (!do_line) {
/* check if any of the centroids is selected */
Vect_get_line_areas(&Out, i, &left, &right);
if (left < 0)
left = Vect_get_isle_area(&Out, abs(left));
if (right < 0)
right = Vect_get_isle_area(&Out, abs(right));
if (left > 0) {
Vect_get_area_cats(&Out, left, Cats);
do_line = Vect_cats_in_constraint(Cats, layer, cat_list);
}
if (!do_line && right > 0) {
Vect_get_area_cats(&Out, right, Cats);
do_line = Vect_cats_in_constraint(Cats, layer, cat_list);
}
}
if (!do_line)
continue;
}
}
Vect_line_prune(APoints);
if (APoints->n_points < 2)
/* Line of length zero, delete if boundary ? */
continue;
total_input += APoints->n_points;
/* copy points */
Vect_reset_line(Points);
Vect_append_points(Points, APoints, GV_FORWARD);
loop_support = 0;
if (!loop_support_flag->answer) {
int n1, n2;
Vect_get_line_nodes(&Out, i, &n1, &n2);
if (n1 == n2) {
if (Vect_get_node_n_lines(&Out, n1) == 2) {
if (abs(Vect_get_node_line(&Out, n1, 0)) == i &&
abs(Vect_get_node_line(&Out, n1, 1)) == i)
loop_support = 1;
}
}
}
for (iter = 0; iter < iterations; iter++) {
switch (method) {
case DOUGLAS:
douglas_peucker(Points, thresh, with_z);
break;
case DOUGLAS_REDUCTION:
douglas_peucker_reduction(Points, thresh, reduction,
with_z);
break;
case LANG:
lang(Points, thresh, look_ahead, with_z);
break;
case VERTEX_REDUCTION:
vertex_reduction(Points, thresh, with_z);
break;
case REUMANN:
reumann_witkam(Points, thresh, with_z);
break;
case BOYLE:
boyle(Points, look_ahead, loop_support, with_z);
break;
case SLIDING_AVERAGING:
sliding_averaging(Points, slide, look_ahead, loop_support, with_z);
break;
case DISTANCE_WEIGHTING:
distance_weighting(Points, slide, look_ahead, loop_support, with_z);
break;
case CHAIKEN:
chaiken(Points, thresh, loop_support, with_z);
break;
case HERMITE:
hermite(Points, thresh, angle_thresh, loop_support, with_z);
break;
case SNAKES:
snakes(Points, alpha, beta, loop_support, with_z);
break;
}
}
if (loop_support == 0) {
/* safety check, BUG in method if not passed */
if (APoints->x[0] != Points->x[0] ||
APoints->y[0] != Points->y[0] ||
APoints->z[0] != Points->z[0])
G_fatal_error(_("Method '%s' did not preserve first point"), method_opt->answer);
if (APoints->x[APoints->n_points - 1] != Points->x[Points->n_points - 1] ||
APoints->y[APoints->n_points - 1] != Points->y[Points->n_points - 1] ||
APoints->z[APoints->n_points - 1] != Points->z[Points->n_points - 1])
G_fatal_error(_("Method '%s' did not preserve last point"), method_opt->answer);
}
else {
/* safety check, BUG in method if not passed */
if (Points->x[0] != Points->x[Points->n_points - 1] ||
Points->y[0] != Points->y[Points->n_points - 1] ||
Points->z[0] != Points->z[Points->n_points - 1])
G_fatal_error(_("Method '%s' did not preserve loop"), method_opt->answer);
}
Vect_line_prune(Points);
/* oversimplified line */
if (Points->n_points < 2) {
after = APoints->n_points;
n_oversimplified++;
if (error_out->answer)
Vect_write_line(&Error, type, APoints, Cats);
}
/* check for topology corruption */
else if (type == GV_BOUNDARY) {
if (!check_topo(&Out, i, APoints, Points, Cats)) {
after = APoints->n_points;
not_modified_boundaries++;
if (error_out->answer)
Vect_write_line(&Error, type, APoints, Cats);
}
else
after = Points->n_points;
}
else {
/* type == GV_LINE */
Vect_rewrite_line(&Out, i, type, Points, Cats);
after = Points->n_points;
}
total_output += after;
}
if (not_modified_boundaries > 0)
G_warning(_("%d boundaries were not modified because modification would damage topology"),
not_modified_boundaries);
if (n_oversimplified > 0)
G_warning(_("%d lines/boundaries were not modified due to over-simplification"),
n_oversimplified);
G_message("-----------------------------------------------------");
/* make sure that clean topo is built at the end */
Vect_build_partial(&Out, GV_BUILD_NONE);
if (error_out->answer)
Vect_build_partial(&Error, GV_BUILD_NONE);
}
Vect_build(&Out);
if (error_out->answer)
Vect_build(&Error);
Vect_close(&In);
Vect_close(&Out);
if (error_out->answer)
Vect_close(&Error);
G_message("-----------------------------------------------------");
if (total_input != 0 && total_input != total_output)
G_done_msg(_("Number of vertices for selected features %s from %d to %d (%d%% remaining)"),
simplification ? _("reduced") : _("changed"),
total_input, total_output,
(total_output * 100) / total_input);
else
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int i, j, precision, field, type, nlines;
int do_attr = 0, attr_cols[8], attr_size = 0, db_open = 0, cnt = 0;
double width, radius;
struct Option *in_opt, *out_opt, *prec_opt, *type_opt, *attr_opt,
*field_opt;
struct GModule *module;
struct Map_info In;
struct bound_box box;
/* vector */
struct line_pnts *Points;
struct line_cats *Cats;
/* attribs */
dbDriver *Driver = NULL;
dbHandle handle;
dbTable *Table;
dbString dbstring;
struct field_info *Fi;
/* init */
G_gisinit(argv[0]);
/* parse command-line */
module = G_define_module();
module->description = _("Exports a vector map to SVG file.");
G_add_keyword(_("vector"));
G_add_keyword(_("export"));
in_opt = G_define_standard_option(G_OPT_V_INPUT);
field_opt = G_define_standard_option(G_OPT_V_FIELD_ALL);
out_opt = G_define_standard_option(G_OPT_F_OUTPUT);
out_opt->description = _("Name for SVG output file");
type_opt = G_define_option();
type_opt->key = "type";
type_opt->type = TYPE_STRING;
type_opt->required = YES;
type_opt->multiple = NO;
type_opt->answer = "poly";
type_opt->options = "poly,line,point";
type_opt->label = _("Output type");
type_opt->description = _("Defines which feature-type will be extracted");
prec_opt = G_define_option();
prec_opt->key = "precision";
prec_opt->type = TYPE_INTEGER;
prec_opt->required = NO;
prec_opt->answer = "6";
prec_opt->multiple = NO;
prec_opt->description = _("Coordinate precision");
attr_opt = G_define_standard_option(G_OPT_DB_COLUMNS);
attr_opt->key = "attribute";
attr_opt->required = NO;
attr_opt->multiple = YES;
attr_opt->description = _("Attribute(s) to include in output SVG");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
if (type_opt->answer[0] == 'l') {
type = TYPE_LINE;
}
else {
if (type_opt->answer[2] == 'l')
type = TYPE_POLY;
else
type = TYPE_POINT;
}
/* override coordinate precision if any */
precision = atof(prec_opt->answer);
if (precision < 0) {
G_fatal_error(_("Precision must not be negative"));
}
if (precision > 15) {
G_fatal_error(_("Precision must not be higher than 15"));
}
/* open input vector */
Vect_set_open_level(2);
if (Vect_open_old2(&In, in_opt->answer, "", field_opt->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), in_opt->answer);
/* parse field number */
field = Vect_get_field_number(&In, field_opt->answer);
/* open db-driver to attribs */
db_init_string(&dbstring);
/* check for requested field */
Fi = Vect_get_field(&In, field);
if (Fi != NULL) {
Driver = db_start_driver(Fi->driver);
if (Driver == NULL) {
G_fatal_error(_("Unable to start driver <%s>"), Fi->driver);
}
/* open db */
db_init_handle(&handle);
db_set_handle(&handle, Fi->database, NULL);
if (db_open_database(Driver, &handle) != DB_OK) {
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
}
db_set_string(&dbstring, Fi->table);
if (db_describe_table(Driver, &dbstring, &Table) != DB_OK) {
G_fatal_error(_("Unable to describe table <%s>"), Fi->table);
}
/* define column-indices for columns to extract */
dbColumn *Column;
for (i = 0; i < db_get_table_number_of_columns(Table); i++) {
Column = db_get_table_column(Table, i);
if (attr_opt->answer != NULL) {
for (j = 0; attr_opt->answers[j] != NULL; j++) {
if (G_strcasecmp(attr_opt->answers[j],
db_get_column_name(Column)) == 0) {
attr_cols[attr_size] = i;
attr_size += 1;
break;
}
}
}
}
do_attr = 1;
db_open = 1;
}
/* parse bounding box and define default stroke-width, radius */
Vect_get_map_box(&In, &box);
if ((box.E - box.W) >= (box.N - box.S)) {
radius = (box.E - box.W) * RADIUS_SCALE;
width = (box.E - box.W) * WIDTH_SCALE;
}
else {
radius = (box.N - box.S) * RADIUS_SCALE;
width = (box.N - box.S) * WIDTH_SCALE;
}
/* open output SVG-file and print SVG-header with viewBox and Namenspaces */
if ((fpsvg = fopen(out_opt->answer, "w")) == NULL) {
G_fatal_error(_("Unable to create SVG file <%s>"), out_opt->answer);
}
fprintf(fpsvg, "<svg xmlns=\"%s\" xmlns:xlink=\"%s\" xmlns:gg=\"%s\" ",
SVG_NS, XLINK_NS, GRASS_NS);
fprintf(fpsvg, "viewBox=\"%.*f %.*f %.*f %.*f\">\n",
precision, box.W,
precision, box.N * -1,
precision, box.E - box.W, precision, box.N - box.S);
fprintf(fpsvg, "<title>v.out.svg %s %s</title>\n", in_opt->answer,
out_opt->answer);
nlines = Vect_get_num_lines(&In);
/* extract areas if any or requested */
if (type == TYPE_POLY) {
if (Vect_get_num_areas(&In) == 0) {
G_warning(_("No areas found, skipping %s"), "type=poly");
}
else {
int nareas;
nareas = Vect_get_num_areas(&In);
/* extract area as paths */
fprintf(fpsvg,
" <g id=\"%s\" fill=\"#CCC\" stroke=\"#000\" stroke-width=\"%.*f\" >\n",
G_Areas, precision, width);
for (i = 1; i <= nareas; i++) {
G_percent(i, nareas, 5);
/* skip areas without centroid */
if (Vect_get_area_centroid(&In, i) == 0) {
G_warning(_("Skipping area %d without centroid"), i);
continue;
}
/* extract attribs, parse area */
Vect_get_area_cats(&In, i, Cats);
fprintf(fpsvg, " <path ");
if (Cats->n_cats > 0) {
mk_attribs(Cats->cat[0], Fi, Driver, Table, attr_cols,
attr_size, do_attr);
}
fprintf(fpsvg, "d=\"");
Vect_get_area_points(&In, i, Points);
mk_path(Points, precision);
/* append islands if any within current path */
for (j = 0; j < Vect_get_area_num_isles(&In, i); j++) {
Vect_get_isle_points(&In, Vect_get_area_isle(&In, i, j),
Points);
mk_path(Points, precision);
}
fprintf(fpsvg, "\" />\n");
cnt += 1;
}
fprintf(fpsvg, " </g>\n");
G_message(_("%d areas extracted"), cnt);
}
}
/* extract points if requested */
if (type == TYPE_POINT) {
if (Vect_get_num_primitives(&In, GV_POINTS) == 0) {
G_warning(_("No points found, skipping %s"), "type=point");
}
else {
/* extract points as circles */
fprintf(fpsvg, " <g id=\"%s\" fill=\"#FC0\" stroke=\"#000\" "
"stroke-width=\"%.*f\" >\n", G_Points, precision, width);
for (i = 1; i <= nlines; i++) {
G_percent(i, nlines, 5);
if (!(Vect_read_line(&In, Points, Cats, i) & GV_POINTS))
continue;
if (field != -1 && !Vect_cat_get(Cats, field, NULL))
continue;
for (j = 0; j < Points->n_points; j++) {
fprintf(fpsvg, " <circle ");
if (Cats->n_cats > 0) {
mk_attribs(Cats->cat[j], Fi, Driver, Table, attr_cols,
attr_size, do_attr);
}
fprintf(fpsvg, "cx=\"%.*f\" cy=\"%.*f\" r=\"%.*f\" />\n",
precision, Points->x[j],
precision, Points->y[j] * -1, precision, radius);
cnt += 1;
}
}
fprintf(fpsvg, " </g>\n");
G_message(_("%d points extracted"), cnt);
}
}
/* extract lines if requested */
if (type == TYPE_LINE) {
if (Vect_get_num_primitives(&In, GV_LINES) == 0) {
G_warning(_("No lines found, skipping %s"), "type=line");
}
else {
/* extract lines as paths */
fprintf(fpsvg, " <g id=\"%s\" fill=\"none\" stroke=\"#000\" "
"stroke-width=\"%.*f\" >\n", G_Lines, precision, width);
for (i = 1; i <= nlines; i++) {
G_percent(i, nlines, 5);
if (!(Vect_read_line(&In, Points, Cats, i) & GV_LINES))
continue;
if (field != -1 && !Vect_cat_get(Cats, field, NULL))
continue;
fprintf(fpsvg, " <path ");
if (Cats->n_cats > 0) {
mk_attribs(Cats->cat[0], Fi, Driver, Table,
attr_cols, attr_size, do_attr);
}
fprintf(fpsvg, "d=\"");
mk_path(Points, precision);
fprintf(fpsvg, "\" />\n");
cnt += 1;
}
fprintf(fpsvg, " </g>\n");
G_message(_("%d lines extracted"), cnt);
}
}
/* finish code */
fprintf(fpsvg, "</svg>\n");
if (db_open == 1) {
/* close database handle */
db_close_database(Driver);
db_shutdown_driver(Driver);
}
/* close SVG-file */
fclose(fpsvg);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct Option *map_opt, *field_opt, *col_opt, *where_opt;
struct Option *algo_opt, *nbclass_opt;
struct Flag *shell_flag;
struct Map_info Map;
struct field_info *Fi;
dbDriver *Driver;
dbCatValArray Cvarr;
int ofield;
int nrec, ctype, nbclass, nbreaks, *frequencies;
int ret, i;
double finfo;
double *classbreaks, min, max, *data;
struct GASTATS stats;
char *desc;
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("classification"));
G_add_keyword(_("attribute table"));
G_add_keyword(_("statistics"));
module->description =
_("Classifies attribute data, e.g. for thematic mapping");
map_opt = G_define_standard_option(G_OPT_V_MAP);
field_opt = G_define_standard_option(G_OPT_V_FIELD);
col_opt = G_define_standard_option(G_OPT_DB_COLUMN);
col_opt->required = YES;
col_opt->description = _("Column name or expression");
where_opt = G_define_standard_option(G_OPT_DB_WHERE);
algo_opt = G_define_option();
algo_opt->key = "algorithm";
algo_opt->type = TYPE_STRING;
algo_opt->required = YES;
algo_opt->multiple = NO;
algo_opt->options = "int,std,qua,equ,dis";
algo_opt->description = _("Algorithm to use for classification");
desc = NULL;
G_asprintf(&desc,
"int;%s;"
"std;%s;"
"qua;%s;"
"equ;%s",
/* "dis;%s" */
_("simple intervals"),
_("standard deviations"),
_("quantiles"),
_("equiprobable (normal distribution)"));
/* _("discontinuities"));currently disabled because of bugs */
algo_opt->descriptions = desc;
nbclass_opt = G_define_option();
nbclass_opt->key = "nbclasses";
nbclass_opt->type = TYPE_INTEGER;
nbclass_opt->required = YES;
nbclass_opt->multiple = NO;
nbclass_opt->description = _("Number of classes to define");
shell_flag = G_define_flag();
shell_flag->key = 'g';
shell_flag->description =
_("Print only class breaks (without min and max)");
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* open input vector */
Vect_set_open_level(2);
if (Vect_open_old2(&Map, map_opt->answer, "", field_opt->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), map_opt->answer);
ofield = Vect_get_field_number(&Map, field_opt->answer);
/* Read attributes */
db_CatValArray_init(&Cvarr);
Fi = Vect_get_field(&Map, ofield);
if (Fi == NULL) {
G_fatal_error(_("Unable to get layer info for vector map"));
}
Vect_close(&Map);
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);
ret = db_CatValArray_sort_by_value(&Cvarr);
if (ret == DB_FAILED)
G_fatal_error(_("Unable to sort array of values"));
data = (double *)G_malloc((nrec) * sizeof(double));
for (i = 0; i < nrec; i++)
data[i] = 0.0;
if (ctype == DB_C_TYPE_INT) {
for (i = 0; i < nrec; i++)
data[i] = Cvarr.value[i].val.i;
}
else {
for (i = 0; i < nrec; i++)
data[i] = Cvarr.value[i].val.d;
}
nbclass = atoi(nbclass_opt->answer);
nbreaks = nbclass - 1; /* we need one less classbreaks (min and max exluded) than classes */
classbreaks = (double *)G_malloc((nbreaks) * sizeof(double));
for (i = 0; i < nbreaks; i++)
classbreaks[i] = 0;
/* Get classbreaks for given algorithm and number of classbreaks.
* finfo takes any info coming from the classification algorithms
* equ algorithm can alter number of class breaks */
finfo =
class_apply_algorithm(algo_opt->answer, data, nrec, &nbreaks,
classbreaks);
if (G_strcasecmp(algo_opt->answer, "dis") == 0 && finfo < 3.84148)
G_warning(_("The discontinuities algorithm indicates that some "
"class breaks are not statistically significant at "
"alpha=0.05. You are advised to reduce the number of classes."));
/*output to be piped to other modules ? */
if (shell_flag->answer) {
for (i = 0; i < nbreaks - 1; i++)
fprintf(stdout, "%f,", classbreaks[i]);
fprintf(stdout, "%f", classbreaks[nbreaks - 1]);
fprintf(stdout, "\n");
}
else {
frequencies = (int *)G_malloc((nbreaks + 1) * sizeof(int));
for (i = 0; i < nbreaks + 1; i++)
frequencies[i] = 0;
ret =
class_frequencies(data, nrec, nbreaks, classbreaks, frequencies);
basic_stats(data, nrec, &stats);
min = data[0];
max = data[nrec - 1];
/* as equ algorithm can modify number of breaks we recalculate number of
* classes
*/
fprintf(stdout, _("\nClassification of %s into %i classes\n"),
col_opt->answer, nbreaks + 1);
fprintf(stdout, _("Using algorithm: *** %s ***\n"), algo_opt->answer);
fprintf(stdout, _("Mean: %f\tStandard deviation = %f\n"), stats.mean,
stats.stdev);
if (G_strcasecmp(algo_opt->answer, "dis") == 0) {
fprintf(stdout, _("Lowest chi2 = %f\n"), finfo);
}
if (G_strcasecmp(algo_opt->answer, "std") == 0)
fprintf(stdout, _("Stdev multiplied by %.4f to define step\n"),
finfo);
fprintf(stdout, "\n");
fprintf(stdout, _("%15s%15s%15s\n\n"), "From (excl.)", "To (incl.)",
"Frequency");
fprintf(stdout, "%15.5f%15.5f%15i\n", min, classbreaks[0],
frequencies[0]);
for (i = 1; i < nbreaks; i++) {
fprintf(stdout, "%15.5f%15.5f%15i\n",
classbreaks[i - 1], classbreaks[i], frequencies[i]);
}
fprintf(stdout, "%15.5f%15.5f%15i\n",
classbreaks[nbreaks - 1], max, frequencies[nbreaks]);
fprintf(stdout, _("\nNote: Minimum of first class is including\n\n"));
}
fflush(stdout);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int i, j, centroid, otype, count;
int nlines, nareas;
int field;
struct GModule *module;
struct Option *in_opt, *field_opt, *out_opt, *type_opt;
struct Option *size_opt, *zmod_opt, *objmod_opt;
FILE *fd;
/* Vector */
struct Map_info In;
struct line_pnts *Points;
struct line_cats *Cats;
int type;
G_gisinit(argv[0]);
/* Module options */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("export"));
module->description =
_("Converts GRASS x,y,z points to POV-Ray x,z,y format.");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
field_opt = G_define_standard_option(G_OPT_V_FIELD_ALL);
type_opt = G_define_standard_option(G_OPT_V3_TYPE);
type_opt->answer = "point,line,area,face";
out_opt = G_define_standard_option(G_OPT_F_OUTPUT);
out_opt->required = YES;
out_opt->description = _("Name for output POV file");
size_opt = G_define_option();
size_opt->key = "size";
size_opt->type = TYPE_STRING;
size_opt->required = NO;
size_opt->answer = "10";
size_opt->label = _("Radius of sphere for points and tube for lines");
size_opt->description = _("May be also variable, e.g. grass_r.");
zmod_opt = G_define_option();
zmod_opt->key = "zmod";
zmod_opt->type = TYPE_STRING;
zmod_opt->required = NO;
zmod_opt->description = _("Modifier for z coordinates");
zmod_opt->description = _("This string is appended to each z coordinate. "
"Examples: '*10', '+1000', '*10+100', '*exaggeration'");
objmod_opt = G_define_option();
objmod_opt->key = "objmod";
objmod_opt->type = TYPE_STRING;
objmod_opt->required = NO;
objmod_opt->label = _("Object modifier (OBJECT_MODIFIER in POV-Ray documentation)");
objmod_opt->description = _("Example: \"pigment { color red 0 green 1 blue 0 }\"");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* Check output type */
otype = Vect_option_to_types(type_opt);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
/* open input vector */
Vect_set_open_level(2);
if (Vect_open_old2(&In, in_opt->answer, "", field_opt->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), in_opt->answer);
field = Vect_get_field_number(&In, field_opt->answer);
/* Open output file */
if ((fd = fopen(out_opt->answer, "w")) == NULL) {
Vect_close(&In);
G_fatal_error(_("Unable to create output file <%s>"), out_opt->answer);
}
if (zmod_opt->answer == NULL)
zmod_opt->answer = G_store("");
if (objmod_opt->answer == NULL)
objmod_opt->answer = G_store("");
nlines = Vect_get_num_lines(&In);
nareas = Vect_get_num_areas(&In);
count = 0;
/* Lines */
if ((otype &
(GV_POINTS | GV_LINES | GV_BOUNDARY | GV_CENTROID | GV_FACE |
GV_KERNEL))) {
for (i = 1; i <= nlines; i++) {
G_percent(i, nlines, 2);
type = Vect_read_line(&In, Points, Cats, i);
G_debug(2, "line = %d type = %d", i, type);
if (field != -1 && Vect_cat_get(Cats, field, NULL) == 0)
continue;
if (!(otype & type)) {
continue;
}
switch (type) {
case GV_POINT:
case GV_CENTROID:
case GV_KERNEL:
fprintf(fd, "sphere { <%f, %f %s, %f>, %s\n%s\n}\n",
Points->x[0], Points->z[0], zmod_opt->answer,
Points->y[0], size_opt->answer, objmod_opt->answer);
count++;
break;
case GV_LINE:
case GV_BOUNDARY:
if (Points->n_points < 2)
break; /* At least 2 points */
fprintf(fd, "sphere_sweep { linear_spline %d,\n",
Points->n_points);
for (j = 0; j < Points->n_points; j++) {
fprintf(fd, " <%f, %f %s, %f>, %s\n",
Points->x[j], Points->z[j], zmod_opt->answer,
Points->y[j], size_opt->answer);
}
fprintf(fd, " %s\n}\n", objmod_opt->answer);
count++;
break;
case GV_FACE:
if (Points->n_points < 3)
break; /* At least 3 points */
Vect_append_point(Points, Points->x[0], Points->y[0], Points->z[0]); /* close */
fprintf(fd, "polygon { %d, \n", Points->n_points);
for (j = 0; j < Points->n_points; j++) {
fprintf(fd, " <%f, %f %s, %f>\n",
Points->x[j], Points->z[j], zmod_opt->answer,
Points->y[j]);
}
fprintf(fd, " %s\n}\n", objmod_opt->answer);
count++;
break;
}
}
}
/* Areas (run always to count features of different type) */
if (otype & GV_AREA && nareas > 0) {
G_message(_("Processing areas..."));
for (i = 1; i <= nareas; i++) {
G_percent(i, nareas, 2);
/* TODO : Use this later for attributes from database: */
centroid = Vect_get_area_centroid(&In, i);
if (centroid > 0) {
Vect_read_line(&In, NULL, Cats, centroid);
if (field != -1 && Vect_cat_get(Cats, field, NULL) < 0)
continue;
}
G_debug(2, "area = %d centroid = %d", i, centroid);
/* Geometry */
/* Area */
Vect_get_area_points(&In, i, Points);
if (Points->n_points > 2) {
for (j = 0; j < Points->n_points; j++) {
fprintf(fd, "polygon { %d, \n", Points->n_points);
for (j = 0; j < Points->n_points; j++) {
fprintf(fd, " <%f, %f %s, %f>\n",
Points->x[j], Points->z[j], zmod_opt->answer,
Points->y[j]);
}
fprintf(fd, " %s\n}\n", objmod_opt->answer);
}
/* TODO: Isles */
/*
for ( k = 0; k < Vect_get_area_num_isles (&In, i); k++ ) {
Vect_get_isle_points ( &In, Vect_get_area_isle (&In, i, k), Points );
for ( j = 0; j < Points->n_points; j++ ) {
}
}
*/
count++;
}
}
}
fclose(fd);
Vect_close(&In);
/* Summary */
G_done_msg(n_("%d feature written.",
"%d features written.",
count), count);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
char *output, buf[DB_SQL_MAX];
double (*rng)(void) = G_drand48;
double zmin, zmax;
int seed;
int i, j, k, n, type, usefloat;
int area, nareas, field;
struct boxlist *List = NULL;
BOX_SIZE *size_list = NULL;
int alloc_size_list = 0;
struct Map_info In, Out;
struct line_pnts *Points;
struct line_cats *Cats;
struct cat_list *cat_list;
struct bound_box box;
struct Cell_head window;
struct GModule *module;
struct
{
struct Option *input, *field, *cats, *where, *output, *nsites,
*zmin, *zmax, *zcol, *ztype, *seed;
} parm;
struct
{
struct Flag *z, *notopo, *a;
} flag;
struct field_info *Fi;
dbDriver *driver;
dbTable *table;
dbString sql;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("sampling"));
G_add_keyword(_("statistics"));
G_add_keyword(_("random"));
module->description = _("Generates random 2D/3D vector points.");
parm.output = G_define_standard_option(G_OPT_V_OUTPUT);
parm.nsites = G_define_option();
parm.nsites->key = "n";
parm.nsites->type = TYPE_INTEGER;
parm.nsites->required = YES;
parm.nsites->description = _("Number of points to be created");
parm.input = G_define_standard_option(G_OPT_V_INPUT);
parm.input->required = NO;
parm.input->description = _("Restrict points to areas in input vector");
parm.input->guisection = _("Selection");
parm.field = G_define_standard_option(G_OPT_V_FIELD_ALL);
parm.field->guisection = _("Selection");
parm.cats = G_define_standard_option(G_OPT_V_CATS);
parm.cats->guisection = _("Selection");
parm.where = G_define_standard_option(G_OPT_DB_WHERE);
parm.where->guisection = _("Selection");
parm.zmin = G_define_option();
parm.zmin->key = "zmin";
parm.zmin->type = TYPE_DOUBLE;
parm.zmin->required = NO;
parm.zmin->description =
_("Minimum z height (needs -z flag or column name)");
parm.zmin->answer = "0.0";
parm.zmin->guisection = _("3D output");
parm.zmax = G_define_option();
parm.zmax->key = "zmax";
parm.zmax->type = TYPE_DOUBLE;
parm.zmax->required = NO;
parm.zmax->description =
_("Maximum z height (needs -z flag or column name)");
parm.zmax->answer = "0.0";
parm.zmax->guisection = _("3D output");
parm.seed = G_define_option();
parm.seed->key = "seed";
parm.seed->type = TYPE_INTEGER;
parm.seed->required = NO;
parm.seed->description =
_("The seed to initialize the random generator. If not set the process ID is used");
parm.zcol = G_define_standard_option(G_OPT_DB_COLUMN);
parm.zcol->label = _("Name of column for z values");
parm.zcol->description =
_("Writes z values to column");
parm.zcol->guisection = _("3D output");
parm.ztype = G_define_option();
parm.ztype->key = "column_type";
parm.ztype->type = TYPE_STRING;
parm.ztype->required = NO;
parm.ztype->multiple = NO;
parm.ztype->description = _("Type of column for z values");
parm.ztype->options = "integer,double precision";
parm.ztype->answer = "double precision";
parm.ztype->guisection = _("3D output");
flag.z = G_define_flag();
flag.z->key = 'z';
flag.z->description = _("Create 3D output");
flag.z->guisection = _("3D output");
flag.a = G_define_flag();
flag.a->key = 'a';
flag.a->description = _("Generate n points for each individual area");
flag.notopo = G_define_standard_flag(G_FLG_V_TOPO);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
output = parm.output->answer;
n = atoi(parm.nsites->answer);
if(parm.seed->answer)
seed = atoi(parm.seed->answer);
if (n <= 0) {
G_fatal_error(_("Number of points must be > 0 (%d given)"), n);
}
nareas = 0;
cat_list = NULL;
field = -1;
if (parm.input->answer) {
Vect_set_open_level(2); /* topology required */
if (2 > Vect_open_old2(&In, parm.input->answer, "", parm.field->answer))
G_fatal_error(_("Unable to open vector map <%s>"),
parm.input->answer);
if (parm.field->answer)
field = Vect_get_field_number(&In, parm.field->answer);
if ((parm.cats->answer || parm.where->answer) && field == -1) {
G_warning(_("Invalid layer number (%d). Parameter '%s' or '%s' specified, assuming layer '1'."),
field, parm.cats->key, parm.where->key);
field = 1;
}
if (field > 0)
cat_list = Vect_cats_set_constraint(&In, field, parm.where->answer,
parm.cats->answer);
nareas = Vect_get_num_areas(&In);
if (nareas == 0) {
Vect_close(&In);
G_fatal_error(_("No areas in vector map <%s>"), parm.input->answer);
}
}
else {
if (flag.a->answer)
G_fatal_error(_("The <-%c> flag requires an input vector with areas"),
flag.a->key);
}
/* create new vector map */
if (-1 == Vect_open_new(&Out, output, flag.z->answer ? WITH_Z : WITHOUT_Z))
G_fatal_error(_("Unable to create vector map <%s>"), output);
Vect_set_error_handler_io(NULL, &Out);
/* Do we need to write random values into attribute table? */
usefloat = -1;
if (parm.zcol->answer) {
Fi = Vect_default_field_info(&Out, 1, NULL, GV_1TABLE);
driver =
db_start_driver_open_database(Fi->driver,
Vect_subst_var(Fi->database, &Out));
if (driver == NULL) {
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Vect_subst_var(Fi->database, &Out), Fi->driver);
}
db_set_error_handler_driver(driver);
db_begin_transaction(driver);
db_init_string(&sql);
sprintf(buf, "create table %s (%s integer, %s %s)", Fi->table, GV_KEY_COLUMN,
parm.zcol->answer, parm.ztype->answer);
db_set_string(&sql, buf);
Vect_map_add_dblink(&Out, 1, NULL, Fi->table, GV_KEY_COLUMN, Fi->database,
Fi->driver);
/* Create table */
G_debug(3, db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
G_fatal_error(_("Unable to create table: %s"),
db_get_string(&sql));
}
/* Create index */
if (db_create_index2(driver, Fi->table, Fi->key) != DB_OK)
G_warning(_("Unable to create index"));
/* Grant */
if (db_grant_on_table
(driver, Fi->table, DB_PRIV_SELECT,
DB_GROUP | DB_PUBLIC) != DB_OK) {
G_fatal_error(_("Unable to grant privileges on table <%s>"),
Fi->table);
}
/* OK. Let's check what type of column user has created */
db_set_string(&sql, Fi->table);
if (db_describe_table(driver, &sql, &table) != DB_OK) {
G_fatal_error(_("Unable to describe table <%s>"), Fi->table);
}
if (db_get_table_number_of_columns(table) != 2) {
G_fatal_error(_("Table should contain only two columns"));
}
type = db_get_column_sqltype(db_get_table_column(table, 1));
if (type == DB_SQL_TYPE_SMALLINT || type == DB_SQL_TYPE_INTEGER)
usefloat = 0;
if (type == DB_SQL_TYPE_REAL || type == DB_SQL_TYPE_DOUBLE_PRECISION)
usefloat = 1;
if (usefloat < 0) {
G_fatal_error(_("You have created unsupported column type. This module supports only INTEGER"
" and DOUBLE PRECISION column types."));
}
}
Vect_hist_command(&Out);
/* Init the random seed */
if(parm.seed->answer)
G_srand48(seed);
else
G_srand48_auto();
G_get_window(&window);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
if (nareas > 0) {
int first = 1, count;
struct bound_box abox, bbox;
box.W = window.west;
box.E = window.east;
box.S = window.south;
box.N = window.north;
box.B = -PORT_DOUBLE_MAX;
box.T = PORT_DOUBLE_MAX;
count = 0;
for (i = 1; i <= nareas; i++) {
if (!Vect_get_area_centroid(&In, i))
continue;
if (field > 0) {
if (Vect_get_area_cats(&In, i, Cats))
continue;
if (!Vect_cats_in_constraint(Cats, field, cat_list))
continue;
}
Vect_get_area_box(&In, i, &abox);
if (!Vect_box_overlap(&abox, &box))
continue;
if (first) {
Vect_box_copy(&bbox, &abox);
first = 0;
}
else
Vect_box_extend(&bbox, &abox);
count++;
}
if (count == 0) {
Vect_close(&In);
Vect_close(&Out);
Vect_delete(output);
G_fatal_error(_("Selected areas in input vector <%s> do not overlap with the current region"),
parm.input->answer);
}
Vect_box_copy(&box, &bbox);
/* does the vector overlap with the current region ? */
if (box.W >= window.east || box.E <= window.west ||
box.S >= window.north || box.N <= window.south) {
Vect_close(&In);
Vect_close(&Out);
Vect_delete(output);
G_fatal_error(_("Input vector <%s> does not overlap with the current region"),
parm.input->answer);
}
/* try to reduce the current region */
if (window.east > box.E)
window.east = box.E;
if (window.west < box.W)
window.west = box.W;
if (window.north > box.N)
window.north = box.N;
if (window.south < box.S)
window.south = box.S;
List = Vect_new_boxlist(1);
alloc_size_list = 10;
size_list = G_malloc(alloc_size_list * sizeof(BOX_SIZE));
}
zmin = zmax = 0;
if (flag.z->answer || parm.zcol->answer) {
zmax = atof(parm.zmax->answer);
zmin = atof(parm.zmin->answer);
}
G_message(_("Generating points..."));
if (flag.a->answer && nareas > 0) {
struct bound_box abox, bbox;
int cat = 1;
/* n points for each area */
nareas = Vect_get_num_areas(&In);
G_percent(0, nareas, 1);
for (area = 1; area <= nareas; area++) {
G_percent(area, nareas, 1);
if (!Vect_get_area_centroid(&In, area))
continue;
if (field > 0) {
if (Vect_get_area_cats(&In, area, Cats))
continue;
if (!Vect_cats_in_constraint(Cats, field, cat_list)) {
continue;
}
}
box.W = window.west;
box.E = window.east;
box.S = window.south;
box.N = window.north;
box.B = -PORT_DOUBLE_MAX;
box.T = PORT_DOUBLE_MAX;
Vect_get_area_box(&In, area, &abox);
if (!Vect_box_overlap(&box, &abox))
continue;
bbox = abox;
if (bbox.W < box.W)
bbox.W = box.W;
if (bbox.E > box.E)
bbox.E = box.E;
if (bbox.S < box.S)
bbox.S = box.S;
if (bbox.N > box.N)
bbox.N = box.N;
for (i = 0; i < n; ++i) {
double x, y, z;
int outside = 1;
int ret;
Vect_reset_line(Points);
Vect_reset_cats(Cats);
while (outside) {
x = rng() * (bbox.W - bbox.E) + bbox.E;
y = rng() * (bbox.N - bbox.S) + bbox.S;
z = rng() * (zmax - zmin) + zmin;
ret = Vect_point_in_area(x, y, &In, area, &abox);
G_debug(3, " area = %d Vect_point_in_area() = %d", area, ret);
if (ret >= 1) {
outside = 0;
}
}
if (flag.z->answer)
Vect_append_point(Points, x, y, z);
else
Vect_append_point(Points, x, y, 0.0);
if (parm.zcol->answer) {
sprintf(buf, "insert into %s values ( %d, ", Fi->table, i + 1);
db_set_string(&sql, buf);
/* Round random value if column is integer type */
if (usefloat)
sprintf(buf, "%f )", z);
else
sprintf(buf, "%.0f )", z);
db_append_string(&sql, buf);
G_debug(3, db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
G_fatal_error(_("Cannot insert new row: %s"),
db_get_string(&sql));
}
}
Vect_cat_set(Cats, 1, cat++);
Vect_write_line(&Out, GV_POINT, Points, Cats);
}
}
}
else {
/* n points in total */
for (i = 0; i < n; ++i) {
double x, y, z;
G_percent(i, n, 4);
Vect_reset_line(Points);
Vect_reset_cats(Cats);
x = rng() * (window.west - window.east) + window.east;
y = rng() * (window.north - window.south) + window.south;
z = rng() * (zmax - zmin) + zmin;
if (nareas) {
int outside = 1;
do {
/* select areas by box */
box.E = x;
box.W = x;
box.N = y;
box.S = y;
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
Vect_select_areas_by_box(&In, &box, List);
G_debug(3, " %d areas selected by box", List->n_values);
/* sort areas by size, the smallest is likely to be the nearest */
if (alloc_size_list < List->n_values) {
alloc_size_list = List->n_values;
size_list = G_realloc(size_list, alloc_size_list * sizeof(BOX_SIZE));
}
k = 0;
for (j = 0; j < List->n_values; j++) {
area = List->id[j];
if (!Vect_get_area_centroid(&In, area))
continue;
if (field > 0) {
if (Vect_get_area_cats(&In, area, Cats))
continue;
if (!Vect_cats_in_constraint(Cats, field, cat_list)) {
continue;
}
}
List->id[k] = List->id[j];
List->box[k] = List->box[j];
size_list[k].i = List->id[k];
box = List->box[k];
size_list[k].box = List->box[k];
size_list[k].size = (box.N - box.S) * (box.E - box.W);
k++;
}
List->n_values = k;
if (List->n_values == 2) {
/* simple swap */
if (size_list[1].size < size_list[0].size) {
size_list[0].i = List->id[1];
size_list[1].i = List->id[0];
size_list[0].box = List->box[1];
size_list[1].box = List->box[0];
}
}
else if (List->n_values > 2)
qsort(size_list, List->n_values, sizeof(BOX_SIZE), sort_by_size);
for (j = 0; j < List->n_values; j++) {
int ret;
area = size_list[j].i;
ret = Vect_point_in_area(x, y, &In, area, &size_list[j].box);
G_debug(3, " area = %d Vect_point_in_area() = %d", area, ret);
if (ret >= 1) {
outside = 0;
break;
}
}
if (outside) {
x = rng() * (window.west - window.east) + window.east;
y = rng() * (window.north - window.south) + window.south;
z = rng() * (zmax - zmin) + zmin;
}
} while (outside);
}
if (flag.z->answer)
Vect_append_point(Points, x, y, z);
else
Vect_append_point(Points, x, y, 0.0);
if (parm.zcol->answer) {
sprintf(buf, "insert into %s values ( %d, ", Fi->table, i + 1);
db_set_string(&sql, buf);
/* Round random value if column is integer type */
if (usefloat)
sprintf(buf, "%f )", z);
else
sprintf(buf, "%.0f )", z);
db_append_string(&sql, buf);
G_debug(3, db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
G_fatal_error(_("Cannot insert new row: %s"),
db_get_string(&sql));
}
}
Vect_cat_set(Cats, 1, i + 1);
Vect_write_line(&Out, GV_POINT, Points, Cats);
}
G_percent(1, 1, 1);
}
if (parm.zcol->answer) {
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
}
if (!flag.notopo->answer) {
Vect_build(&Out);
}
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int out_fd;
CELL *result, *rp;
int nrows, ncols;
int row, col, count_sum;
int field;
struct GModule *module;
struct Option *in_opt, *out_opt, *field_opt;
struct Option *method_opt, *size_opt;
struct Map_info In;
double radius;
struct boxlist *List;
struct Cell_head region;
struct bound_box box;
struct line_pnts *Points;
struct line_cats *Cats;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("algebra"));
G_add_keyword(_("statistics"));
G_add_keyword(_("raster"));
G_add_keyword(_("aggregation"));
module->label = _("Neighborhood analysis tool for vector point maps.");
module->description = _("Makes each cell value a "
"function of the attribute values assigned to the vector points or centroids "
"around it, and stores new cell values in an output raster map.");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
field_opt = G_define_standard_option(G_OPT_V_FIELD_ALL);
out_opt = G_define_standard_option(G_OPT_R_OUTPUT);
method_opt = G_define_option();
method_opt->key = "method";
method_opt->type = TYPE_STRING;
method_opt->required = YES;
method_opt->options = "count";
method_opt->answer = "count";
method_opt->description = _("Neighborhood operation");
size_opt = G_define_option();
size_opt->key = "size";
size_opt->type = TYPE_DOUBLE;
size_opt->required = YES;
size_opt->description = _("Neighborhood diameter in map units");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
radius = atof(size_opt->answer) / 2;
/* open input vector */
Vect_set_open_level(2);
if (Vect_open_old2(&In, in_opt->answer, "", field_opt->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), in_opt->answer);
field = Vect_get_field_number(&In, field_opt->answer);
G_get_set_window(®ion);
nrows = Rast_window_rows();
ncols = Rast_window_cols();
result = Rast_allocate_buf(CELL_TYPE);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
List = Vect_new_boxlist(0);
/*open the new cellfile */
out_fd = Rast_open_new(out_opt->answer, CELL_TYPE);
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
count_sum = 0;
for (row = 0; row < nrows; row++) {
double x, y;
G_percent(row, nrows, 2);
y = Rast_row_to_northing(row + 0.5, ®ion);
box.N = y + radius;
box.S = y - radius;
Rast_set_null_value(result, ncols, CELL_TYPE);
rp = result;
for (col = 0; col < ncols; col++) {
int i, count;
CELL value;
x = Rast_col_to_easting(col + 0.5, ®ion);
box.E = x + radius;
box.W = x - radius;
Vect_select_lines_by_box(&In, &box, GV_POINTS, List);
G_debug(3, " %d lines in box", List->n_values);
count = 0;
for (i = 0; i < List->n_values; i++) {
Vect_read_line(&In, Points, Cats, List->id[i]);
if (field != -1 && Vect_cat_get(Cats, field, NULL) == 0)
continue;
if (Vect_points_distance(x, y, 0.0, Points->x[0],
Points->y[0], 0.0, 0) <= radius)
count++;
}
if (count > 0) {
value = count;
Rast_set_d_value(rp, value, CELL_TYPE);
}
rp = G_incr_void_ptr(rp, Rast_cell_size(CELL_TYPE));
count_sum += count;
}
Rast_put_row(out_fd, result, CELL_TYPE);
}
G_percent(1, 1, 1);
Vect_close(&In);
Rast_close(out_fd);
if (count_sum < 1)
G_warning(_("No points found"));
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct Option *map_opt, *type_opt,
*percentile;
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("statistics"));
G_add_keyword(_("univariate statistics"));
G_add_keyword(_("attribute table"));
G_add_keyword(_("geometry"));
module->label =
_("Calculates univariate statistics of vector map features.");
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";
type_opt->answer = "point,line,area";
col_opt = G_define_standard_option(G_OPT_DB_COLUMN);
col_opt->required = NO;
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");
ext_flag = G_define_flag();
ext_flag->key = 'e';
ext_flag->description = _("Calculate extended statistics");
weight_flag = G_define_flag();
weight_flag->key = 'w';
weight_flag->description = _("Weigh by line length or area size");
geometry = G_define_flag();
geometry->key = 'd';
geometry->description = _("Calculate geometric distances instead of attribute statistics");
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* Only require col_opt answer if -g flag is not set */
if (!col_opt->answer && !geometry->answer) {
G_fatal_error(_("Required parameter <%s> not set:\n\t(%s)"), col_opt->key, col_opt->description);
}
otype = Vect_option_to_types(type_opt);
perc = atoi(percentile->answer);
Cats = Vect_new_cats_struct();
/* open input vector */
Vect_set_open_level(2);
if (Vect_open_old2(&Map, map_opt->answer, "", field_opt->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), map_opt->answer);
ofield = Vect_get_field_number(&Map, field_opt->answer);
if ((otype & GV_POINT) && Vect_get_num_primitives(&Map, GV_POINT) == 0) {
otype &= ~(GV_POINT);
if (otype & GV_POINT)
G_fatal_error("Bye");
}
if ((otype & GV_CENTROID) && Vect_get_num_primitives(&Map, GV_CENTROID) == 0) {
otype &= ~(GV_CENTROID);
}
if ((otype & GV_LINE) && Vect_get_num_primitives(&Map, GV_LINE) == 0) {
otype &= ~(GV_LINE);
}
if ((otype & GV_BOUNDARY) && Vect_get_num_primitives(&Map, GV_BOUNDARY) == 0) {
otype &= ~(GV_BOUNDARY);
}
if ((otype & GV_AREA) && Vect_get_num_areas(&Map) == 0) {
otype &= ~(GV_AREA);
}
/* 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 && geometry->answer)
compatible = 1; /* distances is compatible with GV_POINTS and GV_LINES */
if (!compatible && !weight_flag->answer)
compatible = 1; /* attributes are always compatible without weight */
if (geometry->answer && (otype & GV_AREA))
G_fatal_error(_("Geometry distances are not supported for areas. Use '%s' instead."), "v.distance");
if (!compatible) {
G_warning(_("Incompatible vector type(s) specified, only number of features, minimum, maximum and range "
"can be calculated"));
}
if (ext_flag->answer && (!(otype & GV_POINTS) || geometry->answer)) {
G_warning(_("Extended statistics is currently supported only for points/centroids"));
}
if (geometry->answer)
select_from_geometry();
else
select_from_database();
summary();
Vect_close(&Map);
exit(EXIT_SUCCESS);
}
int vect_to_rast(const char *vector_map, const char *raster_map, const char *field_name,
const char *column, int cache_mb, int use, double value,
int value_type, const char *rgbcolumn, const char *labelcolumn,
int ftype, char *where, char *cats, int dense)
{
struct Map_info Map;
struct line_pnts *Points;
int i, field;
struct cat_list *cat_list = NULL;
int fd; /* for raster map */
int nareas, nlines; /* number of converted features */
int nareas_all, nplines_all; /* number of all areas, points/lines */
int stat;
int format;
int pass, npasses;
/* Attributes */
int nrec;
int ctype = 0;
struct field_info *Fi;
dbDriver *Driver;
dbCatValArray cvarr;
int is_fp = 0;
nareas = 0;
G_verbose_message(_("Loading data..."));
Vect_set_open_level(2);
if (Vect_open_old2(&Map, vector_map, "", field_name) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), vector_map);
field = Vect_get_field_number(&Map, field_name);
if (field > 0)
cat_list = Vect_cats_set_constraint(&Map, field, where, cats);
if ((use == USE_Z) && !(Vect_is_3d(&Map)))
G_fatal_error(_("Vector map <%s> is not 3D"),
Vect_get_full_name(&Map));
switch (use) {
case USE_ATTR:
db_CatValArray_init(&cvarr);
if (!(Fi = Vect_get_field(&Map, field)))
G_fatal_error(_("Database connection not defined for layer <%s>"),
field_name);
if ((Driver =
db_start_driver_open_database(Fi->driver, Fi->database)) == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
db_set_error_handler_driver(Driver);
/* Note do not check if the column exists in the table because it may be expression */
if ((nrec =
db_select_CatValArray(Driver, Fi->table, Fi->key, column, NULL,
&cvarr)) == -1)
G_fatal_error(_("Column <%s> not found"), column);
G_debug(3, "nrec = %d", nrec);
ctype = cvarr.ctype;
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Column type (%s) not supported (did you mean 'labelcolumn'?)"),
db_sqltype_name(ctype));
if (nrec < 0)
G_fatal_error(_("No records selected from table <%s>"),
Fi->table);
G_debug(1, "%d records selected from table", nrec);
db_close_database_shutdown_driver(Driver);
for (i = 0; i < cvarr.n_values; i++) {
if (ctype == DB_C_TYPE_INT) {
G_debug(3, "cat = %d val = %d", cvarr.value[i].cat,
cvarr.value[i].val.i);
}
else if (ctype == DB_C_TYPE_DOUBLE) {
G_debug(3, "cat = %d val = %f", cvarr.value[i].cat,
cvarr.value[i].val.d);
}
}
switch (ctype) {
case DB_C_TYPE_INT:
format = CELL_TYPE;
break;
case DB_C_TYPE_DOUBLE:
format = DCELL_TYPE;
break;
default:
G_fatal_error(_("Unable to use column <%s>"), column);
break;
}
break;
case USE_CAT:
format = CELL_TYPE;
break;
case USE_VAL:
format = value_type;
break;
case USE_Z:
format = DCELL_TYPE;
is_fp = 1;
break;
case USE_D:
format = DCELL_TYPE;
break;
default:
G_fatal_error(_("Unknown use type: %d"), use);
}
fd = Rast_open_new(raster_map, format);
Points = Vect_new_line_struct();
if (use != USE_Z && use != USE_D && (ftype & GV_AREA)) {
if ((nareas = sort_areas(&Map, Points, field, cat_list)) == 0)
G_warning(_("No areas selected from vector map <%s>"),
vector_map);
G_debug(1, "%d areas sorted", nareas);
}
if (nareas > 0 && dense) {
G_warning(_("Area conversion and line densification are mutually exclusive, disabling line densification."));
dense = 0;
}
nlines = Vect_get_num_primitives(&Map, ftype);
nplines_all = nlines;
npasses = begin_rasterization(cache_mb, format, dense);
pass = 0;
nareas_all = Vect_get_num_areas(&Map);
do {
pass++;
if (npasses > 1)
G_message(_("Pass %d of %d:"), pass, npasses);
stat = 0;
if ((use != USE_Z && use != USE_D) && nareas) {
if (do_areas
(&Map, Points, &cvarr, ctype, use, value,
value_type) < 0) {
G_warning(_("Problem processing areas from vector map <%s>, continuing..."),
vector_map);
stat = -1;
break;
}
}
if (nlines) {
if ((nlines =
do_lines(&Map, Points, &cvarr, ctype, field, cat_list,
use, value, value_type, ftype,
&nplines_all, dense)) < 0) {
G_warning(_("Problem processing lines from vector map <%s>, continuing..."),
vector_map);
stat = -1;
break;
}
}
G_important_message(_("Writing raster map..."));
stat = output_raster(fd);
} while (stat == 0);
G_suppress_warnings(0);
/* stat: 0 == repeat; 1 == done; -1 == error; */
Vect_destroy_line_struct(Points);
if (stat < 0) {
Rast_unopen(fd);
return 1;
}
Vect_close(&Map);
G_verbose_message(_("Creating support files for raster map..."));
Rast_close(fd);
update_hist(raster_map, vector_map, Map.head.orig_scale);
/* colors */
if (rgbcolumn) {
if (use != USE_ATTR && use != USE_CAT) {
G_warning(_("Color can be updated from database only if use=attr"));
update_colors(raster_map);
}
else {
update_dbcolors(raster_map, vector_map, field, rgbcolumn, is_fp,
column);
}
}
else if (use == USE_D)
update_fcolors(raster_map);
else
update_colors(raster_map);
update_cats(raster_map);
/* labels */
update_labels(raster_map, vector_map, field, labelcolumn, use, value,
column);
#if 0
/* maximum possible numer of areas: number of centroids
* actual number of areas, currently unknown:
* number of areas with centroid that are within cat constraint
* and overlap with current region */
if (nareas_all > 0)
G_message(_("Converted areas: %d of %d"), nareas,
Vect_get_num_primitives(&Map, GV_CENTROID));
/* maximum possible numer of lines: number of GV_LINE + GV_POINT
* actual number of lines, currently unknown:
* number of lines are within cat constraint
* and overlap with current region */
if (nlines > 0 && nplines_all > 0)
G_message(_("Converted points/lines: %d of %d"), nlines, nplines_all);
#endif
return 0;
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct GParams params;
struct Map_info Map;
struct Map_info **BgMap; /* backgroud vector maps */
int nbgmaps; /* number of registrated background maps */
enum mode action_mode;
FILE *ascii;
int i;
int move_first, snap;
int ret, layer;
double move_x, move_y, move_z, thresh[3];
struct line_pnts *coord;
struct ilist *List;
struct cat_list *Clist;
ascii = NULL;
List = NULL;
BgMap = NULL;
nbgmaps = 0;
coord = NULL;
Clist = NULL;
G_gisinit(argv[0]);
module = G_define_module();
module->overwrite = TRUE;
G_add_keyword(_("vector"));
G_add_keyword(_("editing"));
G_add_keyword(_("geometry"));
module->description = _("Edits a vector map, allows adding, deleting "
"and modifying selected vector features.");
if (!parser(argc, argv, ¶ms, &action_mode))
exit(EXIT_FAILURE);
/* get list of categories */
Clist = Vect_new_cat_list();
if (params.cat->answer && Vect_str_to_cat_list(params.cat->answer, Clist)) {
G_fatal_error(_("Unable to get category list <%s>"),
params.cat->answer);
}
/* open input file */
if (params.in->answer) {
if (strcmp(params.in->answer, "-") != 0) {
ascii = fopen(params.in->answer, "r");
if (ascii == NULL)
G_fatal_error(_("Unable to open file <%s>"),
params.in->answer);
}
else {
ascii = stdin;
}
}
if (!ascii && action_mode == MODE_ADD)
G_fatal_error(_("Required parameter <%s> not set"), params.in->key);
if (action_mode == MODE_CREATE) {
int overwrite;
overwrite = G_check_overwrite(argc, argv);
if (G_find_vector2(params.map->answer, G_mapset())) {
if (!overwrite)
G_fatal_error(_("Vector map <%s> already exists"),
params.map->answer);
}
/* 3D vector maps? */
ret = Vect_open_new(&Map, params.map->answer, WITHOUT_Z);
if (Vect_maptype(&Map) == GV_FORMAT_OGR_DIRECT) {
int type;
type = Vect_option_to_types(params.type);
if (type != GV_POINT && type != GV_LINE &&
type != GV_BOUNDARY)
G_fatal_error(_("Supported feature type for OGR layer: "
"%s, %s or %s"), "point", "line", "boundary");
V2_open_new_ogr(&Map, type);
}
if (ret == -1) {
G_fatal_error(_("Unable to create vector map <%s>"),
params.map->answer);
}
G_debug(1, "Map created");
if (ascii) {
/* also add new vector features */
action_mode = MODE_ADD;
}
}
else { /* open selected vector file */
if (action_mode == MODE_ADD) /* write */
ret = Vect_open_update2(&Map, params.map->answer, G_mapset(), params.fld->answer);
else /* read-only -- select features */
ret = Vect_open_old2(&Map, params.map->answer, G_mapset(), params.fld->answer);
if (ret < 2)
G_fatal_error(_("Unable to open vector map <%s> at topological level %d"),
params.map->answer, 2);
}
G_debug(1, "Map opened");
/* open backgroud maps */
if (params.bmaps->answer) {
i = 0;
while (params.bmaps->answers[i]) {
const char *bmap = params.bmaps->answers[i];
const char *mapset = G_find_vector2(bmap, "");
if (!mapset)
G_fatal_error(_("Vector map <%s> not found"), bmap);
if (strcmp(
G_fully_qualified_name(params.map->answer, G_mapset()),
G_fully_qualified_name(bmap, mapset)) == 0) {
G_fatal_error(_("Unable to open vector map <%s> as the background map. "
"It is given as vector map to be edited."),
bmap);
}
nbgmaps++;
BgMap = (struct Map_info **)G_realloc(
BgMap, nbgmaps * sizeof(struct Map_info *));
BgMap[nbgmaps - 1] =
(struct Map_info *)G_malloc(sizeof(struct Map_info));
if (Vect_open_old(BgMap[nbgmaps - 1], bmap, "") == -1)
G_fatal_error(_("Unable to open vector map <%s>"), bmap);
G_verbose_message(_("Background vector map <%s> registered"), bmap);
i++;
}
}
layer = Vect_get_field_number(&Map, params.fld->answer);
i = 0;
while (params.maxdist->answers[i]) {
switch (i) {
case THRESH_COORDS:
thresh[THRESH_COORDS] =
max_distance(atof(params.maxdist->answers[THRESH_COORDS]));
thresh[THRESH_SNAP] = thresh[THRESH_QUERY] =
thresh[THRESH_COORDS];
break;
case THRESH_SNAP:
thresh[THRESH_SNAP] =
max_distance(atof(params.maxdist->answers[THRESH_SNAP]));
break;
case THRESH_QUERY:
thresh[THRESH_QUERY] =
atof(params.maxdist->answers[THRESH_QUERY]);
break;
default:
break;
}
i++;
}
move_first = params.move_first->answer ? 1 : 0;
snap = NO_SNAP;
if (strcmp(params.snap->answer, "node") == 0)
snap = SNAP;
else if (strcmp(params.snap->answer, "vertex") == 0)
snap = SNAPVERTEX;
if (snap != NO_SNAP && thresh[THRESH_SNAP] <= 0) {
G_warning(_("Threshold for snapping must be > 0. No snapping applied."));
snap = NO_SNAP;
}
if (action_mode != MODE_CREATE && action_mode != MODE_ADD) {
/* select lines */
List = Vect_new_list();
G_message(_("Selecting features..."));
if (action_mode == MODE_COPY && BgMap && BgMap[0]) {
List = select_lines(BgMap[0], action_mode, ¶ms, thresh, List);
}
else {
List = select_lines(&Map, action_mode, ¶ms, thresh, List);
}
}
if ((action_mode != MODE_CREATE && action_mode != MODE_ADD &&
action_mode != MODE_SELECT)) {
if (List->n_values < 1) {
G_warning(_("No features selected, nothing to edit"));
action_mode = MODE_NONE;
ret = 0;
}
else {
/* reopen the map for updating */
if (action_mode == MODE_ZBULK && !Vect_is_3d(&Map)) {
Vect_close(&Map);
G_fatal_error(_("Vector map <%s> is not 3D. Tool '%s' requires 3D vector map. "
"Please convert the vector map "
"to 3D using e.g. %s."), params.map->answer,
params.tool->answer, "v.extrude");
}
Vect_close(&Map);
Vect_open_update2(&Map, params.map->answer, G_mapset(), params.fld->answer);
}
}
/* coords option -> array */
if (params.coord->answers) {
coord = Vect_new_line_struct();
int i = 0;
double east, north;
while (params.coord->answers[i]) {
east = atof(params.coord->answers[i]);
north = atof(params.coord->answers[i + 1]);
Vect_append_point(coord, east, north, 0.0);
i += 2;
}
}
/* perform requested editation */
switch (action_mode) {
case MODE_CREATE:
break;
case MODE_ADD:
if (!params.header->answer)
Vect_read_ascii_head(ascii, &Map);
int num_lines;
num_lines = Vect_get_num_lines(&Map);
ret = Vect_read_ascii(ascii, &Map);
G_message(_("%d features added"), ret);
if (ret > 0) {
int iline;
struct ilist *List_added;
List_added = Vect_new_list();
for (iline = num_lines + 1; iline <= Vect_get_num_lines(&Map); iline++)
Vect_list_append(List_added, iline);
G_verbose_message(_("Threshold value for snapping is %.2f"),
thresh[THRESH_SNAP]);
if (snap != NO_SNAP) { /* apply snapping */
/* snap to vertex ? */
Vedit_snap_lines(&Map, BgMap, nbgmaps, List_added,
thresh[THRESH_SNAP],
snap == SNAP ? FALSE : TRUE);
}
if (params.close->answer) { /* close boundaries */
int nclosed;
nclosed = close_lines(&Map, GV_BOUNDARY, thresh[THRESH_SNAP]);
G_message(_("%d boundaries closed"), nclosed);
}
Vect_destroy_list(List_added);
}
break;
case MODE_DEL:
ret = Vedit_delete_lines(&Map, List);
G_message(_("%d features deleted"), ret);
break;
case MODE_MOVE:
move_x = atof(params.move->answers[0]);
move_y = atof(params.move->answers[1]);
move_z = atof(params.move->answers[2]);
G_verbose_message(_("Threshold value for snapping is %.2f"),
thresh[THRESH_SNAP]);
ret = Vedit_move_lines(&Map, BgMap, nbgmaps, List, move_x, move_y, move_z, snap, thresh[THRESH_SNAP]);
G_message(_("%d features moved"), ret);
break;
case MODE_VERTEX_MOVE:
move_x = atof(params.move->answers[0]);
move_y = atof(params.move->answers[1]);
move_z = atof(params.move->answers[2]);
G_verbose_message(_("Threshold value for snapping is %.2f"),
thresh[THRESH_SNAP]);
ret = Vedit_move_vertex(&Map, BgMap, nbgmaps, List, coord, thresh[THRESH_COORDS], thresh[THRESH_SNAP], move_x, move_y, move_z, move_first, snap);
G_message(_("%d vertices moved"), ret);
break;
case MODE_VERTEX_ADD:
ret = Vedit_add_vertex(&Map, List, coord, thresh[THRESH_COORDS]);
G_message(_("%d vertices added"), ret);
break;
case MODE_VERTEX_DELETE:
ret = Vedit_remove_vertex(&Map, List, coord, thresh[THRESH_COORDS]);
G_message(_("%d vertices removed"), ret);
break;
case MODE_BREAK:
if (params.coord->answer) {
ret = Vedit_split_lines(&Map, List,
coord, thresh[THRESH_COORDS], NULL);
}
else {
ret = Vect_break_lines_list(&Map, List, NULL, GV_LINES, NULL);
}
G_message(_("%d lines broken"), ret);
break;
case MODE_CONNECT:
G_verbose_message(_("Threshold value for snapping is %.2f"),
thresh[THRESH_SNAP]);
ret = Vedit_connect_lines(&Map, List, thresh[THRESH_SNAP]);
G_message(_("%d lines connected"), ret);
break;
case MODE_MERGE:
ret = Vedit_merge_lines(&Map, List);
G_message(_("%d lines merged"), ret);
break;
case MODE_SELECT:
ret = print_selected(List);
break;
case MODE_CATADD:
ret = Vedit_modify_cats(&Map, List, layer, 0, Clist);
G_message(_("%d features modified"), ret);
break;
case MODE_CATDEL:
ret = Vedit_modify_cats(&Map, List, layer, 1, Clist);
G_message(_("%d features modified"), ret);
break;
case MODE_COPY:
if (BgMap && BgMap[0]) {
if (nbgmaps > 1)
G_warning(_("Multiple background maps were given. "
"Selected features will be copied only from "
"vector map <%s>."),
Vect_get_full_name(BgMap[0]));
ret = Vedit_copy_lines(&Map, BgMap[0], List);
}
else {
ret = Vedit_copy_lines(&Map, NULL, List);
}
G_message(_("%d features copied"), ret);
break;
case MODE_SNAP:
G_verbose_message(_("Threshold value for snapping is %.2f"),
thresh[THRESH_SNAP]);
ret = snap_lines(&Map, List, thresh[THRESH_SNAP]);
break;
case MODE_FLIP:
ret = Vedit_flip_lines(&Map, List);
G_message(_("%d lines flipped"), ret);
break;
case MODE_NONE:
break;
case MODE_ZBULK:{
double start, step;
double x1, y1, x2, y2;
start = atof(params.zbulk->answers[0]);
step = atof(params.zbulk->answers[1]);
x1 = atof(params.bbox->answers[0]);
y1 = atof(params.bbox->answers[1]);
x2 = atof(params.bbox->answers[2]);
y2 = atof(params.bbox->answers[3]);
ret = Vedit_bulk_labeling(&Map, List,
x1, y1, x2, y2, start, step);
G_message(_("%d lines labeled"), ret);
break;
}
case MODE_CHTYPE:{
ret = Vedit_chtype_lines(&Map, List);
if (ret > 0) {
G_message(_("%d features converted"), ret);
}
else {
G_message(_("No feature modified"));
}
break;
}
default:
G_warning(_("Operation not implemented"));
ret = -1;
break;
}
Vect_hist_command(&Map);
/* build topology only if requested or if tool!=select */
if (!(action_mode == MODE_SELECT || params.topo->answer == 1 ||
!MODE_NONE)) {
Vect_build_partial(&Map, GV_BUILD_NONE);
Vect_build(&Map);
}
if (List)
Vect_destroy_list(List);
Vect_close(&Map);
G_debug(1, "Map closed");
/* close background maps */
for (i = 0; i < nbgmaps; i++) {
Vect_close(BgMap[i]);
G_free((void *)BgMap[i]);
}
G_free((void *)BgMap);
if (coord)
Vect_destroy_line_struct(coord);
if (Clist)
Vect_destroy_cat_list(Clist);
G_done_msg(" ");
if (ret > -1) {
exit(EXIT_SUCCESS);
}
else {
exit(EXIT_FAILURE);
}
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct Map_info Map;
FILE *ascii, *att;
char *input, *output, *delim, **columns, *where, *field_name, *cats;
int format, dp, field, ret, region, old_format, header, type;
int ver, pnt;
struct cat_list *clist;
clist = NULL;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("export"));
G_add_keyword("ASCII");
module->label =
_("Exports a vector map to a GRASS ASCII vector representation.");
module->description = _("By default only features with category are exported. "
"To export all features use 'layer=-1'.");
parse_args(argc, argv, &input, &output, &format, &dp, &delim,
&field_name, &columns, &where, ®ion, &old_format, &header,
&cats, &type);
if (format == GV_ASCII_FORMAT_STD && columns) {
G_warning(_("Parameter '%s' ignored in standard mode"), "column");
}
ver = 5;
pnt = 0;
if (old_format)
ver = 4;
if (ver == 4 && format == GV_ASCII_FORMAT_POINT) {
G_fatal_error(_("Format '%s' is not supported for old version"), "point");
}
if (ver == 4 && strcmp(output, "-") == 0) {
G_fatal_error(_("Parameter '%s' must be given for old version"), "output");
}
/* open with topology only if needed */
if (format == GV_ASCII_FORMAT_WKT ||
(format == GV_ASCII_FORMAT_STD && (where || clist))) {
if (Vect_open_old2(&Map, input, "", field_name) < 2) /* topology required for areas */
G_warning(_("Unable to open vector map <%s> at topology level. "
"Areas will not be processed."),
input);
}
else {
Vect_set_open_level(1); /* topology not needed */
if (Vect_open_old2(&Map, input, "", field_name) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), input);
if (Vect_maptype(&Map) != GV_FORMAT_NATIVE) {
/* require topological level for external formats
centroids are read from topo */
Vect_close(&Map);
Vect_set_open_level(2);
if (Vect_open_old2(&Map, input, "", field_name) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), input);
}
}
field = Vect_get_field_number(&Map, field_name);
if (cats) {
clist = Vect_new_cat_list();
clist->field = field;
if (clist->field < 1)
G_fatal_error(_("Layer <%s> not found"), field_name);
ret = Vect_str_to_cat_list(cats, clist);
if (ret > 0)
G_fatal_error(_n("%d error in <%s> option",
"%d errors in <%s> option",
ret),
ret, "cats");
}
if (strcmp(output, "-") != 0) {
if (ver == 4) {
ascii = G_fopen_new("dig_ascii", output);
}
else if (strcmp(output, "-") == 0) {
ascii = stdout;
}
else {
ascii = fopen(output, "w");
}
if (ascii == NULL) {
G_fatal_error(_("Unable to open file <%s>"), output);
}
}
else {
ascii = stdout;
}
if (format == GV_ASCII_FORMAT_STD) {
Vect_write_ascii_head(ascii, &Map);
fprintf(ascii, "VERTI:\n");
}
/* Open dig_att */
att = NULL;
if (ver == 4 && !pnt) {
if (G_find_file("dig_att", output, G_mapset()) != NULL)
G_fatal_error(_("dig_att file already exist"));
if ((att = G_fopen_new("dig_att", output)) == NULL)
G_fatal_error(_("Unable to open dig_att file <%s>"),
output);
}
if (where || columns || clist)
G_message(_("Fetching data..."));
ret = Vect_write_ascii(ascii, att, &Map, ver, format, dp, delim,
region, type, field, clist, (const char *)where,
(const char **)columns, header);
if (ret < 1) {
if (format == GV_ASCII_FORMAT_POINT) {
G_warning(_("No points found, nothing to be exported"));
}
else {
G_warning(_("No features found, nothing to be exported"));
}
}
if (ascii != NULL)
fclose(ascii);
if (att != NULL)
fclose(att);
Vect_close(&Map);
if (cats)
Vect_destroy_cat_list(clist);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int npmin;
int ii;
double x_orig, y_orig, dnorm, deltx, delty, xm, ym;
char dmaxchar[200];
char dminchar[200];
struct quaddata *data;
struct multfunc *functions;
struct multtree *tree;
int open_check, with_z;
char buf[1024];
struct GModule *module;
struct
{
struct Option *input, *field, *zcol, *wheresql, *scol, *elev, *slope,
*aspect, *pcurv, *tcurv, *mcurv, *treefile, *overfile, *maskmap,
*dmin, *dmax, *zmult, *fi, *rsm, *segmax, *npmin, *cvdev, *devi,
*theta, *scalex;
} parm;
struct
{
struct Flag *deriv, *cprght, *cv;
} flag;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("surface"));
G_add_keyword(_("interpolation"));
G_add_keyword(_("3D"));
module->label = _("Performs surface interpolation from vector points map by splines.");
module->description =
_("Spatial approximation and topographic analysis from given "
"point or isoline data in vector format to floating point "
"raster format using regularized spline with tension.");
flag.cv = G_define_flag();
flag.cv->key = 'c';
flag.cv->description =
_("Perform cross-validation procedure without raster approximation");
flag.cv->guisection = _("Parameters");
flag.cprght = G_define_flag();
flag.cprght->key = 't';
flag.cprght->description = _("Use scale dependent tension");
flag.cprght->guisection = _("Parameters");
flag.deriv = G_define_flag();
flag.deriv->key = 'd';
flag.deriv->description =
_("Output partial derivatives instead of topographic parameters");
flag.deriv->guisection = _("Outputs");
parm.input = G_define_standard_option(G_OPT_V_INPUT);
parm.field = G_define_standard_option(G_OPT_V_FIELD);
parm.field->answer = "1";
parm.field->guisection = _("Selection");
parm.zcol = G_define_standard_option(G_OPT_DB_COLUMN);
parm.zcol->key = "zcolumn";
parm.zcol->required = NO;
parm.zcol->label =
_("Name of the attribute column with values to be used for approximation");
parm.zcol->description = _("If not given and input is 2D vector map then category values are used. "
"If input is 3D vector map then z-coordinates are used.");
parm.zcol->guisection = _("Parameters");
parm.wheresql = G_define_standard_option(G_OPT_DB_WHERE);
parm.wheresql->guisection = _("Selection");
parm.elev = G_define_standard_option(G_OPT_R_OUTPUT);
parm.elev->key = "elevation";
parm.elev->required = NO;
parm.elev->description = _("Name for output surface elevation raster map");
parm.elev->guisection = _("Outputs");
parm.slope = G_define_standard_option(G_OPT_R_OUTPUT);
parm.slope->key = "slope";
parm.slope->required = NO;
parm.slope->description = _("Name for output slope raster map");
parm.slope->guisection = _("Outputs");
parm.aspect = G_define_standard_option(G_OPT_R_OUTPUT);
parm.aspect->key = "aspect";
parm.aspect->required = NO;
parm.aspect->description = _("Name for output aspect raster map");
parm.aspect->guisection = _("Outputs");
parm.pcurv = G_define_standard_option(G_OPT_R_OUTPUT);
parm.pcurv->key = "pcurvature";
parm.pcurv->required = NO;
parm.pcurv->description = _("Name for output profile curvature raster map");
parm.pcurv->guisection = _("Outputs");
parm.tcurv = G_define_standard_option(G_OPT_R_OUTPUT);
parm.tcurv->key = "tcurvature";
parm.tcurv->required = NO;
parm.tcurv->description = _("Name for output tangential curvature raster map");
parm.tcurv->guisection = _("Outputs");
parm.mcurv = G_define_standard_option(G_OPT_R_OUTPUT);
parm.mcurv->key = "mcurvature";
parm.mcurv->required = NO;
parm.mcurv->description = _("Name for output mean curvature raster map");
parm.mcurv->guisection = _("Outputs");
parm.devi = G_define_standard_option(G_OPT_V_OUTPUT);
parm.devi->key = "deviations";
parm.devi->required = NO;
parm.devi->description = _("Name for output deviations vector point map");
parm.devi->guisection = _("Outputs");
parm.cvdev = G_define_standard_option(G_OPT_V_OUTPUT);
parm.cvdev->key = "cvdev";
parm.cvdev->required = NO;
parm.cvdev->description =
_("Name for output cross-validation errors vector point map");
parm.cvdev->guisection = _("Outputs");
parm.treefile = G_define_standard_option(G_OPT_V_OUTPUT);
parm.treefile->key = "treeseg";
parm.treefile->required = NO;
parm.treefile->description =
_("Name for output vector map showing quadtree segmentation");
parm.treefile->guisection = _("Outputs");
parm.overfile = G_define_standard_option(G_OPT_V_OUTPUT);
parm.overfile->key = "overwin";
parm.overfile->required = NO;
parm.overfile->description =
_("Name for output vector map showing overlapping windows");
parm.overfile->guisection = _("Outputs");
parm.maskmap = G_define_standard_option(G_OPT_R_INPUT);
parm.maskmap->key = "mask";
parm.maskmap->required = NO;
parm.maskmap->description = _("Name of raster map used as mask");
parm.maskmap->guisection = _("Parameters");
parm.fi = G_define_option();
parm.fi->key = "tension";
parm.fi->type = TYPE_DOUBLE;
parm.fi->answer = TENSION;
parm.fi->required = NO;
parm.fi->description = _("Tension parameter");
parm.fi->guisection = _("Parameters");
parm.rsm = G_define_option();
parm.rsm->key = "smooth";
parm.rsm->type = TYPE_DOUBLE;
parm.rsm->required = NO;
parm.rsm->description = _("Smoothing parameter");
parm.rsm->guisection = _("Parameters");
parm.scol = G_define_option();
parm.scol->key = "smooth_column";
parm.scol->type = TYPE_STRING;
parm.scol->required = NO;
parm.scol->description =
_("Name of the attribute column with smoothing parameters");
parm.scol->guisection = _("Parameters");
parm.segmax = G_define_option();
parm.segmax->key = "segmax";
parm.segmax->type = TYPE_INTEGER;
parm.segmax->answer = MAXSEGM;
parm.segmax->required = NO;
parm.segmax->description = _("Maximum number of points in a segment");
parm.segmax->guisection = _("Parameters");
parm.npmin = G_define_option();
parm.npmin->key = "npmin";
parm.npmin->type = TYPE_INTEGER;
parm.npmin->answer = MINPOINTS;
parm.npmin->required = NO;
parm.npmin->description =
_("Minimum number of points for approximation in a segment (>segmax)");
parm.npmin->guisection = _("Parameters");
parm.dmin = G_define_option();
parm.dmin->key = "dmin";
parm.dmin->type = TYPE_DOUBLE;
parm.dmin->required = NO;
parm.dmin->description =
_("Minimum distance between points (to remove almost identical points)");
parm.dmin->guisection = _("Parameters");
parm.dmax = G_define_option();
parm.dmax->key = "dmax";
parm.dmax->type = TYPE_DOUBLE;
parm.dmax->required = NO;
parm.dmax->description =
_("Maximum distance between points on isoline (to insert additional points)");
parm.dmax->guisection = _("Parameters");
parm.zmult = G_define_option();
parm.zmult->key = "zscale";
parm.zmult->type = TYPE_DOUBLE;
parm.zmult->answer = ZMULT;
parm.zmult->required = NO;
parm.zmult->description =
_("Conversion factor for values used for approximation");
parm.zmult->guisection = _("Parameters");
parm.theta = G_define_option();
parm.theta->key = "theta";
parm.theta->type = TYPE_DOUBLE;
parm.theta->required = NO;
parm.theta->description =
_("Anisotropy angle (in degrees counterclockwise from East)");
parm.theta->guisection = _("Parameters");
parm.scalex = G_define_option();
parm.scalex->key = "scalex";
parm.scalex->type = TYPE_DOUBLE;
parm.scalex->required = NO;
parm.scalex->description = _("Anisotropy scaling factor");
parm.scalex->guisection = _("Parameters");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
G_get_set_window(&cellhd);
ew_res = cellhd.ew_res;
ns_res = cellhd.ns_res;
n_cols = cellhd.cols;
n_rows = cellhd.rows;
x_orig = cellhd.west;
y_orig = cellhd.south;
xm = cellhd.east;
ym = cellhd.north;
if (ew_res < ns_res)
dmin = ew_res / 2;
else
dmin = ns_res / 2;
disk = n_rows * n_cols * sizeof(int);
sdisk = n_rows * n_cols * sizeof(short int);
sprintf(dmaxchar, "%f", dmin * 5);
sprintf(dminchar, "%f", dmin);
if (!parm.dmin->answer) {
parm.dmin->answer = G_store(dminchar);
parm.dmin->answers = (char **) G_malloc(2 * sizeof(char *));
parm.dmin->answers[0] = G_store(dminchar);
parm.dmin->answers[1] = NULL;
}
if (!parm.dmax->answer) {
parm.dmax->answer = G_store(dmaxchar);
parm.dmax->answers = (char **) G_malloc(2 * sizeof(char *));
parm.dmax->answers[0] = G_store(dmaxchar);
parm.dmax->answers[1] = NULL;
}
input = parm.input->answer;
zcol = parm.zcol->answer;
scol = parm.scol->answer;
wheresql = parm.wheresql->answer;
maskmap = parm.maskmap->answer;
elev = parm.elev->answer;
devi = parm.devi->answer;
cvdev = parm.cvdev->answer;
slope = parm.slope->answer;
aspect = parm.aspect->answer;
pcurv = parm.pcurv->answer;
tcurv = parm.tcurv->answer;
mcurv = parm.mcurv->answer;
treefile = parm.treefile->answer;
overfile = parm.overfile->answer;
if (devi) {
if (Vect_legal_filename(devi) == -1)
G_fatal_error(_("Output vector map name <%s> is not valid map name"),
devi);
}
if (cvdev) {
if (Vect_legal_filename(cvdev) == -1)
G_fatal_error(_("Output vector map name <%s> is not valid map name"),
cvdev);
}
if (treefile) {
if (Vect_legal_filename(treefile) == -1)
G_fatal_error(_("Output vector map name <%s> is not valid map name"),
treefile);
}
if (overfile) {
if (Vect_legal_filename(overfile) == -1)
G_fatal_error(_("Output vector map name <%s> is not valid map name"),
overfile);
}
/* if (treefile)
Vect_check_input_output_name(input, treefile, G_FATAL_EXIT);
if (overfile)
Vect_check_input_output_name(input, overfile, G_FATAL_EXIT);
*/
if ((elev == NULL) && (pcurv == NULL) && (tcurv == NULL)
&& (mcurv == NULL)
&& (slope == NULL) && (aspect == NULL) && (devi == NULL)
&& (cvdev == NULL))
G_warning(_("You are not outputting any raster or vector maps"));
cond2 = ((pcurv != NULL) || (tcurv != NULL) || (mcurv != NULL));
cond1 = ((slope != NULL) || (aspect != NULL) || cond2);
deriv = flag.deriv->answer;
dtens = flag.cprght->answer;
cv = flag.cv->answer;
if ((cv && cvdev == NULL) || (!(cv) && cvdev != NULL))
G_fatal_error(_("Both cross-validation options (-c flag and cvdev vector output) must be specified"));
if ((elev != NULL || cond1 || cond2 || devi != NULL) && cv)
G_fatal_error(_("The cross-validation cannot be computed simultaneously with output raster or devi file"));
ertre = 0.1;
sscanf(parm.dmax->answer, "%lf", &dmax);
sscanf(parm.dmin->answer, "%lf", &dmin);
sscanf(parm.fi->answer, "%lf", &fi);
sscanf(parm.segmax->answer, "%d", &KMAX);
sscanf(parm.npmin->answer, "%d", &npmin);
sscanf(parm.zmult->answer, "%lf", &zmult);
/* if (fi=0.000000) G_fatal_error("Tension must be > 0.000000") */
if (parm.theta->answer)
sscanf(parm.theta->answer, "%lf", &theta);
if (parm.scalex->answer) {
sscanf(parm.scalex->answer, "%lf", &scalex);
if (!parm.theta->answer)
G_fatal_error(_("Using anisotropy - both theta and scalex have to be specified"));
}
if (parm.rsm->answer) {
sscanf(parm.rsm->answer, "%lf", &rsm);
if (rsm < 0.0)
G_fatal_error("Smoothing must be a positive value");
if (scol != NULL)
G_warning(_("Both smatt and smooth options specified - using constant"));
}
else {
sscanf(SMOOTH, "%lf", &rsm);
if (scol != NULL)
rsm = -1; /* used in InterpLib to indicate variable smoothing */
}
if (npmin > MAXPOINTS - 50) {
G_warning(_("The computation will last too long - lower npmin is suggested"));
KMAX2 = 2 * npmin; /* was: KMAX2 = npmin + 50; */
}
else
KMAX2 = 2 * npmin; /* was: KMAX2 = MAXPOINTS; fixed by JH in 12/01 */
/* handling of KMAX2 in GRASS4 v.surf.rst
if (npmin > MAXPOINTS - 50)
KMAX2 = npmin + 50;
else
KMAX2 = MAXPOINTS;
*/
dmin = dmin * dmin;
KMIN = npmin;
az = G_alloc_vector(n_cols + 1);
if (!az) {
G_fatal_error(_("Not enough memory for %s"), "az");
}
if (cond1) {
adx = G_alloc_vector(n_cols + 1);
if (!adx) {
G_fatal_error(_("Not enough memory for %s"), "adx");
}
ady = G_alloc_vector(n_cols + 1);
if (!ady) {
G_fatal_error(_("Not enough memory for %s"), "ady");
}
if (cond2) {
adxx = G_alloc_vector(n_cols + 1);
if (!adxx) {
G_fatal_error(_("Not enough memory for %s"), "adxx");
}
adyy = G_alloc_vector(n_cols + 1);
if (!adyy) {
G_fatal_error(_("Not enough memory for %s"), "adyy");
}
adxy = G_alloc_vector(n_cols + 1);
if (!adxy) {
G_fatal_error(_("Not enough memory for %s"), "adxy");
}
}
}
if ((data =
quad_data_new(x_orig, y_orig, xm, ym, n_rows, n_cols, 0,
KMAX)) == NULL)
G_fatal_error(_("Unable to create %s"), "quaddata");
if ((functions =
MT_functions_new(quad_compare, quad_divide_data, quad_add_data,
quad_intersect, quad_division_check,
quad_get_points)) == NULL)
G_fatal_error(_("Unable to create %s"), "quadfunc");
if ((tree = MT_tree_new(data, NULL, NULL, 0)) == NULL)
G_fatal_error(_("Unable to create %s"), "tree");
root = tree;
if ((info = MT_tree_info_new(root, functions, dmin, KMAX)) == NULL)
G_fatal_error(_("Unable to create %s"), "tree info");
open_check = Vect_open_old2(&Map, input, "", parm.field->answer);
if (open_check < 1)
G_fatal_error(_("Unable to open vector map <%s>"), input);
/* if (open_check < 2)
G_fatal_error(_("You first need to run v.build on vector map <%s>"), input);
*/
/* get value used for approximation */
with_z = !parm.zcol->answer && Vect_is_3d(&Map);
field = Vect_get_field_number(&Map, parm.field->answer);
if (!with_z && field < 1)
G_fatal_error(_("Layer <%s> not found"), parm.field->answer);
if (Vect_is_3d(&Map)) {
if (!with_z)
G_verbose_message(_("Input is 3D: using attribute values instead of z-coordinates for approximation"));
else
G_verbose_message(_("Input is 3D: using z-coordinates for approximation"));
}
else { /* 2D */
if (parm.zcol->answer)
G_verbose_message(_("Input is 2D: using attribute values for approximation"));
else
G_verbose_message(_("Input is 2D: using category values for approximation"));
}
/* we can't read the input file's timestamp as they don't exist in */
/* the new vector format. Even so, a TimeStamp structure is needed */
/* for IL_init_params_2d(), so we set it to NULL. */
/* If anyone is ever motivated to add it, the Plus_head struct has */
/* 'long coor_mtime' and dig_head has 'char *date; char *source_date;' */
/* which could be read in. */
if (devi != NULL || cvdev != NULL) {
Pnts = Vect_new_line_struct();
Cats2 = Vect_new_cats_struct();
db_init_string(&sql2);
if (devi != NULL) {
if (Vect_open_new(&Map2, devi, 1) < 0)
G_fatal_error(_("Unable to create vector map <%s>"), devi);
} else {
if (Vect_open_new(&Map2, cvdev, 1) < 0)
G_fatal_error(_("Unable to create vector map <%s>"), cvdev);
}
Vect_hist_command(&Map2);
ff = Vect_default_field_info(&Map2, 1, NULL, GV_1TABLE);
Vect_map_add_dblink(&Map2, 1, NULL, ff->table, GV_KEY_COLUMN, ff->database,
ff->driver);
/* Create new table */
db_zero_string(&sql2);
sprintf(buf, "create table %s ( ", ff->table);
db_append_string(&sql2, buf);
db_append_string(&sql2, "cat integer");
db_append_string(&sql2, ", flt1 double precision");
db_append_string(&sql2, ")");
G_debug(1, "%s", db_get_string(&sql2));
driver2 = db_start_driver_open_database(ff->driver, ff->database);
if (driver2 == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
ff->database, ff->driver);
db_set_error_handler_driver(driver2);
if (db_execute_immediate(driver2, &sql2) != DB_OK) {
G_fatal_error(_("Unable to create table '%s'"),
db_get_string(&sql2));
}
db_begin_transaction(driver2);
count = 1;
}
ertot = 0.;
create_temp_files();
IL_init_params_2d(¶ms, NULL, 1, 1, zmult, KMIN, KMAX, maskmap, n_rows,
n_cols, az, adx, ady, adxx, adyy, adxy, fi, KMAX2,
SCIK1, SCIK2, SCIK3, rsm, elev, slope, aspect, pcurv,
tcurv, mcurv, dmin, x_orig, y_orig, deriv, theta,
scalex, Tmp_fd_z, Tmp_fd_dx, Tmp_fd_dy, Tmp_fd_xx,
Tmp_fd_yy, Tmp_fd_xy, devi, NULL, cv,
parm.wheresql->answer);
IL_init_func_2d(¶ms, IL_grid_calc_2d, IL_matrix_create,
IL_check_at_points_2d, IL_secpar_loop_2d, IL_crst,
IL_crstg, IL_write_temp_2d);
totsegm =
IL_vector_input_data_2d(¶ms, &Map, with_z ? 0 : field,
zcol, scol,
info, &xmin, &xmax,
&ymin, &ymax, &zmin, &zmax, &NPOINT, &dmax);
if (totsegm <= 0) {
clean();
G_fatal_error(_("Input failed"));
}
/*Vect_set_release_support(&Map); */
Vect_close(&Map);
if (treefile != NULL) {
if (0 > Vect_open_new(&TreeMap, treefile, 0)) {
clean();
G_fatal_error(_("Unable to open vector map <%s>"), treefile);
}
Vect_hist_command(&TreeMap);
/*
sprintf (TreeMap.head.your_name, "grass");
sprintf (TreeMap.head.map_name, "Quad tree for %s", input);
TreeMap.head.orig_scale = 100000;
TreeMap.head.plani_zone = G_zone ();
*/
print_tree(root, x_orig, y_orig, &TreeMap);
Vect_build(&TreeMap);
Vect_close(&TreeMap);
}
disk = disk + totsegm * sizeof(int) * 4;
sdisk = sdisk + totsegm * sizeof(int) * 4;
if (elev != NULL)
ddisk += disk;
if (slope != NULL)
sddisk += sdisk;
if (aspect != NULL)
sddisk += sdisk;
if (pcurv != NULL)
ddisk += disk;
if (tcurv != NULL)
ddisk += disk;
if (mcurv != NULL)
ddisk += disk;
ddisk += sddisk;
G_verbose_message(_("Processing all selected output files "
"will require %d bytes of disk space for temp files"), ddisk);
deltx = xmax - xmin;
delty = ymax - ymin;
dnorm = sqrt((deltx * delty * KMIN) / NPOINT);
if (dtens) {
params.fi = params.fi * dnorm / 1000.;
G_verbose_message("dnorm = %f, rescaled tension = %f", dnorm, params.fi);
}
bitmask = IL_create_bitmask(¶ms);
if (totsegm <= 0) {
clean();
G_fatal_error(_("Input failed"));
}
ertot = 0.;
G_message(_("Processing segments..."));
if (IL_interp_segments_2d(¶ms, info, info->root, bitmask,
zmin, zmax, &zminac, &zmaxac, &gmin, &gmax,
&c1min, &c1max, &c2min, &c2max, &ertot, totsegm,
n_cols, dnorm) < 0) {
clean();
G_fatal_error(_("Interp_segmets failed"));
}
G_free_vector(az);
if (cond1) {
G_free_vector(adx);
G_free_vector(ady);
if (cond2) {
G_free_vector(adxx);
G_free_vector(adyy);
G_free_vector(adxy);
}
}
ii = IL_output_2d(¶ms, &cellhd, zmin, zmax, zminac, zmaxac, c1min,
c1max, c2min, c2max, gmin, gmax, ertot, input, dnorm,
dtens, 1, NPOINT);
if (ii < 0) {
clean();
G_fatal_error(_("Unable to write raster maps - try to increase resolution"));
}
G_free(zero_array_cell);
if (elev != NULL)
fclose(Tmp_fd_z);
if (slope != NULL)
fclose(Tmp_fd_dx);
if (aspect != NULL)
fclose(Tmp_fd_dy);
if (pcurv != NULL)
fclose(Tmp_fd_xx);
if (tcurv != NULL)
fclose(Tmp_fd_yy);
if (mcurv != NULL)
fclose(Tmp_fd_xy);
if (overfile != NULL) {
if (0 > Vect_open_new(&OverMap, overfile, 0)) {
clean();
G_fatal_error(_("Unable to create vector map <%s>"), overfile);
}
Vect_hist_command(&OverMap);
/*
sprintf (OverMap.head.your_name, "grass");
sprintf (OverMap.head.map_name, "Overlap segments for %s", input);
OverMap.head.orig_scale = 100000;
OverMap.head.plani_zone = G_zone ();
*/
print_tree(root, x_orig, y_orig, &OverMap);
Vect_build(&OverMap);
Vect_close(&OverMap);
}
if (elev != NULL)
unlink(Tmp_file_z);
if (slope != NULL)
unlink(Tmp_file_dx);
if (aspect != NULL)
unlink(Tmp_file_dy);
if (pcurv != NULL)
unlink(Tmp_file_xx);
if (tcurv != NULL)
unlink(Tmp_file_yy);
if (mcurv != NULL)
unlink(Tmp_file_xy);
if (cvdev != NULL || devi != NULL) {
db_commit_transaction(driver2);
db_close_database_shutdown_driver(driver2);
Vect_build(&Map2);
Vect_close(&Map2);
}
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct Map_info In, Out, Buf;
struct line_pnts *Points;
struct line_cats *Cats, *BCats;
char bufname[GNAME_MAX];
struct GModule *module;
struct Option *in_opt, *out_opt, *type_opt, *dista_opt, *distb_opt,
*angle_opt;
struct Flag *straight_flag, *nocaps_flag;
struct Option *tol_opt, *bufcol_opt, *scale_opt, *field_opt;
int verbose;
double da, db, dalpha, tolerance, unit_tolerance;
int type;
int i, ret, nareas, area, nlines, line;
char *Areas, *Lines;
int field;
struct buf_contours *arr_bc;
struct buf_contours_pts arr_bc_pts;
int buffers_count = 0, line_id;
struct spatial_index si;
struct bound_box bbox;
/* Attributes if sizecol is used */
int nrec, ctype;
struct field_info *Fi;
dbDriver *Driver;
dbCatValArray cvarr;
double size_val, scale;
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("geometry"));
G_add_keyword(_("buffer"));
module->description =
_("Creates a buffer around vector features of given type.");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
field_opt = G_define_standard_option(G_OPT_V_FIELD_ALL);
field_opt->guisection = _("Selection");
type_opt = G_define_standard_option(G_OPT_V_TYPE);
type_opt->options = "point,line,boundary,centroid,area";
type_opt->answer = "point,line,area";
type_opt->guisection = _("Selection");
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
dista_opt = G_define_option();
dista_opt->key = "distance";
dista_opt->type = TYPE_DOUBLE;
dista_opt->required = NO;
dista_opt->description =
_("Buffer distance along major axis in map units");
dista_opt->guisection = _("Distance");
distb_opt = G_define_option();
distb_opt->key = "minordistance";
distb_opt->type = TYPE_DOUBLE;
distb_opt->required = NO;
distb_opt->description =
_("Buffer distance along minor axis in map units");
distb_opt->guisection = _("Distance");
angle_opt = G_define_option();
angle_opt->key = "angle";
angle_opt->type = TYPE_DOUBLE;
angle_opt->required = NO;
angle_opt->answer = "0";
angle_opt->description = _("Angle of major axis in degrees");
angle_opt->guisection = _("Distance");
bufcol_opt = G_define_standard_option(G_OPT_DB_COLUMN);
bufcol_opt->key = "bufcolumn";
bufcol_opt->description =
_("Name of column to use for buffer distances");
bufcol_opt->guisection = _("Distance");
scale_opt = G_define_option();
scale_opt->key = "scale";
scale_opt->type = TYPE_DOUBLE;
scale_opt->required = NO;
scale_opt->answer = "1.0";
scale_opt->description = _("Scaling factor for attribute column values");
scale_opt->guisection = _("Distance");
tol_opt = G_define_option();
tol_opt->key = "tolerance";
tol_opt->type = TYPE_DOUBLE;
tol_opt->required = NO;
tol_opt->answer = "0.01";
tol_opt->description =
_("Maximum distance between theoretical arc and polygon segments as multiple of buffer");
tol_opt->guisection = _("Distance");
straight_flag = G_define_flag();
straight_flag->key = 's';
straight_flag->description = _("Make outside corners straight");
nocaps_flag = G_define_flag();
nocaps_flag->key = 'c';
nocaps_flag->description = _("Don't make caps at the ends of polylines");
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
type = Vect_option_to_types(type_opt);
if ((dista_opt->answer && bufcol_opt->answer) ||
(!(dista_opt->answer || bufcol_opt->answer)))
G_fatal_error(_("Select a buffer distance/minordistance/angle "
"or column, but not both."));
if (bufcol_opt->answer)
G_warning(_("The bufcol option may contain bugs during the cleaning "
"step. If you encounter problems, use the debug "
"option or clean manually with v.clean tool=break; "
"v.category step=0; v.extract -d type=area"));
if (field_opt->answer)
field = Vect_get_field_number(&In, field_opt->answer);
else
field = -1;
if (bufcol_opt->answer && field == -1)
G_fatal_error(_("The bufcol option requires a valid layer."));
tolerance = atof(tol_opt->answer);
if (tolerance <= 0)
G_fatal_error(_("The tolerance must be > 0."));
if (adjust_tolerance(&tolerance))
G_warning(_("The tolerance was reset to %g"), tolerance);
scale = atof(scale_opt->answer);
if (scale <= 0.0)
G_fatal_error("Illegal scale value");
da = db = dalpha = 0;
if (dista_opt->answer) {
da = atof(dista_opt->answer);
if (distb_opt->answer)
db = atof(distb_opt->answer);
else
db = da;
if (angle_opt->answer)
dalpha = atof(angle_opt->answer);
else
dalpha = 0;
unit_tolerance = tolerance * MIN(da, db);
G_verbose_message(_("The tolerance in map units = %g"), unit_tolerance);
}
Vect_check_input_output_name(in_opt->answer, out_opt->answer,
GV_FATAL_EXIT);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
BCats = Vect_new_cats_struct();
Vect_set_open_level(2); /* topology required */
if (1 > Vect_open_old2(&In, in_opt->answer, "", field_opt->answer))
G_fatal_error(_("Unable to open vector map <%s>"), in_opt->answer);
if (0 > Vect_open_new(&Out, out_opt->answer, WITHOUT_Z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create vector map <%s>"), out_opt->answer);
}
/* open tmp vector for buffers, needed for cleaning */
sprintf(bufname, "%s_tmp_%d", out_opt->answer, getpid());
if (0 > Vect_open_new(&Buf, bufname, 0)) {
Vect_close(&In);
Vect_close(&Out);
Vect_delete(out_opt->answer);
exit(EXIT_FAILURE);
}
Vect_build_partial(&Buf, GV_BUILD_BASE);
/* check and load attribute column data */
if (bufcol_opt->answer) {
db_CatValArray_init(&cvarr);
Fi = Vect_get_field(&In, field);
if (Fi == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
field);
Driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (Driver == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
/* Note do not check if the column exists in the table because it may be expression */
/* TODO: only select values we need instead of all in column */
nrec =
db_select_CatValArray(Driver, Fi->table, Fi->key,
bufcol_opt->answer, NULL, &cvarr);
if (nrec < 0)
G_fatal_error(_("Unable to select data from table <%s>"),
Fi->table);
G_debug(2, "%d records selected from table", nrec);
ctype = cvarr.ctype;
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Column type not supported"));
db_close_database_shutdown_driver(Driver);
/* Output cats/values list */
for (i = 0; i < cvarr.n_values; i++) {
if (ctype == DB_C_TYPE_INT) {
G_debug(4, "cat = %d val = %d", cvarr.value[i].cat,
cvarr.value[i].val.i);
}
else if (ctype == DB_C_TYPE_DOUBLE) {
G_debug(4, "cat = %d val = %f", cvarr.value[i].cat,
cvarr.value[i].val.d);
}
}
}
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
/* Create buffers' boundaries */
nlines = nareas = 0;
if ((type & GV_POINTS) || (type & GV_LINES))
nlines += Vect_get_num_primitives(&In, type);
if (type & GV_AREA)
nareas = Vect_get_num_areas(&In);
if (nlines + nareas == 0) {
G_warning(_("No features available for buffering. "
"Check type option and features available in the input vector."));
exit(EXIT_SUCCESS);
}
buffers_count = 1;
arr_bc = G_malloc((nlines + nareas + 1) * sizeof(struct buf_contours));
Vect_spatial_index_init(&si, 0);
/* Lines (and Points) */
if ((type & GV_POINTS) || (type & GV_LINES)) {
int ltype;
if (nlines > 0)
G_message(_("Buffering lines..."));
for (line = 1; line <= nlines; line++) {
int cat;
G_debug(2, "line = %d", line);
G_percent(line, nlines, 2);
if (!Vect_line_alive(&In, line))
continue;
ltype = Vect_read_line(&In, Points, Cats, line);
if (!(ltype & type))
continue;
if (field > 0 && !Vect_cat_get(Cats, field, &cat))
continue;
if (bufcol_opt->answer) {
ret = db_CatValArray_get_value_di(&cvarr, cat, &size_val);
if (ret != DB_OK) {
G_warning(_("No record for category %d in table <%s>"),
cat, Fi->table);
continue;
}
if (size_val < 0.0) {
G_warning(_("Attribute is of invalid size (%.3f) for category %d"),
size_val, cat);
continue;
}
if (size_val == 0.0)
continue;
da = size_val * scale;
db = da;
dalpha = 0;
unit_tolerance = tolerance * MIN(da, db);
G_debug(2, " dynamic buffer size = %.2f", da);
G_debug(2, _("The tolerance in map units: %g"),
unit_tolerance);
}
Vect_line_prune(Points);
if (ltype & GV_POINTS || Points->n_points == 1) {
Vect_point_buffer2(Points->x[0], Points->y[0], da, db, dalpha,
!(straight_flag->answer), unit_tolerance,
&(arr_bc_pts.oPoints));
Vect_write_line(&Out, GV_BOUNDARY, arr_bc_pts.oPoints, BCats);
line_id = Vect_write_line(&Buf, GV_BOUNDARY, arr_bc_pts.oPoints, Cats);
Vect_destroy_line_struct(arr_bc_pts.oPoints);
/* add buffer to spatial index */
Vect_get_line_box(&Buf, line_id, &bbox);
Vect_spatial_index_add_item(&si, buffers_count, &bbox);
arr_bc[buffers_count].outer = line_id;
arr_bc[buffers_count].inner_count = 0;
arr_bc[buffers_count].inner = NULL;
buffers_count++;
}
else {
Vect_line_buffer2(Points, da, db, dalpha,
!(straight_flag->answer),
!(nocaps_flag->answer), unit_tolerance,
&(arr_bc_pts.oPoints),
&(arr_bc_pts.iPoints),
&(arr_bc_pts.inner_count));
Vect_write_line(&Out, GV_BOUNDARY, arr_bc_pts.oPoints, BCats);
line_id = Vect_write_line(&Buf, GV_BOUNDARY, arr_bc_pts.oPoints, Cats);
Vect_destroy_line_struct(arr_bc_pts.oPoints);
/* add buffer to spatial index */
Vect_get_line_box(&Buf, line_id, &bbox);
Vect_spatial_index_add_item(&si, buffers_count, &bbox);
arr_bc[buffers_count].outer = line_id;
arr_bc[buffers_count].inner_count = arr_bc_pts.inner_count;
if (arr_bc_pts.inner_count > 0) {
arr_bc[buffers_count].inner = G_malloc(arr_bc_pts.inner_count * sizeof(int));
for (i = 0; i < arr_bc_pts.inner_count; i++) {
Vect_write_line(&Out, GV_BOUNDARY, arr_bc_pts.iPoints[i], BCats);
line_id = Vect_write_line(&Buf, GV_BOUNDARY, arr_bc_pts.iPoints[i], Cats);
Vect_destroy_line_struct(arr_bc_pts.iPoints[i]);
/* add buffer to spatial index */
Vect_get_line_box(&Buf, line_id, &bbox);
Vect_spatial_index_add_item(&si, buffers_count, &bbox);
arr_bc[buffers_count].inner[i] = line_id;
}
G_free(arr_bc_pts.iPoints);
}
buffers_count++;
}
}
}
/* Areas */
if (type & GV_AREA) {
int centroid;
if (nareas > 0)
G_message(_("Buffering areas..."));
for (area = 1; area <= nareas; area++) {
int cat;
G_percent(area, nareas, 2);
if (!Vect_area_alive(&In, area))
continue;
centroid = Vect_get_area_centroid(&In, area);
if (centroid == 0)
continue;
Vect_read_line(&In, NULL, Cats, centroid);
if (field > 0 && !Vect_cat_get(Cats, field, &cat))
continue;
if (bufcol_opt->answer) {
ret = db_CatValArray_get_value_di(&cvarr, cat, &size_val);
if (ret != DB_OK) {
G_warning(_("No record for category %d in table <%s>"),
cat, Fi->table);
continue;
}
if (size_val < 0.0) {
G_warning(_("Attribute is of invalid size (%.3f) for category %d"),
size_val, cat);
continue;
}
if (size_val == 0.0)
continue;
da = size_val * scale;
db = da;
dalpha = 0;
unit_tolerance = tolerance * MIN(da, db);
G_debug(2, " dynamic buffer size = %.2f", da);
G_debug(2, _("The tolerance in map units: %g"),
unit_tolerance);
}
Vect_area_buffer2(&In, area, da, db, dalpha,
!(straight_flag->answer),
!(nocaps_flag->answer), unit_tolerance,
&(arr_bc_pts.oPoints),
&(arr_bc_pts.iPoints),
&(arr_bc_pts.inner_count));
Vect_write_line(&Out, GV_BOUNDARY, arr_bc_pts.oPoints, BCats);
line_id = Vect_write_line(&Buf, GV_BOUNDARY, arr_bc_pts.oPoints, Cats);
Vect_destroy_line_struct(arr_bc_pts.oPoints);
/* add buffer to spatial index */
Vect_get_line_box(&Buf, line_id, &bbox);
Vect_spatial_index_add_item(&si, buffers_count, &bbox);
arr_bc[buffers_count].outer = line_id;
arr_bc[buffers_count].inner_count = arr_bc_pts.inner_count;
if (arr_bc_pts.inner_count > 0) {
arr_bc[buffers_count].inner = G_malloc(arr_bc_pts.inner_count * sizeof(int));
for (i = 0; i < arr_bc_pts.inner_count; i++) {
Vect_write_line(&Out, GV_BOUNDARY, arr_bc_pts.iPoints[i], BCats);
line_id = Vect_write_line(&Buf, GV_BOUNDARY, arr_bc_pts.iPoints[i], Cats);
Vect_destroy_line_struct(arr_bc_pts.iPoints[i]);
/* add buffer to spatial index */
Vect_get_line_box(&Buf, line_id, &bbox);
Vect_spatial_index_add_item(&si, buffers_count, &bbox);
arr_bc[buffers_count].inner[i] = line_id;
}
G_free(arr_bc_pts.iPoints);
}
buffers_count++;
}
}
verbose = G_verbose();
G_message(_("Cleaning buffers..."));
/* Break lines */
G_message(_("Building parts of topology..."));
Vect_build_partial(&Out, GV_BUILD_BASE);
G_message(_("Snapping boundaries..."));
Vect_snap_lines(&Out, GV_BOUNDARY, 1e-7, NULL);
G_message(_("Breaking polygons..."));
Vect_break_polygons(&Out, GV_BOUNDARY, NULL);
G_message(_("Removing duplicates..."));
Vect_remove_duplicates(&Out, GV_BOUNDARY, NULL);
do {
G_message(_("Breaking boundaries..."));
Vect_break_lines(&Out, GV_BOUNDARY, NULL);
G_message(_("Removing duplicates..."));
Vect_remove_duplicates(&Out, GV_BOUNDARY, NULL);
G_message(_("Cleaning boundaries at nodes"));
} while (Vect_clean_small_angles_at_nodes(&Out, GV_BOUNDARY, NULL) > 0);
/* Dangles and bridges don't seem to be necessary if snapping is small enough. */
/* Still needed for larger buffer distances ? */
/*
G_message(_("Removing dangles..."));
Vect_remove_dangles(&Out, GV_BOUNDARY, -1, NULL);
G_message (_("Removing bridges..."));
Vect_remove_bridges(&Out, NULL);
*/
G_message(_("Attaching islands..."));
Vect_build_partial(&Out, GV_BUILD_ATTACH_ISLES);
/* Calculate new centroids for all areas */
nareas = Vect_get_num_areas(&Out);
Areas = (char *)G_calloc(nareas + 1, sizeof(char));
G_message(_("Calculating centroids for areas..."));
G_percent(0, nareas, 2);
for (area = 1; area <= nareas; area++) {
double x, y;
G_percent(area, nareas, 2);
G_debug(3, "area = %d", area);
if (!Vect_area_alive(&Out, area))
continue;
ret = Vect_get_point_in_area(&Out, area, &x, &y);
if (ret < 0) {
G_warning(_("Cannot calculate area centroid"));
continue;
}
ret = point_in_buffer(arr_bc, &si, &Buf, x, y);
if (ret) {
G_debug(3, " -> in buffer");
Areas[area] = 1;
}
}
/* Make a list of boundaries to be deleted (both sides inside) */
nlines = Vect_get_num_lines(&Out);
G_debug(3, "nlines = %d", nlines);
Lines = (char *)G_calloc(nlines + 1, sizeof(char));
G_message(_("Generating list of boundaries to be deleted..."));
for (line = 1; line <= nlines; line++) {
int j, side[2], areas[2];
G_percent(line, nlines, 2);
G_debug(3, "line = %d", line);
if (!Vect_line_alive(&Out, line))
continue;
Vect_get_line_areas(&Out, line, &side[0], &side[1]);
for (j = 0; j < 2; j++) {
if (side[j] == 0) { /* area/isle not build */
areas[j] = 0;
}
else if (side[j] > 0) { /* area */
areas[j] = side[j];
}
else { /* < 0 -> island */
areas[j] = Vect_get_isle_area(&Out, abs(side[j]));
}
}
G_debug(3, " areas = %d , %d -> Areas = %d, %d", areas[0], areas[1],
Areas[areas[0]], Areas[areas[1]]);
if (Areas[areas[0]] && Areas[areas[1]])
Lines[line] = 1;
}
G_free(Areas);
/* Delete boundaries */
G_message(_("Deleting boundaries..."));
for (line = 1; line <= nlines; line++) {
G_percent(line, nlines, 2);
if (!Vect_line_alive(&Out, line))
continue;
if (Lines[line]) {
G_debug(3, " delete line %d", line);
Vect_delete_line(&Out, line);
}
else {
/* delete incorrect boundaries */
int side[2];
Vect_get_line_areas(&Out, line, &side[0], &side[1]);
if (!side[0] && !side[1])
Vect_delete_line(&Out, line);
}
}
G_free(Lines);
/* Create new centroids */
Vect_reset_cats(Cats);
Vect_cat_set(Cats, 1, 1);
nareas = Vect_get_num_areas(&Out);
G_message(_("Calculating centroids for areas..."));
for (area = 1; area <= nareas; area++) {
double x, y;
G_percent(area, nareas, 2);
G_debug(3, "area = %d", area);
if (!Vect_area_alive(&Out, area))
continue;
ret = Vect_get_point_in_area(&Out, area, &x, &y);
if (ret < 0) {
G_warning(_("Cannot calculate area centroid"));
continue;
}
ret = point_in_buffer(arr_bc, &si, &Buf, x, y);
if (ret) {
Vect_reset_line(Points);
Vect_append_point(Points, x, y, 0.);
Vect_write_line(&Out, GV_CENTROID, Points, Cats);
}
}
/* free arr_bc[] */
/* will only slow down the module
for (i = 0; i < buffers_count; i++) {
Vect_destroy_line_struct(arr_bc[i].oPoints);
for (j = 0; j < arr_bc[i].inner_count; j++)
Vect_destroy_line_struct(arr_bc[i].iPoints[j]);
G_free(arr_bc[i].iPoints);
} */
Vect_spatial_index_destroy(&si);
Vect_close(&Buf);
Vect_delete(bufname);
G_set_verbose(verbose);
Vect_close(&In);
Vect_build_partial(&Out, GV_BUILD_NONE);
Vect_build(&Out);
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct {
struct Option *input, *output, *zshift, *height, *elevation, *hcolumn,
*type, *field, *cats, *where, *interp, *scale, *null;
} opt;
struct {
struct Flag *trace;
} flag;
struct Map_info In, Out;
struct line_pnts *Points;
struct line_cats *Cats;
struct bound_box map_box;
struct cat_list *cat_list;
struct Cell_head window;
int field;
int only_type, cat;
int fdrast, interp_method, trace;
double objheight, objheight_default, voffset;
double scale, null_val;
struct field_info *Fi;
dbDriver *driver = NULL;
char *comment;
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("geometry"));
G_add_keyword(_("sampling"));
G_add_keyword(_("3D"));
module->label =
_("Extrudes flat vector features to 3D vector features with defined height.");
module->description =
_("Optionally the height can be derived from sampling of elevation raster map.");
flag.trace = G_define_flag();
flag.trace->key = 't';
flag.trace->description = _("Trace elevation");
flag.trace->guisection = _("Elevation");
opt.input = G_define_standard_option(G_OPT_V_INPUT);
opt.field = G_define_standard_option(G_OPT_V_FIELD_ALL);
opt.field->guisection = _("Selection");
opt.cats = G_define_standard_option(G_OPT_V_CATS);
opt.cats->guisection = _("Selection");
opt.where = G_define_standard_option(G_OPT_DB_WHERE);
opt.where->guisection = _("Selection");
opt.type = G_define_standard_option(G_OPT_V_TYPE);
opt.type->answer = "point,line,area";
opt.type->options = "point,line,area";
opt.type->guisection = _("Selection");
opt.output = G_define_standard_option(G_OPT_V_OUTPUT);
opt.zshift = G_define_option();
opt.zshift->key = "zshift";
opt.zshift->description = _("Shifting value for z coordinates");
opt.zshift->type = TYPE_DOUBLE;
opt.zshift->required = NO;
opt.zshift->answer = "0";
opt.zshift->guisection = _("Height");
opt.height = G_define_option();
opt.height->key = "height";
opt.height->type = TYPE_DOUBLE;
opt.height->required = NO;
opt.height->multiple = NO;
opt.height->description = _("Fixed height for 3D vector features");
opt.height->guisection = _("Height");
opt.hcolumn = G_define_standard_option(G_OPT_DB_COLUMN);
opt.hcolumn->key = "height_column";
opt.hcolumn->multiple = NO;
opt.hcolumn->description = _("Name of attribute column with feature height");
opt.hcolumn->guisection = _("Height");
/* raster sampling */
opt.elevation = G_define_standard_option(G_OPT_R_ELEV);
opt.elevation->required = NO;
opt.elevation->description = _("Elevation raster map for height extraction");
opt.elevation->guisection = _("Elevation");
opt.interp = G_define_standard_option(G_OPT_R_INTERP_TYPE);
opt.interp->answer = "nearest";
opt.interp->guisection = _("Elevation");
opt.scale = G_define_option();
opt.scale->key = "scale";
opt.scale->type = TYPE_DOUBLE;
opt.scale->description = _("Scale factor sampled raster values");
opt.scale->answer = "1.0";
opt.scale->guisection = _("Elevation");
opt.null = G_define_option();
opt.null->key = "null_value";
opt.null->type = TYPE_DOUBLE;
opt.null->description =
_("Height for sampled raster NULL values");
opt.null->guisection = _("Elevation");
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (!opt.height->answer && !opt.hcolumn->answer) {
G_fatal_error(_("One of '%s' or '%s' parameters must be set"),
opt.height->key, opt.hcolumn->key);
}
sscanf(opt.zshift->answer, "%lf", &voffset);
G_debug(1, "voffset = %f", voffset);
if (opt.height->answer)
sscanf(opt.height->answer, "%lf", &objheight);
else
objheight = 0.;
G_debug(1, "objheight = %f", objheight);
objheight_default = objheight;
only_type = Vect_option_to_types(opt.type);
/* sampling method */
interp_method = Rast_option_to_interp_type(opt.interp);
/* used to scale sampled raster values */
scale = atof(opt.scale->answer);
/* is null value defined */
if (opt.null->answer)
null_val = atof(opt.null->answer);
/* trace elevation */
trace = flag.trace->answer ? TRUE : FALSE;
/* set input vector map name and mapset */
Vect_check_input_output_name(opt.input->answer, opt.output->answer, G_FATAL_EXIT);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_set_open_level(2); /* topology required for input */
/* opening input vector map */
if (Vect_open_old2(&In, opt.input->answer, "", opt.field->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), opt.input->answer);
Vect_set_error_handler_io(&In, &Out);
/* creating output vector map */
if (Vect_open_new(&Out, opt.output->answer, WITH_Z) < 0)
G_fatal_error(_("Unable to create vector map <%s>"),
opt.output->answer);
field = Vect_get_field_number(&In, opt.field->answer);
if ((opt.hcolumn->answer || opt.cats->answer || opt.where->answer) && field == -1) {
G_warning(_("Invalid layer number (%d). "
"Parameter '%s', '%s' or '%s' specified, assuming layer '1'."),
field, opt.hcolumn->key, opt.cats->key, opt.where->key);
field = 1;
}
/* set constraint for cats or where */
cat_list = NULL;
if (field > 0)
cat_list = Vect_cats_set_constraint(&In, field, opt.where->answer,
opt.cats->answer);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
/* opening database connection, if required */
if (opt.hcolumn->answer) {
int ctype;
dbColumn *column;
if ((Fi = Vect_get_field(&In, field)) == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
field);
if ((driver =
db_start_driver_open_database(Fi->driver, Fi->database)) == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
db_set_error_handler_driver(driver);
if (db_get_column(driver, Fi->table, opt.hcolumn->answer, &column) != DB_OK)
G_fatal_error(_("Column <%s> does not exist"),
opt.hcolumn->answer);
else
db_free_column(column);
ctype = db_column_Ctype(driver, Fi->table, opt.hcolumn->answer);
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_STRING &&
ctype != DB_C_TYPE_DOUBLE) {
G_fatal_error(_("Column <%s>: invalid data type"),
opt.hcolumn->answer);
}
}
/* do we work with elevation raster? */
fdrast = -1;
if (opt.elevation->answer) {
/* raster setup */
G_get_window(&window);
/* open the elev raster, and check for error condition */
fdrast = Rast_open_old(opt.elevation->answer, "");
}
/* if area */
if (only_type & GV_AREA) {
int area, nareas, centroid;
nareas = Vect_get_num_areas(&In);
G_debug(2, "n_areas = %d", nareas);
if (nareas > 0)
G_message(_("Extruding areas..."));
for (area = 1; area <= nareas; area++) {
G_debug(3, "area = %d", area);
G_percent(area, nareas, 2);
if (!Vect_area_alive(&In, area))
continue;
centroid = Vect_get_area_centroid(&In, area);
if (!centroid) {
G_warning(_("Skipping area %d without centroid"), area);
continue;
}
Vect_read_line(&In, NULL, Cats, centroid);
if (field > 0 && !Vect_cats_in_constraint(Cats, field, cat_list))
continue;
/* height attribute */
if (opt.hcolumn->answer) {
cat = Vect_get_area_cat(&In, area, field);
if (cat == -1) {
G_warning(_("No category defined for area %d. Using default fixed height %f."),
area, objheight_default);
objheight = objheight_default;
}
if (get_height(Fi, opt.hcolumn->answer,
driver, cat, &objheight) != 0) {
G_warning(_("Unable to fetch height from DB for area %d. Using default fixed height %f."),
area, objheight_default);
objheight = objheight_default;
}
} /* if opt.hcolumn->answer */
Vect_get_area_points(&In, area, Points);
G_debug(3, "area: %d height: %f", area, objheight);
extrude(&In, &Out, Cats, Points,
fdrast, trace, interp_method, scale,
opt.null->answer ? TRUE : FALSE, null_val,
objheight, voffset, &window, GV_AREA,
centroid);
} /* foreach area */
}
if (only_type > 0) {
int line, nlines;
int type;
G_debug(1, "other than areas");
/* loop through each line in the dataset */
nlines = Vect_get_num_lines(&In);
G_message(_("Extruding features..."));
for (line = 1; line <= nlines; line++) {
/* progress feedback */
G_percent(line, nlines, 2);
if (!Vect_line_alive(&In, line))
continue;
/* read line */
type = Vect_read_line(&In, Points, Cats, line);
if (!(type & only_type))
continue;
if (field > 0 && !Vect_cats_in_constraint(Cats, field, cat_list))
continue;
/* height attribute */
if (opt.hcolumn->answer) {
cat = Vect_get_line_cat(&In, line, field);
if (cat == -1) {
G_warning(_("No category defined for feature %d. Using default fixed height %f."),
line, objheight_default);
objheight = objheight_default;
}
if (get_height(Fi, opt.hcolumn->answer,
driver, cat, &objheight) != 0) {
G_warning(_("Unable to fetch height from DB for line %d. Using default fixed height %f."),
line, objheight_default);
objheight = objheight_default;
}
} /* if opt.hcolumn->answer */
extrude(&In, &Out, Cats, Points,
fdrast, trace, interp_method, scale,
opt.null->answer ? TRUE : FALSE, null_val,
objheight, voffset, &window, type, -1);
} /* for each line */
} /* else if area */
if (driver) {
db_close_database(driver);
db_shutdown_driver(driver);
}
G_important_message(_("Copying attribute table..."));
if (field < 0)
Vect_copy_tables(&In, &Out, 0);
else
Vect_copy_table_by_cat_list(&In, &Out, field, field, NULL,
GV_1TABLE, cat_list);
Vect_build(&Out);
/* header */
G_asprintf(&comment, "Generated by %s from vector map <%s>",
G_program_name(), Vect_get_full_name(&In));
Vect_set_comment(&Out, comment);
G_free(comment);
Vect_get_map_box(&Out, &map_box);
Vect_close(&In);
Vect_close(&Out);
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
G_done_msg("T: %f B: %f.", map_box.T, map_box.B);
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
struct GModule *module;
struct Option *map_opt, *field_opt, *fs_opt, *vs_opt, *nv_opt, *col_opt,
*where_opt, *file_opt;
struct Flag *c_flag, *v_flag, *r_flag;
dbDriver *driver;
dbString sql, value_string;
dbCursor cursor;
dbTable *table;
dbColumn *column;
dbValue *value;
struct field_info *Fi;
int ncols, col, more;
struct Map_info Map;
char query[1024];
struct ilist *list_lines;
struct bound_box *min_box, *line_box;
int i, line, area, init_box, cat;
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("database"));
G_add_keyword(_("attribute table"));
module->description = _("Prints vector map attributes.");
map_opt = G_define_standard_option(G_OPT_V_MAP);
field_opt = G_define_standard_option(G_OPT_V_FIELD);
col_opt = G_define_standard_option(G_OPT_DB_COLUMNS);
where_opt = G_define_standard_option(G_OPT_DB_WHERE);
fs_opt = G_define_standard_option(G_OPT_F_SEP);
fs_opt->description = _("Output field separator");
fs_opt->guisection = _("Format");
vs_opt = G_define_standard_option(G_OPT_F_SEP);
vs_opt->key = "vs";
vs_opt->description = _("Output vertical record separator");
vs_opt->answer = NULL;
vs_opt->guisection = _("Format");
nv_opt = G_define_option();
nv_opt->key = "nv";
nv_opt->type = TYPE_STRING;
nv_opt->required = NO;
nv_opt->description = _("Null value indicator");
nv_opt->guisection = _("Format");
file_opt = G_define_standard_option(G_OPT_F_OUTPUT);
file_opt->key = "file";
file_opt->required = NO;
file_opt->description =
_("Name for output file (if omitted or \"-\" output to stdout)");
r_flag = G_define_flag();
r_flag->key = 'r';
r_flag->description =
_("Print minimal region extent of selected vector features instead of attributes");
c_flag = G_define_flag();
c_flag->key = 'c';
c_flag->description = _("Do not include column names in output");
c_flag->guisection = _("Format");
v_flag = G_define_flag();
v_flag->key = 'v';
v_flag->description = _("Vertical output (instead of horizontal)");
v_flag->guisection = _("Format");
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* set input vector map name and mapset */
if (file_opt->answer && strcmp(file_opt->answer, "-") != 0) {
if (NULL == freopen(file_opt->answer, "w", stdout)) {
G_fatal_error(_("Unable to open file <%s> for writing"), file_opt->answer);
}
}
if (r_flag->answer) {
min_box = (struct bound_box *) G_malloc(sizeof(struct bound_box));
G_zero((void *)min_box, sizeof(struct bound_box));
line_box = (struct bound_box *) G_malloc(sizeof(struct bound_box));
list_lines = Vect_new_list();
}
else {
min_box = line_box = NULL;
list_lines = NULL;
}
db_init_string(&sql);
db_init_string(&value_string);
/* open input vector */
if (!r_flag->answer)
Vect_open_old_head2(&Map, map_opt->answer, "", field_opt->answer);
else {
if (2 > Vect_open_old2(&Map, map_opt->answer, "", field_opt->answer)) {
Vect_close(&Map);
G_fatal_error(_("Unable to open vector map <%s> at topology level. "
"Flag '%c' requires topology level."),
map_opt->answer, r_flag->key);
}
}
if ((Fi = Vect_get_field2(&Map, field_opt->answer)) == 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)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
if (col_opt->answer)
sprintf(query, "SELECT %s FROM ", col_opt->answer);
else
sprintf(query, "SELECT * FROM ");
db_set_string(&sql, query);
db_append_string(&sql, Fi->table);
if (where_opt->answer) {
char *buf = NULL;
buf = G_malloc((strlen(where_opt->answer) + 8));
sprintf(buf, " WHERE %s", where_opt->answer);
db_append_string(&sql, buf);
G_free(buf);
}
if (db_open_select_cursor(driver, &sql, &cursor, DB_SEQUENTIAL) != DB_OK)
G_fatal_error(_("Unable to open select cursor"));
table = db_get_cursor_table(&cursor);
ncols = db_get_table_number_of_columns(table);
/* column names if horizontal output (ignore for -r) */
if (!v_flag->answer && !c_flag->answer && !r_flag->answer) {
for (col = 0; col < ncols; col++) {
column = db_get_table_column(table, col);
if (col)
fprintf(stdout, "%s", fs_opt->answer);
fprintf(stdout, "%s", db_get_column_name(column));
}
fprintf(stdout, "\n");
}
init_box = 1;
/* fetch the data */
while (1) {
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK)
G_fatal_error(_("Unable to fetch data from table <%s>"),
Fi->table);
if (!more)
break;
cat = -1;
for (col = 0; col < ncols; col++) {
column = db_get_table_column(table, col);
value = db_get_column_value(column);
if (cat < 0 && strcmp(Fi->key, db_get_column_name(column)) == 0) {
cat = db_get_value_int(value);
if (r_flag->answer)
break;
}
if (r_flag->answer)
continue;
db_convert_column_value_to_string(column, &value_string);
if (!c_flag->answer && v_flag->answer)
fprintf(stdout, "%s%s", db_get_column_name(column),
fs_opt->answer);
if (col && !v_flag->answer)
fprintf(stdout, "%s", fs_opt->answer);
if (nv_opt->answer && db_test_value_isnull(value))
fprintf(stdout, "%s", nv_opt->answer);
else
fprintf(stdout, "%s", db_get_string(&value_string));
if (v_flag->answer)
fprintf(stdout, "\n");
}
if (r_flag->answer) {
/* get minimal region extent */
Vect_cidx_find_all(&Map, Vect_get_field_number(&Map, field_opt->answer), -1, cat, list_lines);
for (i = 0; i < list_lines->n_values; i++) {
line = list_lines->value[i];
area = Vect_get_centroid_area(&Map, line);
if (area > 0) {
if (!Vect_get_area_box(&Map, area, line_box))
G_fatal_error(_("Unable to get bounding box of area %d"),
area);
}
else {
if (!Vect_get_line_box(&Map, line, line_box))
G_fatal_error(_("Unable to get bounding box of line %d"),
line);
}
if (init_box) {
Vect_box_copy(min_box, line_box);
init_box = 0;
}
else {
Vect_box_extend(min_box, line_box);
}
}
}
else {
if (!v_flag->answer)
fprintf(stdout, "\n");
else if (vs_opt->answer)
fprintf(stdout, "%s\n", vs_opt->answer);
}
}
if (r_flag->answer) {
fprintf(stdout, "n=%f\n", min_box->N);
fprintf(stdout, "s=%f\n", min_box->S);
fprintf(stdout, "w=%f\n", min_box->W);
fprintf(stdout, "e=%f\n", min_box->E);
if (Vect_is_3d(&Map)) {
fprintf(stdout, "t=%f\n", min_box->T);
fprintf(stdout, "b=%f\n", min_box->B);
}
fflush(stdout);
G_free((void *)min_box);
G_free((void *)line_box);
Vect_destroy_list(list_lines);
}
db_close_cursor(&cursor);
db_close_database_shutdown_driver(driver);
Vect_close(&Map);
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
int field, type, vertex_type;
double dmax;
char buf[DB_SQL_MAX];
struct {
struct Option *input, *output, *type, *dmax, *lfield, *use;
} opt;
struct {
struct Flag *table, *inter;
} flag;
struct GModule *module;
struct Map_info In, Out;
struct line_cats *LCats;
struct line_pnts *LPoints;
dbDriver *driver;
struct field_info *Fi;
dbString stmt;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("geometry"));
G_add_keyword("3D");
G_add_keyword(_("node"));
G_add_keyword(_("vertex"));
module->description =
_("Creates points along input lines in new vector map with 2 layers.");
opt.input = G_define_standard_option(G_OPT_V_INPUT);
opt.lfield = G_define_standard_option(G_OPT_V_FIELD);
opt.lfield->key = "llayer";
opt.lfield->answer = "1";
opt.lfield->label = "Line layer number or name";
opt.lfield->guisection = _("Selection");
opt.type = G_define_standard_option(G_OPT_V3_TYPE);
opt.type->answer = "point,line,boundary,centroid,face";
opt.type->guisection = _("Selection");
opt.output = G_define_standard_option(G_OPT_V_OUTPUT);
opt.use = G_define_option();
opt.use->key = "use";
opt.use->type = TYPE_STRING;
opt.use->required = NO;
opt.use->description = _("Use line nodes or vertices only");
opt.use->options = "node,vertex";
opt.dmax = G_define_option();
opt.dmax->key = "dmax";
opt.dmax->type = TYPE_DOUBLE;
opt.dmax->required = NO;
opt.dmax->answer = "100";
opt.dmax->description = _("Maximum distance between points in map units");
flag.inter = G_define_flag();
flag.inter->key = 'i';
flag.inter->description = _("Interpolate points between line vertices (only for use=vertex)");
flag.table = G_define_standard_flag(G_FLG_V_TABLE);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
LCats = Vect_new_cats_struct();
LPoints = Vect_new_line_struct();
db_init_string(&stmt);
type = Vect_option_to_types(opt.type);
dmax = atof(opt.dmax->answer);
vertex_type = 0;
if (opt.use->answer) {
if (opt.use->answer[0] == 'n')
vertex_type = GV_NODE;
else
vertex_type = GV_VERTEX;
}
Vect_check_input_output_name(opt.input->answer, opt.output->answer,
G_FATAL_EXIT);
/* Open input lines */
Vect_set_open_level(2);
if (Vect_open_old2(&In, opt.input->answer, "", opt.lfield->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), opt.input->answer);
Vect_set_error_handler_io(&In, &Out);
field = Vect_get_field_number(&In, opt.lfield->answer);
/* Open output segments */
if (Vect_open_new(&Out, opt.output->answer, Vect_is_3d(&In)) < 0)
G_fatal_error(_("Unable to create vector map <%s>"),
opt.output->answer);
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
/* Table */
Fi = NULL;
if (!flag.table->answer) {
struct field_info *Fin;
/* copy input table */
Fin = Vect_get_field(&In, field);
if (Fin) { /* table defined */
int ret;
Fi = Vect_default_field_info(&Out, 1, NULL, GV_MTABLE);
Vect_map_add_dblink(&Out, 1, NULL, Fi->table, Fin->key,
Fi->database, Fi->driver);
ret = db_copy_table(Fin->driver, Fin->database, Fin->table,
Fi->driver, Vect_subst_var(Fi->database,
&Out), Fi->table);
if (ret == DB_FAILED) {
G_fatal_error(_("Unable to copy table <%s>"),
Fin->table);
}
}
Fi = Vect_default_field_info(&Out, 2, NULL, GV_MTABLE);
Vect_map_add_dblink(&Out, 2, NULL, Fi->table, GV_KEY_COLUMN, Fi->database,
Fi->driver);
/* 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);
db_set_error_handler_driver(driver);
if (field == -1)
sprintf(buf,
"create table %s ( cat int, along double precision )",
Fi->table);
else
sprintf(buf,
"create table %s ( cat int, lcat int, along double precision )",
Fi->table);
db_append_string(&stmt, buf);
if (db_execute_immediate(driver, &stmt) != DB_OK) {
G_fatal_error(_("Unable to create table: '%s'"),
db_get_string(&stmt));
}
if (db_create_index2(driver, Fi->table, GV_KEY_COLUMN) != DB_OK)
G_warning(_("Unable to create index for table <%s>, key <%s>"),
Fi->table, GV_KEY_COLUMN);
if (db_grant_on_table (driver, Fi->table, DB_PRIV_SELECT,
DB_GROUP | DB_PUBLIC) != DB_OK)
G_fatal_error(_("Unable to grant privileges on table <%s>"),
Fi->table);
db_begin_transaction(driver);
}
if (type & (GV_POINTS | GV_LINES | GV_FACE)) {
int line, nlines, nskipped;
nskipped = 0;
nlines = Vect_get_num_lines(&In);
for (line = 1; line <= nlines; line++) {
int ltype, cat;
G_debug(3, "line = %d", line);
G_percent(line, nlines, 2);
ltype = Vect_read_line(&In, LPoints, LCats, line);
if (!(ltype & type))
continue;
if (!Vect_cat_get(LCats, field, &cat) && field != -1) {
nskipped++;
continue;
}
/* Assign CAT for layer 0 objects (i.e. boundaries) */
if (field == -1)
cat = -1;
if (LPoints->n_points <= 1) {
write_point(&Out, LPoints->x[0], LPoints->y[0], LPoints->z[0],
cat, 0.0, driver, Fi);
}
else { /* lines */
write_line(&Out, LPoints, cat, vertex_type,
flag.inter->answer, dmax, driver, Fi);
}
}
if (nskipped > 0)
G_warning(_("%d features without category in layer <%d> skipped. "
"Note that features without category (usually boundaries) are not "
"skipped when '%s=-1' is given."),
nskipped, field, opt.lfield->key);
}
if (type == GV_AREA) {
int area, nareas, centroid, cat;
nareas = Vect_get_num_areas(&In);
for (area = 1; area <= nareas; area++) {
int i, isle, nisles;
G_percent(area, nareas, 2);
centroid = Vect_get_area_centroid(&In, area);
cat = -1;
if (centroid > 0) {
Vect_read_line(&In, NULL, LCats, centroid);
if (!Vect_cat_get(LCats, field, &cat))
continue;
}
Vect_get_area_points(&In, area, LPoints);
write_line(&Out, LPoints, cat, vertex_type, flag.inter->answer,
dmax, driver, Fi);
nisles = Vect_get_area_num_isles(&In, area);
for (i = 0; i < nisles; i++) {
isle = Vect_get_area_isle(&In, area, i);
Vect_get_isle_points(&In, isle, LPoints);
write_line(&Out, LPoints, cat, vertex_type,
flag.inter->answer, dmax, driver, Fi);
}
}
}
if (!flag.table->answer) {
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
}
Vect_build(&Out);
/* Free, close ... */
Vect_close(&In);
G_done_msg(_("%d points written to output vector map."),
Vect_get_num_primitives(&Out, GV_POINT));
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
int ret, level;
int stat, type, display;
int chcat;
int has_color, has_fcolor;
struct color_rgb color, fcolor;
double size;
int default_width;
double width_scale;
double minreg, maxreg, reg;
char map_name[GNAME_MAX];
struct GModule *module;
struct Option *map_opt;
struct Option *color_opt, *fcolor_opt, *rgbcol_opt, *zcol_opt;
struct Option *type_opt, *display_opt;
struct Option *icon_opt, *size_opt, *sizecolumn_opt, *rotcolumn_opt;
struct Option *where_opt;
struct Option *field_opt, *cat_opt, *lfield_opt;
struct Option *lcolor_opt, *bgcolor_opt, *bcolor_opt;
struct Option *lsize_opt, *font_opt, *enc_opt, *xref_opt, *yref_opt;
struct Option *attrcol_opt, *maxreg_opt, *minreg_opt;
struct Option *width_opt, *wcolumn_opt, *wscale_opt;
struct Option *leglab_opt;
struct Option *icon_line_opt, *icon_area_opt;
struct Flag *id_flag, *cats_acolors_flag, *sqrt_flag, *legend_flag;
char *desc;
struct cat_list *Clist;
LATTR lattr;
struct Map_info Map;
struct Cell_head window;
struct bound_box box;
double overlap;
stat = 0;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("graphics"));
G_add_keyword(_("vector"));
module->description = _("Displays user-specified vector map "
"in the active graphics frame.");
map_opt = G_define_standard_option(G_OPT_V_MAP);
field_opt = G_define_standard_option(G_OPT_V_FIELD_ALL);
field_opt->answer = "1";
field_opt->guisection = _("Selection");
display_opt = G_define_option();
display_opt->key = "display";
display_opt->type = TYPE_STRING;
display_opt->required = YES;
display_opt->multiple = YES;
display_opt->answer = "shape";
display_opt->options = "shape,cat,topo,vert,dir,zcoor";
display_opt->description = _("Display");
desc = NULL;
G_asprintf(&desc,
"shape;%s;cat;%s;topo;%s;vert;%s;dir;%s;zcoor;%s",
_("Display geometry of features"),
_("Display category numbers of features"),
_("Display topology information (nodes, edges)"),
_("Display vertices of features"),
_("Display direction of linear features"),
_("Display z-coordinate of features (only for 3D vector maps)"));
display_opt->descriptions = desc;
/* Query */
type_opt = G_define_standard_option(G_OPT_V_TYPE);
type_opt->answer = "point,line,area,face";
type_opt->options = "point,line,boundary,centroid,area,face";
type_opt->guisection = _("Selection");
cat_opt = G_define_standard_option(G_OPT_V_CATS);
cat_opt->guisection = _("Selection");
where_opt = G_define_standard_option(G_OPT_DB_WHERE);
where_opt->guisection = _("Selection");
/* Colors */
color_opt = G_define_standard_option(G_OPT_CN);
color_opt->label = _("Feature color");
color_opt->guisection = _("Colors");
fcolor_opt = G_define_standard_option(G_OPT_CN);
fcolor_opt->key = "fill_color";
fcolor_opt->answer = "200:200:200";
fcolor_opt->label = _("Area fill color");
fcolor_opt->guisection = _("Colors");
rgbcol_opt = G_define_standard_option(G_OPT_DB_COLUMN);
rgbcol_opt->key = "rgb_column";
rgbcol_opt->guisection = _("Colors");
rgbcol_opt->label = _("Colorize features according color definition column");
rgbcol_opt->description = _("Color definition in R:G:B form");
zcol_opt = G_define_standard_option(G_OPT_M_COLR);
zcol_opt->key = "zcolor";
zcol_opt->description = _("Colorize point or area features according to z-coordinate");
zcol_opt->guisection = _("Colors");
/* Lines */
width_opt = G_define_option();
width_opt->key = "width";
width_opt->type = TYPE_INTEGER;
width_opt->answer = "0";
width_opt->guisection = _("Lines");
width_opt->description = _("Line width");
wcolumn_opt = G_define_standard_option(G_OPT_DB_COLUMN);
wcolumn_opt->key = "width_column";
wcolumn_opt->guisection = _("Lines");
wcolumn_opt->label = _("Name of numeric column containing line width");
wcolumn_opt->description = _("These values will be scaled by width_scale");
wscale_opt = G_define_option();
wscale_opt->key = "width_scale";
wscale_opt->type = TYPE_DOUBLE;
wscale_opt->answer = "1";
wscale_opt->guisection = _("Lines");
wscale_opt->description = _("Scale factor for width_column");
/* Symbols */
icon_opt = G_define_option();
icon_opt->key = "icon";
icon_opt->type = TYPE_STRING;
icon_opt->required = NO;
icon_opt->multiple = NO;
icon_opt->guisection = _("Symbols");
icon_opt->answer = "basic/x";
/* This could also use ->gisprompt = "old,symbol,symbol" instead of ->options */
icon_opt->options = icon_files();
icon_opt->description = _("Point and centroid symbol");
size_opt = G_define_option();
size_opt->key = "size";
size_opt->type = TYPE_DOUBLE;
size_opt->answer = "5";
size_opt->guisection = _("Symbols");
size_opt->label = _("Symbol size");
size_opt->description =
_("When used with the size_column option this becomes the scale factor");
sizecolumn_opt = G_define_standard_option(G_OPT_DB_COLUMN);
sizecolumn_opt->key = "size_column";
sizecolumn_opt->guisection = _("Symbols");
sizecolumn_opt->description =
_("Name of numeric column containing symbol size");
rotcolumn_opt = G_define_standard_option(G_OPT_DB_COLUMN);
rotcolumn_opt->key = "rotation_column";
rotcolumn_opt->guisection = _("Symbols");
rotcolumn_opt->label =
_("Name of numeric column containing symbol rotation angle");
rotcolumn_opt->description =
_("Measured in degrees CCW from east");
icon_area_opt = G_define_option();
icon_area_opt->key = "icon_area";
icon_area_opt->type = TYPE_STRING;
icon_area_opt->required = NO;
icon_area_opt->multiple = NO;
icon_area_opt->guisection = _("Legend");
icon_area_opt->answer = "legend/area";
icon_area_opt->options = icon_files();
icon_area_opt->description = _("Area/boundary symbol for legend");
icon_line_opt = G_define_option();
icon_line_opt->key = "icon_line";
icon_line_opt->type = TYPE_STRING;
icon_line_opt->required = NO;
icon_line_opt->multiple = NO;
icon_line_opt->guisection = _("Legend");
icon_line_opt->answer = "legend/line";
icon_line_opt->options = icon_files();
icon_line_opt->description = _("Line symbol for legend");
leglab_opt = G_define_option();
leglab_opt->key = "legend_label";
leglab_opt->type = TYPE_STRING;
leglab_opt->guisection = _("Legend");
leglab_opt->description = _("Label to display after symbol in vector legend");
/* Labels */
lfield_opt = G_define_standard_option(G_OPT_V_FIELD);
lfield_opt->key = "label_layer";
lfield_opt->required = NO;
lfield_opt->guisection = _("Labels");
lfield_opt->label =
_("Layer number for labels (default: the given layer number)");
attrcol_opt = G_define_standard_option(G_OPT_DB_COLUMN);
attrcol_opt->key = "attribute_column";
attrcol_opt->multiple = NO; /* or fix attr.c, around line 102 */
attrcol_opt->guisection = _("Labels");
attrcol_opt->description = _("Name of column to be displayed as a label");
lcolor_opt = G_define_standard_option(G_OPT_C);
lcolor_opt->key = "label_color";
lcolor_opt->answer = "red";
lcolor_opt->label = _("Label color");
lcolor_opt->guisection = _("Labels");
bgcolor_opt = G_define_standard_option(G_OPT_CN);
bgcolor_opt->key = "label_bgcolor";
bgcolor_opt->answer = "none";
bgcolor_opt->guisection = _("Labels");
bgcolor_opt->label = _("Label background color");
bcolor_opt = G_define_standard_option(G_OPT_CN);
bcolor_opt->key = "label_bcolor";
bcolor_opt->type = TYPE_STRING;
bcolor_opt->answer = "none";
bcolor_opt->guisection = _("Labels");
bcolor_opt->label = _("Label border color");
lsize_opt = G_define_option();
lsize_opt->key = "label_size";
lsize_opt->type = TYPE_INTEGER;
lsize_opt->answer = "8";
lsize_opt->guisection = _("Labels");
lsize_opt->description = _("Label size (pixels)");
font_opt = G_define_option();
font_opt->key = "font";
font_opt->type = TYPE_STRING;
font_opt->guisection = _("Labels");
font_opt->description = _("Font name");
enc_opt = G_define_option();
enc_opt->key = "encoding";
enc_opt->type = TYPE_STRING;
enc_opt->guisection = _("Labels");
enc_opt->description = _("Text encoding");
xref_opt = G_define_option();
xref_opt->key = "xref";
xref_opt->type = TYPE_STRING;
xref_opt->guisection = _("Labels");
xref_opt->answer = "left";
xref_opt->options = "left,center,right";
xref_opt->description = _("Label horizontal justification");
yref_opt = G_define_option();
yref_opt->key = "yref";
yref_opt->type = TYPE_STRING;
yref_opt->guisection = _("Labels");
yref_opt->answer = "center";
yref_opt->options = "top,center,bottom";
yref_opt->description = _("Label vertical justification");
minreg_opt = G_define_option();
minreg_opt->key = "minreg";
minreg_opt->type = TYPE_DOUBLE;
minreg_opt->required = NO;
minreg_opt->description =
_("Minimum region size (average from height and width) "
"when map is displayed");
maxreg_opt = G_define_option();
maxreg_opt->key = "maxreg";
maxreg_opt->type = TYPE_DOUBLE;
maxreg_opt->required = NO;
maxreg_opt->description =
_("Maximum region size (average from height and width) "
"when map is displayed");
/* Colors */
cats_acolors_flag = G_define_flag();
cats_acolors_flag->key = 'c';
cats_acolors_flag->guisection = _("Colors");
cats_acolors_flag->description =
_("Random colors according to category number "
"(or layer number if 'layer=-1' is given)");
/* Query */
id_flag = G_define_flag();
id_flag->key = 'i';
id_flag->guisection = _("Selection");
id_flag->description = _("Use values from 'cats' option as feature id");
sqrt_flag = G_define_flag();
sqrt_flag->key = 'r';
sqrt_flag->label = _("Use square root of the value of size_column");
sqrt_flag->description =
_("This makes circle areas proportionate to the size_column values "
"instead of circle radius");
sqrt_flag->guisection = _("Symbols");
legend_flag = G_define_flag();
legend_flag->key = 's';
legend_flag->label = _("Do not show this layer in vector legend");
legend_flag->guisection = _("Legend");
/* Check command line */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
D_open_driver();
G_get_set_window(&window);
/* Check min/max region */
reg = ((window.east - window.west) + (window.north - window.south)) / 2;
if (minreg_opt->answer) {
minreg = atof(minreg_opt->answer);
if (reg < minreg) {
G_important_message(_("Region size is lower than minreg, nothing displayed"));
exit(EXIT_SUCCESS);
}
}
if (maxreg_opt->answer) {
maxreg = atof(maxreg_opt->answer);
if (reg > maxreg) {
G_important_message(_("Region size is greater than maxreg, nothing displayed"));
exit(EXIT_SUCCESS);
}
}
strcpy(map_name, map_opt->answer);
default_width = atoi(width_opt->answer);
if (default_width < 0)
default_width = 0;
width_scale = atof(wscale_opt->answer);
if (cats_acolors_flag->answer && rgbcol_opt->answer) {
G_warning(_("The -%c flag and <%s> option cannot be used together, "
"the -%c flag will be ignored!"),
cats_acolors_flag->key, rgbcol_opt->key, cats_acolors_flag->key);
cats_acolors_flag->answer = FALSE;
}
color = G_standard_color_rgb(WHITE);
has_color = option_to_color(&color, color_opt->answer);
fcolor = G_standard_color_rgb(WHITE);
has_fcolor = option_to_color(&fcolor, fcolor_opt->answer);
size = atof(size_opt->answer);
/* if where_opt was specified select categories from db
* otherwise parse cat_opt */
Clist = Vect_new_cat_list();
Clist->field = atoi(field_opt->answer);
/* open vector */
level = Vect_open_old2(&Map, map_name, "", field_opt->answer);
chcat = 0;
if (where_opt->answer) {
if (Clist->field < 1)
G_fatal_error(_("Option <%s> must be > 0"), field_opt->key);
chcat = 1;
option_to_where(&Map, Clist, where_opt->answer);
}
else if (cat_opt->answer) {
if (Clist->field < 1 && !id_flag->answer)
G_fatal_error(_("Option <%s> must be > 0"), field_opt->key);
chcat = 1;
ret = Vect_str_to_cat_list(cat_opt->answer, Clist);
if (ret > 0)
G_warning(n_("%d error in cat option", "%d errors in cat option", ret), ret);
}
type = Vect_option_to_types(type_opt);
display = option_to_display(display_opt);
/* labels */
options_to_lattr(&lattr, lfield_opt->answer,
lcolor_opt->answer, bgcolor_opt->answer, bcolor_opt->answer,
atoi(lsize_opt->answer), font_opt->answer, enc_opt->answer,
xref_opt->answer, yref_opt->answer);
D_setup(0);
D_set_reduction(1.0);
G_verbose_message(_("Plotting..."));
if (level >= 2)
Vect_get_map_box(&Map, &box);
if (level >= 2 && (window.north < box.S || window.south > box.N ||
window.east < box.W ||
window.west > G_adjust_easting(box.E, &window))) {
G_warning(_("The bounding box of the map is outside the current region, "
"nothing drawn"));
}
else {
overlap = G_window_percentage_overlap(&window, box.N, box.S,
box.E, box.W);
G_debug(1, "overlap = %f \n", overlap);
if (overlap < 1)
Vect_set_constraint_region(&Map, window.north, window.south,
window.east, window.west,
PORT_DOUBLE_MAX, -PORT_DOUBLE_MAX);
/* default line width */
if (!wcolumn_opt->answer)
D_line_width(default_width);
if (display & DISP_SHAPE) {
stat += display_shape(&Map, type, Clist, &window,
has_color ? &color : NULL, has_fcolor ? &fcolor : NULL, chcat,
icon_opt->answer, size, sizecolumn_opt->answer,
sqrt_flag->answer ? TRUE : FALSE, rotcolumn_opt->answer,
id_flag->answer ? TRUE : FALSE,
cats_acolors_flag->answer ? TRUE : FALSE, rgbcol_opt->answer,
default_width, wcolumn_opt->answer, width_scale,
zcol_opt->answer);
if (wcolumn_opt->answer)
D_line_width(default_width);
}
if (has_color) {
D_RGB_color(color.r, color.g, color.b);
if (display & DISP_DIR)
stat += display_dir(&Map, type, Clist, chcat, size);
}
if (!legend_flag->answer) {
write_into_legfile(&Map, type, leglab_opt->answer, map_name,
icon_opt->answer, size_opt->answer,
color_opt->answer, fcolor_opt->answer,
width_opt->answer, icon_area_opt->answer,
icon_line_opt->answer, sizecolumn_opt->answer);
}
/* reset line width: Do we need to get line width from display
* driver (not implemented)? It will help restore previous line
* width (not just 0) determined by another module (e.g.,
* d.linewidth). */
if (!wcolumn_opt->answer)
D_line_width(0);
if (display & DISP_CAT)
stat += display_label(&Map, type, Clist, &lattr, chcat);
if (attrcol_opt->answer)
stat += display_attr(&Map, type, attrcol_opt->answer, Clist, &lattr, chcat);
if (display & DISP_ZCOOR)
stat += display_zcoor(&Map, type, &lattr);
if (display & DISP_VERT)
stat += display_vert(&Map, type, &lattr, size);
if (display & DISP_TOPO)
stat += display_topo(&Map, type, &lattr, size);
}
D_save_command(G_recreate_command());
D_close_driver();
Vect_close(&Map);
Vect_destroy_cat_list(Clist);
if (stat != 0) {
G_fatal_error(_("Rendering failed"));
}
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
struct GModule *module;
struct Option *input, *output, *field;
struct Flag *all, *flat;
struct Cell_head window;
char *sitefile;
struct Map_info Map;
struct Point *points; /* point loaded from site file */
int *hull; /* index of points located on the convex hull */
int numSitePoints, numHullPoints;
int MODE2D;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("geometry"));
module->description =
_("Produces a convex hull for a given vector map.");
input = G_define_standard_option(G_OPT_V_INPUT);
field = G_define_standard_option(G_OPT_V_FIELD_ALL);
output = G_define_standard_option(G_OPT_V_OUTPUT);
all = G_define_flag();
all->key = 'a';
all->description =
_("Use all vector points (do not limit to current region)");
flat = G_define_flag();
flat->key = 'f';
flat->description =
_("Create a 'flat' 2D hull even if the input is 3D points");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
sitefile = input->answer;
Vect_check_input_output_name(input->answer, output->answer,
GV_FATAL_EXIT);
Vect_set_open_level(1);
if (Vect_open_old2(&Map, sitefile, "", field->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), sitefile);
/* load site coordinates */
G_get_window(&window);
numSitePoints = loadSiteCoordinates(&Map, &points, all->answer, &window,
Vect_get_field_number(&Map, field->answer));
if (numSitePoints < 0)
G_fatal_error(_("Error loading vector points from <%s>"), sitefile);
if (numSitePoints < 3)
G_fatal_error(_("Convex hull calculation requires at least three points (%d found)"), numSitePoints);
G_verbose_message(_("%d points read from vector map <%s>"), sitefile);
/* create a 2D or a 3D hull? */
MODE2D = 1;
if (Vect_is_3d(&Map)) {
MODE2D = 0;
}
if (flat->answer) {
MODE2D = 1;
}
/* create vector map */
if (0 > Vect_open_new(&Map, output->answer, MODE2D ? WITHOUT_Z : WITH_Z)) {
G_fatal_error(_("Unable to create vector map <%s>"), output->answer);
}
Vect_hist_command(&Map);
if (MODE2D) {
/* compute convex hull */
numHullPoints = convexHull(points, numSitePoints, &hull);
/* output vector map */
outputHull(&Map, points, hull, numHullPoints);
}
else {
/* this does everything for the 3D hull including vector map creation */
convexHull3d(points, numSitePoints, &Map);
}
/* clean up and bye bye */
Vect_build(&Map);
Vect_close(&Map);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct Option *vector_opt, *seed_opt, *flowlines_opt, *flowacc_opt, *sampled_opt,
*scalar_opt, *unit_opt, *step_opt, *limit_opt, *skip_opt, *dir_opt,
*error_opt;
struct Flag *table_fl;
struct GModule *module;
RASTER3D_Region region;
RASTER3D_Map *flowacc, *sampled;
struct Integration integration;
struct Seed seed;
struct Gradient_info gradient_info;
struct Map_info seed_Map;
struct line_pnts *seed_points;
struct line_cats *seed_cats;
struct Map_info fl_map;
struct line_cats *fl_cats; /* for flowlines */
struct line_pnts *fl_points; /* for flowlines */
struct field_info *finfo;
dbDriver *driver;
int cat; /* cat of flowlines */
int if_table;
int i, r, c, d;
char *desc;
int n_seeds, seed_count, ltype;
int skip[3];
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster3d"));
G_add_keyword(_("hydrology"));
G_add_keyword(_("voxel"));
module->description =
_("Computes 3D flow lines and 3D flow accumulation.");
scalar_opt = G_define_standard_option(G_OPT_R3_INPUT);
scalar_opt->required = NO;
scalar_opt->guisection = _("Input");
vector_opt = G_define_standard_option(G_OPT_R3_INPUTS);
vector_opt->key = "vector_field";
vector_opt->required = NO;
vector_opt->description = _("Names of three 3D raster maps describing "
"x, y, z components of vector field");
vector_opt->guisection = _("Input");
seed_opt = G_define_standard_option(G_OPT_V_INPUT);
seed_opt->required = NO;
seed_opt->key = "seed_points";
seed_opt->description = _("If no map is provided, "
"flow lines are generated "
"from each cell of the input 3D raster");
seed_opt->label = _("Name of vector map with points "
"from which flow lines are generated");
seed_opt->guisection = _("Input");
flowlines_opt = G_define_standard_option(G_OPT_V_OUTPUT);
flowlines_opt->key = "flowline";
flowlines_opt->required = NO;
flowlines_opt->description = _("Name for vector map of flow lines");
flowlines_opt->guisection = _("Output");
flowacc_opt = G_define_standard_option(G_OPT_R3_OUTPUT);
flowacc_opt->key = "flowaccumulation";
flowacc_opt->required = NO;
flowacc_opt->description =
_("Name for output flowaccumulation 3D raster");
flowacc_opt->guisection = _("Output");
sampled_opt = G_define_standard_option(G_OPT_R3_INPUT);
sampled_opt->key = "sampled";
sampled_opt->required = NO;
sampled_opt->label =
_("Name for 3D raster sampled by flowlines");
sampled_opt->description =
_("Values of this 3D raster will be stored "
"as attributes of flowlines segments");
unit_opt = G_define_option();
unit_opt->key = "unit";
unit_opt->type = TYPE_STRING;
unit_opt->required = NO;
unit_opt->answer = "cell";
unit_opt->options = "time,length,cell";
desc = NULL;
G_asprintf(&desc,
"time;%s;"
"length;%s;"
"cell;%s",
_("elapsed time"),
_("length in map units"), _("length in cells (voxels)"));
unit_opt->descriptions = desc;
unit_opt->label = _("Unit of integration step");
unit_opt->description = _("Default unit is cell");
unit_opt->guisection = _("Integration");
step_opt = G_define_option();
step_opt->key = "step";
step_opt->type = TYPE_DOUBLE;
step_opt->required = NO;
step_opt->answer = "0.25";
step_opt->label = _("Integration step in selected unit");
step_opt->description = _("Default step is 0.25 cell");
step_opt->guisection = _("Integration");
limit_opt = G_define_option();
limit_opt->key = "limit";
limit_opt->type = TYPE_INTEGER;
limit_opt->required = NO;
limit_opt->answer = "2000";
limit_opt->description = _("Maximum number of steps");
limit_opt->guisection = _("Integration");
error_opt = G_define_option();
error_opt->key = "max_error";
error_opt->type = TYPE_DOUBLE;
error_opt->required = NO;
error_opt->answer = "1e-5";
error_opt->label = _("Maximum error of integration");
error_opt->description = _("Influences step, increase maximum error "
"to allow bigger steps");
error_opt->guisection = _("Integration");
skip_opt = G_define_option();
skip_opt->key = "skip";
skip_opt->type = TYPE_INTEGER;
skip_opt->required = NO;
skip_opt->multiple = YES;
skip_opt->description =
_("Number of cells between flow lines in x, y and z direction");
dir_opt = G_define_option();
dir_opt->key = "direction";
dir_opt->type = TYPE_STRING;
dir_opt->required = NO;
dir_opt->multiple = NO;
dir_opt->options = "up,down,both";
dir_opt->answer = "down";
dir_opt->description = _("Compute flowlines upstream, "
"downstream or in both direction.");
table_fl = G_define_flag();
table_fl->key = 'a';
table_fl->description = _("Create and fill attribute table");
G_option_required(scalar_opt, vector_opt, NULL);
G_option_exclusive(scalar_opt, vector_opt, NULL);
G_option_required(flowlines_opt, flowacc_opt, NULL);
G_option_requires(seed_opt, flowlines_opt, NULL);
G_option_requires(table_fl, flowlines_opt, NULL);
G_option_requires(sampled_opt, table_fl, NULL);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
driver = NULL;
finfo = NULL;
if_table = table_fl->answer ? TRUE : FALSE;
check_vector_input_maps(vector_opt, seed_opt);
Rast3d_init_defaults();
Rast3d_get_window(®ion);
/* set up integration variables */
if (step_opt->answer) {
integration.step = atof(step_opt->answer);
integration.unit = unit_opt->answer;
}
else {
integration.unit = "cell";
integration.step = 0.25;
}
integration.max_error = atof(error_opt->answer);
integration.max_step = 5 * integration.step;
integration.min_step = integration.step / 5;
integration.limit = atof(limit_opt->answer);
if (strcmp(dir_opt->answer, "up") == 0)
integration.direction_type = FLOWDIR_UP;
else if (strcmp(dir_opt->answer, "down") == 0)
integration.direction_type = FLOWDIR_DOWN;
else
integration.direction_type = FLOWDIR_BOTH;
/* cell size is the diagonal */
integration.cell_size = sqrt(region.ns_res * region.ns_res +
region.ew_res * region.ew_res +
region.tb_res * region.tb_res);
/* set default skip if needed */
if (skip_opt->answers) {
for (i = 0; i < 3; i++) {
if (skip_opt->answers[i] != NULL) {
skip[i] = atoi(skip_opt->answers[i]);
}
else {
G_fatal_error(_("Please provide 3 integer values for skip option."));
}
}
}
else {
skip[0] = fmax(1, region.cols / 10);
skip[1] = fmax(1, region.rows / 10);
skip[2] = fmax(1, region.depths / 10);
}
/* open raster 3D maps of velocity components */
gradient_info.initialized = FALSE;
load_input_raster3d_maps(scalar_opt, vector_opt, &gradient_info, ®ion);
/* open new 3D raster map of flowacumulation */
if (flowacc_opt->answer) {
flowacc = Rast3d_open_new_opt_tile_size(flowacc_opt->answer,
RASTER3D_USE_CACHE_DEFAULT,
®ion, FCELL_TYPE, 32);
if (!flowacc)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"),
flowacc_opt->answer);
init_flowaccum(®ion, flowacc);
}
/* open 3D raster map used for sampling */
if (sampled_opt->answer) {
sampled = Rast3d_open_cell_old(sampled_opt->answer,
G_find_raster3d(sampled_opt->answer, ""),
®ion, RASTER3D_TILE_SAME_AS_FILE,
RASTER3D_USE_CACHE_DEFAULT);
if (!sampled)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"),
sampled_opt->answer);
}
else
sampled = NULL;
/* open new vector map of flowlines */
if (flowlines_opt->answer) {
fl_cats = Vect_new_cats_struct();
fl_points = Vect_new_line_struct();
if (Vect_open_new(&fl_map, flowlines_opt->answer, TRUE) < 0)
G_fatal_error(_("Unable to create vector map <%s>"),
flowlines_opt->answer);
Vect_hist_command(&fl_map);
if (if_table) {
create_table(&fl_map, &finfo, &driver,
gradient_info.compute_gradient, sampled ? 1 : 0);
}
}
n_seeds = 0;
/* open vector map of seeds */
if (seed_opt->answer) {
if (Vect_open_old2(&seed_Map, seed_opt->answer, "", "1") < 0)
G_fatal_error(_("Unable to open vector map <%s>"),
seed_opt->answer);
if (!Vect_is_3d(&seed_Map))
G_fatal_error(_("Vector map <%s> is not 3D"), seed_opt->answer);
n_seeds = Vect_get_num_primitives(&seed_Map, GV_POINT);
}
if (flowacc_opt->answer || (!seed_opt->answer && flowlines_opt->answer)) {
if (flowacc_opt->answer)
n_seeds += region.cols * region.rows * region.depths;
else {
n_seeds += ceil(region.cols / (double)skip[0]) *
ceil(region.rows / (double)skip[1]) *
ceil(region.depths / (double)skip[2]);
}
}
G_debug(1, "Number of seeds is %d", n_seeds);
seed_count = 0;
cat = 1;
if (seed_opt->answer) {
seed_points = Vect_new_line_struct();
seed_cats = Vect_new_cats_struct();
/* compute flowlines from vector seed map */
while (TRUE) {
ltype = Vect_read_next_line(&seed_Map, seed_points, seed_cats);
if (ltype == -1) {
Vect_close(&seed_Map);
G_fatal_error(_("Error during reading seed vector map"));
}
else if (ltype == -2) {
break;
}
else if (ltype == GV_POINT) {
seed.x = seed_points->x[0];
seed.y = seed_points->y[0];
seed.z = seed_points->z[0];
seed.flowline = TRUE;
seed.flowaccum = FALSE;
}
G_percent(seed_count, n_seeds, 1);
if (integration.direction_type == FLOWDIR_UP ||
integration.direction_type == FLOWDIR_BOTH) {
integration.actual_direction = FLOWDIR_UP;
compute_flowline(®ion, &seed, &gradient_info, flowacc, sampled,
&integration, &fl_map, fl_cats, fl_points,
&cat, if_table, finfo, driver);
}
if (integration.direction_type == FLOWDIR_DOWN ||
integration.direction_type == FLOWDIR_BOTH) {
integration.actual_direction = FLOWDIR_DOWN;
compute_flowline(®ion, &seed, &gradient_info, flowacc, sampled,
&integration, &fl_map, fl_cats, fl_points,
&cat, if_table, finfo, driver);
}
seed_count++;
}
Vect_destroy_line_struct(seed_points);
Vect_destroy_cats_struct(seed_cats);
Vect_close(&seed_Map);
}
if (flowacc_opt->answer || (!seed_opt->answer && flowlines_opt->answer)) {
/* compute flowlines from points on grid */
for (r = region.rows; r > 0; r--) {
for (c = 0; c < region.cols; c++) {
for (d = 0; d < region.depths; d++) {
seed.x =
region.west + c * region.ew_res + region.ew_res / 2;
seed.y =
region.south + r * region.ns_res - region.ns_res / 2;
seed.z =
region.bottom + d * region.tb_res + region.tb_res / 2;
seed.flowline = FALSE;
seed.flowaccum = FALSE;
if (flowacc_opt->answer)
seed.flowaccum = TRUE;
if (flowlines_opt->answer && !seed_opt->answer &&
(c % skip[0] == 0) && (r % skip[1] == 0) && (d % skip[2] == 0))
seed.flowline = TRUE;
if (seed.flowaccum || seed.flowline) {
G_percent(seed_count, n_seeds, 1);
if (integration.direction_type == FLOWDIR_UP ||
integration.direction_type == FLOWDIR_BOTH) {
integration.actual_direction = FLOWDIR_UP;
compute_flowline(®ion, &seed, &gradient_info,
flowacc, sampled, &integration, &fl_map,
fl_cats, fl_points, &cat,
if_table, finfo, driver);
}
if (integration.direction_type == FLOWDIR_DOWN ||
integration.direction_type == FLOWDIR_BOTH) {
integration.actual_direction = FLOWDIR_DOWN;
compute_flowline(®ion, &seed, &gradient_info,
flowacc, sampled, &integration, &fl_map,
fl_cats, fl_points, &cat,
if_table, finfo, driver);
}
seed_count++;
}
}
}
}
}
G_percent(1, 1, 1);
if (flowlines_opt->answer) {
if (if_table) {
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
}
Vect_destroy_line_struct(fl_points);
Vect_destroy_cats_struct(fl_cats);
Vect_build(&fl_map);
Vect_close(&fl_map);
}
if (flowacc_opt->answer)
Rast3d_close(flowacc);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
struct Map_info In, Out;
static struct line_pnts *Points;
struct line_cats *Cats;
struct field_info *Fi;
struct cat_list *Clist;
int i, j, ret, option, otype, type, with_z, step, id;
int n_areas, centr, new_centr, nmodified;
int open_level;
double x, y;
int cat, ocat, scat, *fields, nfields, field;
struct GModule *module;
struct Option *in_opt, *out_opt, *option_opt, *type_opt;
struct Option *cat_opt, *field_opt, *step_opt, *id_opt;
struct Flag *shell, *notab;
FREPORT **freps;
int nfreps, rtype, fld;
char *desc;
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("category"));
G_add_keyword(_("layer"));
module->description =
_("Attaches, deletes or reports vector categories to map geometry.");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
field_opt = G_define_standard_option(G_OPT_V_FIELD);
field_opt->multiple = YES;
field_opt->guisection = _("Selection");
type_opt = G_define_standard_option(G_OPT_V3_TYPE);
type_opt->answer = "point,line,centroid,face";
type_opt->guisection = _("Selection");
id_opt = G_define_standard_option(G_OPT_V_IDS);
id_opt->label = _("Feature ids (by default all features are processed)");
id_opt->guisection = _("Selection");
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
out_opt->required = NO;
option_opt = G_define_option();
option_opt->key = "option";
option_opt->type = TYPE_STRING;
option_opt->required = YES;
option_opt->multiple = NO;
option_opt->options = "add,del,chlayer,sum,report,print,layers,transfer";
option_opt->description = _("Action to be done");
desc = NULL;
G_asprintf(&desc,
"add;%s;"
"del;%s;"
"chlayer;%s;"
"sum;%s;"
"transfer;%s;"
"report;%s;"
"print;%s;"
"layers;%s",
_("add a category to features without category in the given layer"),
_("delete category (cat=-1 to delete all categories of given layer)"),
_("change layer number (e.g. layer=3,1 changes layer 3 to layer 1)"),
_("add the value specified by cat option to the current category value"),
_("copy values from one layer to another (e.g. layer=1,2,3 copies values from layer 1 to layer 2 and 3)"),
_("print report (statistics), in shell style: layer type count min max"),
_("print category values, layers are separated by '|', more cats in the same layer are separated by '/'"),
_("print only layer numbers"));
option_opt->descriptions = desc;
cat_opt = G_define_standard_option(G_OPT_V_CAT);
cat_opt->answer = "1";
step_opt = G_define_option();
step_opt->key = "step";
step_opt->type = TYPE_INTEGER;
step_opt->required = NO;
step_opt->multiple = NO;
step_opt->answer = "1";
step_opt->description = _("Category increment");
shell = G_define_flag();
shell->key = 'g';
shell->label = _("Shell script style, currently only for report");
shell->description = _("Format: layer type count min max");
notab = G_define_standard_flag(G_FLG_V_TABLE);
notab->description = _("Do not copy attribute table(s)");
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* read options */
option = 0;
switch (option_opt->answer[0]) {
case ('a'):
option = O_ADD;
break;
case ('d'):
option = O_DEL;
break;
case ('c'):
option = O_CHFIELD;
G_warning(_("Database connection and attribute tables for concerned layers are not changed"));
break;
case ('s'):
option = O_SUM;
break;
case ('t'):
option = O_TRANS;
break;
case ('r'):
option = O_REP;
break;
case ('p'):
option = O_PRN;
break;
case ('l'):
option = O_LYR;
break;
}
if (option == O_LYR) {
/* print vector layer numbers */
/* open vector on level 2 head only, this is why this option
* is processed here, all other options need (?) to fully open
* the input vector */
Vect_set_open_level(2);
if (Vect_open_old_head2(&In, in_opt->answer, "", field_opt->answer) < 2) {
G_fatal_error(_("Unable to open vector map <%s> at topological level %d"),
Vect_get_full_name(&In), 2);
}
if (In.format == GV_FORMAT_NATIVE) {
nfields = Vect_cidx_get_num_fields(&In);
for (i = 0; i < nfields; i++) {
if ((field = Vect_cidx_get_field_number(&In, i)) > 0)
fprintf(stdout, "%d\n", field);
}
}
else
fprintf(stdout, "%s\n", field_opt->answer);
Vect_close(&In);
exit(EXIT_SUCCESS);
}
cat = atoi(cat_opt->answer);
step = atoi(step_opt->answer);
otype = Vect_option_to_types(type_opt);
if (cat < 0 && option == O_ADD)
G_fatal_error(_("Invalid category number (must be equal to or greater than 0). "
"Normally category number starts at 1."));
/* collect ids */
if (id_opt->answer) {
Clist = Vect_new_cat_list();
Clist->field = atoi(field_opt->answer);
ret = Vect_str_to_cat_list(id_opt->answer, Clist);
if (ret > 0) {
G_warning(n_("%d error in id option",
"%d errors in id option",
ret), ret);
}
}
else {
Clist = NULL;
}
if ((option != O_REP) && (option != O_PRN) && (option != O_LYR)) {
if (out_opt->answer == NULL)
G_fatal_error(_("Output vector wasn't entered"));
Vect_check_input_output_name(in_opt->answer, out_opt->answer,
G_FATAL_EXIT);
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
/* do we need topology ? */
if ((option == O_ADD && (otype & GV_AREA)) ||
(option == O_REP && (otype & GV_AREA)) ||
(option == O_TRANS) || /* topo for cidx check */
(option == O_LYR)) /* topo for cidx check */
open_level = 2;
else
open_level = 1;
/* open input vector */
if (open_level > 1) {
Vect_set_open_level(open_level);
if (Vect_open_old2(&In, in_opt->answer, "", field_opt->answer) < open_level) {
G_warning(_("Unable to open vector map <%s> at topological level %d"),
Vect_get_full_name(&In), open_level);
open_level = 1;
}
}
if (open_level == 1) {
Vect_set_open_level(open_level);
if (Vect_open_old2(&In, in_opt->answer, "", field_opt->answer) < open_level) {
G_fatal_error(_("Unable to open vector map <%s> at topological level %d"),
Vect_get_full_name(&In), open_level);
}
}
/* read fields */
i = nfields = 0;
while (field_opt->answers[i++])
nfields++;
fields = (int *)G_malloc(nfields * sizeof(int));
i = 0;
while (field_opt->answers[i]) {
fields[i] = Vect_get_field_number(&In, field_opt->answers[i]);
i++;
}
if (nfields > 1 && option != O_PRN && option != O_CHFIELD && option != O_TRANS)
G_fatal_error(_("Too many layers for this operation"));
if (nfields != 2 && option == O_CHFIELD)
G_fatal_error(_("2 layers must be specified"));
if (option == O_TRANS && open_level == 1 && nfields < 2) {
G_fatal_error(_("2 layers must be specified"));
}
if (option == O_TRANS && open_level > 1) {
/* check if field[>0] already exists */
if (nfields > 1) {
for(i = 1; i < nfields; i++) {
if (Vect_cidx_get_field_index(&In, fields[i]) != -1)
G_warning(_("Categories already exist in layer %d"), fields[i]);
}
}
/* find next free layer number */
else if (nfields == 1) {
int max = -1;
for (i = 0; i < Vect_cidx_get_num_fields(&In); i++) {
if (max < Vect_cidx_get_field_number(&In, i))
max = Vect_cidx_get_field_number(&In, i);
}
max++;
nfields++;
fields = (int *)G_realloc(fields, nfields * sizeof(int));
fields[nfields - 1] = max;
}
}
if (otype & GV_AREA && option == O_TRANS && !(otype & GV_CENTROID))
otype |= GV_CENTROID;
/* open output vector if needed */
if (option == O_ADD || option == O_DEL || option == O_CHFIELD ||
option == O_SUM || option == O_TRANS) {
with_z = Vect_is_3d(&In);
if (0 > Vect_open_new(&Out, out_opt->answer, with_z)) {
Vect_close(&In);
exit(EXIT_FAILURE);
}
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
}
id = 0;
nmodified = 0;
if (option == O_ADD || option == O_DEL || option == O_CHFIELD ||
option == O_SUM || option == O_TRANS) {
G_message(_("Processing features..."));
}
switch (option) {
case (O_ADD):
/* Lines */
while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) {
id++;
if (type & otype && (!Clist ||
(Clist &&
Vect_cat_in_cat_list(id, Clist) == TRUE))) {
if ((Vect_cat_get(Cats, fields[0], &ocat)) == 0) {
if (ocat < 0) {
if (Vect_cat_set(Cats, fields[0], cat) > 0) {
nmodified++;
}
cat += step;
}
}
}
Vect_write_line(&Out, type, Points, Cats);
}
/* Areas */
if ((otype & GV_AREA) && open_level > 1) {
n_areas = Vect_get_num_areas(&In);
new_centr = 0;
for (i = 1; i <= n_areas; i++) {
centr = Vect_get_area_centroid(&In, i);
if (centr > 0)
continue; /* Centroid exists and may be processed as line */
ret = Vect_get_point_in_area(&In, i, &x, &y);
if (ret < 0) {
G_warning(_("Unable to calculate area centroid"));
continue;
}
Vect_reset_line(Points);
Vect_reset_cats(Cats);
Vect_append_point(Points, x, y, 0.0);
if (Vect_cat_set(Cats, fields[0], cat) > 0) {
nmodified++;
}
cat += step;
Vect_write_line(&Out, GV_CENTROID, Points, Cats);
new_centr++;
}
if (new_centr > 0)
G_message(n_("%d new centroid placed in output map",
"%d new centroids placed in output map",
new_centr), new_centr);
}
break;
case (O_TRANS):
/* Lines */
while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) {
id++;
if (type & otype && (!Clist ||
(Clist &&
Vect_cat_in_cat_list(id, Clist) == TRUE))) {
int n = Cats->n_cats;
scat = -1;
for (i = 0; i < n; i++) {
if (Cats->field[i] == fields[0]) {
scat = Cats->cat[i];
for (j = 1; j < nfields; j++) {
if (Vect_cat_set(Cats, fields[j], scat) > 0) {
G_debug(4, "Copy cat %i of field %i to field %i", scat, fields[0], fields[j]);
}
}
}
}
if (scat != -1)
nmodified++;
}
Vect_write_line(&Out, type, Points, Cats);
}
break;
case (O_DEL):
while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) {
id++;
if (type & otype && (!Clist ||
(Clist &&
Vect_cat_in_cat_list(id, Clist) == TRUE))) {
ret = Vect_field_cat_del(Cats, fields[0], cat);
if (ret > 0) {
nmodified++;
}
}
Vect_write_line(&Out, type, Points, Cats);
}
break;
case (O_CHFIELD):
while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) {
id++;
if (type & otype && (!Clist ||
(Clist &&
Vect_cat_in_cat_list(id, Clist) == TRUE))) {
i = 0;
while (i < Cats->n_cats) {
if (Cats->field[i] == fields[0]) {
int found = -1;
/* check if cat already exists in layer fields[1] */
for (j = 0; j < Cats->n_cats; j++) {
if (Cats->field[j] == fields[1] &&
Cats->cat[j] == Cats->cat[i]) {
found = j;
break;
}
}
/* does not exist, change layer */
if (found < 0) {
Cats->field[i] = fields[1];
i++;
}
/* exists already in fields[1], delete from fields[0] */
else
Vect_field_cat_del(Cats, fields[0], Cats->cat[found]);
nmodified++;
}
}
}
Vect_write_line(&Out, type, Points, Cats);
}
break;
case (O_SUM):
while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) {
id++;
if (type & otype && (!Clist ||
(Clist &&
Vect_cat_in_cat_list(id, Clist) == TRUE))) {
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == fields[0]) {
Cats->cat[i] += cat;
}
}
nmodified++;
}
Vect_write_line(&Out, type, Points, Cats);
}
break;
case (O_REP):
nfreps = 0;
freps = NULL;
while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) {
id++;
if (Clist && Vect_cat_in_cat_list(id, Clist) == FALSE)
continue;
switch (type) {
case (GV_POINT):
rtype = FR_POINT;
break;
case (GV_LINE):
rtype = FR_LINE;
break;
case (GV_BOUNDARY):
rtype = FR_BOUNDARY;
break;
case (GV_CENTROID):
rtype = FR_CENTROID;
break;
case (GV_FACE):
rtype = FR_FACE;
break;
case (GV_KERNEL):
rtype = FR_KERNEL;
break;
default:
rtype = FR_UNKNOWN;
}
for (i = 0; i < Cats->n_cats; i++) {
field = Cats->field[i];
cat = Cats->cat[i];
ret = FALSE;
for (j = 0; j < nfreps; j++) {
if (freps[j]->field == field) {
fld = j;
ret = TRUE;
break;
}
}
if (!ret) { /* field report doesn't exist */
nfreps++;
freps =
(FREPORT **) G_realloc(freps,
nfreps * sizeof(FREPORT *));
fld = nfreps - 1;
freps[fld] = (FREPORT *) G_calloc(1, sizeof(FREPORT));
freps[fld]->field = field;
for (j = 0; j < FRTYPES; j++) {
/* cat '0' is valid category number */
freps[fld]->min[j] = -1;
}
if ((Fi = Vect_get_field(&In, field)) != NULL) {
freps[fld]->table = G_store(Fi->table);
}
else {
freps[fld]->table = '\0';
}
}
freps[fld]->count[rtype]++;
freps[fld]->count[FR_ALL]++;
if (freps[fld]->min[rtype] == -1 ||
freps[fld]->min[rtype] > cat)
freps[fld]->min[rtype] = cat;
if ((freps[fld]->max[rtype] == 0) ||
freps[fld]->max[rtype] < cat)
freps[fld]->max[rtype] = cat;
if (freps[fld]->min[FR_ALL] == -1 ||
freps[fld]->min[FR_ALL] > cat)
freps[fld]->min[FR_ALL] = cat;
if ((freps[fld]->max[FR_ALL] == 0) ||
freps[fld]->max[FR_ALL] < cat)
freps[fld]->max[FR_ALL] = cat;
}
}
/* Areas */
if ((otype & GV_AREA) && open_level > 1 && !Clist) {
n_areas = Vect_get_num_areas(&In);
for (i = 1; i <= n_areas; i++) {
int k;
centr = Vect_get_area_centroid(&In, i);
if (centr <= 0)
continue; /* Area without centroid */
Vect_read_line(&In, NULL, Cats, centr);
for (j = 0; j < Cats->n_cats; j++) {
field = Cats->field[j];
cat = Cats->cat[j];
ret = FALSE;
for (k = 0; k < nfreps; k++) {
if (freps[k]->field == field) {
fld = k;
ret = TRUE;
break;
}
}
if (!ret) { /* field report doesn't exist */
nfreps++;
freps =
(FREPORT **) G_realloc(freps,
nfreps * sizeof(FREPORT *));
fld = nfreps - 1;
freps[fld] = (FREPORT *) G_calloc(1, sizeof(FREPORT));
freps[fld]->field = field;
for (j = 0; j < FRTYPES; j++) {
/* cat '0' is valid category number */
freps[fld]->min[k] = -1;
}
if ((Fi = Vect_get_field(&In, field)) != NULL) {
freps[fld]->table = G_store(Fi->table);
}
else {
freps[fld]->table = '\0';
}
}
freps[fld]->count[FR_AREA]++;
if (freps[fld]->min[FR_AREA] == -1 ||
freps[fld]->min[FR_AREA] > cat)
freps[fld]->min[FR_AREA] = cat;
if ((freps[fld]->max[FR_AREA] == 0) ||
freps[fld]->max[FR_AREA] < cat)
freps[fld]->max[FR_AREA] = cat;
}
}
}
for (i = 0; i < nfreps; i++) {
if (shell->answer) {
if (freps[i]->count[FR_POINT] > 0)
fprintf(stdout, "%d point %d %d %d\n", freps[i]->field,
freps[i]->count[FR_POINT],
(freps[i]->min[FR_POINT] < 0 ? 0 : freps[i]->min[FR_POINT]),
freps[i]->max[FR_POINT]);
if (freps[i]->count[FR_LINE] > 0)
fprintf(stdout, "%d line %d %d %d\n", freps[i]->field,
freps[i]->count[FR_LINE],
(freps[i]->min[FR_LINE] < 0 ? 0 : freps[i]->min[FR_LINE]),
freps[i]->max[FR_LINE]);
if (freps[i]->count[FR_BOUNDARY] > 0)
fprintf(stdout, "%d boundary %d %d %d\n", freps[i]->field,
freps[i]->count[FR_BOUNDARY],
(freps[i]->min[FR_BOUNDARY] < 0 ? 0 : freps[i]->min[FR_BOUNDARY]),
freps[i]->max[FR_BOUNDARY]);
if (freps[i]->count[FR_CENTROID] > 0)
fprintf(stdout, "%d centroid %d %d %d\n", freps[i]->field,
freps[i]->count[FR_CENTROID],
(freps[i]->min[FR_BOUNDARY] < 0 ? 0 : freps[i]->min[FR_BOUNDARY]),
freps[i]->max[FR_CENTROID]);
if (freps[i]->count[FR_AREA] > 0)
fprintf(stdout, "%d area %d %d %d\n", freps[i]->field,
freps[i]->count[FR_AREA],
(freps[i]->min[FR_AREA] < 0 ? 0 : freps[i]->min[FR_AREA]),
freps[i]->max[FR_AREA]);
if (freps[i]->count[FR_FACE] > 0)
fprintf(stdout, "%d face %d %d %d\n", freps[i]->field,
freps[i]->count[FR_FACE],
(freps[i]->min[FR_FACE] < 0 ? 0 : freps[i]->min[FR_FACE]),
freps[i]->max[FR_FACE]);
if (freps[i]->count[FR_KERNEL] > 0)
fprintf(stdout, "%d kernel %d %d %d\n", freps[i]->field,
freps[i]->count[FR_KERNEL],
(freps[i]->min[FR_KERNEL] < 0 ? 0 : freps[i]->min[FR_KERNEL]),
freps[i]->max[FR_KERNEL]);
if (freps[i]->count[FR_ALL] > 0)
fprintf(stdout, "%d all %d %d %d\n", freps[i]->field,
freps[i]->count[FR_ALL],
(freps[i]->min[FR_ALL] < 0 ? 0 : freps[i]->min[FR_ALL]),
freps[i]->max[FR_ALL]);
}
else {
if (freps[i]->table != '\0') {
fprintf(stdout, "%s: %d/%s\n", _("Layer/table"),
freps[i]->field, freps[i]->table);
}
else {
fprintf(stdout, "%s: %d\n", _("Layer"), freps[i]->field);
}
fprintf(stdout, _("type count min max\n"));
fprintf(stdout, "%s %7d %10d %10d\n", _("point"),
freps[i]->count[FR_POINT],
(freps[i]->min[FR_POINT] < 0) ? 0 : freps[i]->min[FR_POINT],
freps[i]->max[FR_POINT]);
fprintf(stdout, "%s %7d %10d %10d\n", _("line"),
freps[i]->count[FR_LINE],
(freps[i]->min[FR_LINE] < 0) ? 0 : freps[i]->min[FR_LINE],
freps[i]->max[FR_LINE]);
fprintf(stdout, "%s %7d %10d %10d\n", _("boundary"),
freps[i]->count[FR_BOUNDARY],
(freps[i]->min[FR_BOUNDARY] < 0) ? 0 : freps[i]->min[FR_BOUNDARY],
freps[i]->max[FR_BOUNDARY]);
fprintf(stdout, "%s %7d %10d %10d\n", _("centroid"),
freps[i]->count[FR_CENTROID],
(freps[i]->min[FR_CENTROID] < 0) ? 0 : freps[i]->min[FR_CENTROID],
freps[i]->max[FR_CENTROID]);
fprintf(stdout, "%s %7d %10d %10d\n", _("area"),
freps[i]->count[FR_AREA],
(freps[i]->min[FR_AREA] < 0) ? 0 : freps[i]->min[FR_AREA],
freps[i]->max[FR_AREA]);
fprintf(stdout, "%s %7d %10d %10d\n", _("face"),
freps[i]->count[FR_FACE],
(freps[i]->min[FR_FACE] < 0) ? 0 : freps[i]->min[FR_FACE],
freps[i]->max[FR_FACE]);
fprintf(stdout, "%s %7d %10d %10d\n", _("kernel"),
freps[i]->count[FR_KERNEL],
(freps[i]->min[FR_KERNEL] < 0) ? 0 : freps[i]->min[FR_KERNEL],
freps[i]->max[FR_KERNEL]);
fprintf(stdout, "%s %7d %10d %10d\n", _("all"),
freps[i]->count[FR_ALL],
(freps[i]->min[FR_ALL] < 0) ? 0 : freps[i]->min[FR_ALL],
freps[i]->max[FR_ALL]);
}
}
break;
case (O_PRN):
while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) {
id++;
int has = 0;
if (!(type & otype))
continue;
if (Clist && Vect_cat_in_cat_list(id, Clist) == FALSE)
continue;
/* Check if the line has at least one cat */
for (i = 0; i < nfields; i++) {
for (j = 0; j < Cats->n_cats; j++) {
if (Cats->field[j] == fields[i]) {
has = 1;
break;
}
}
}
if (!has)
continue;
for (i = 0; i < nfields; i++) {
int first = 1;
if (i > 0)
fprintf(stdout, "|");
for (j = 0; j < Cats->n_cats; j++) {
if (Cats->field[j] == fields[i]) {
if (!first)
fprintf(stdout, "/");
fprintf(stdout, "%d", Cats->cat[j]);
first = 0;
}
}
}
fprintf(stdout, "\n");
}
break;
}
if (option == O_ADD || option == O_DEL || option == O_CHFIELD ||
option == O_SUM || option == O_TRANS){
if (!notab->answer){
G_message(_("Copying attribute table(s)..."));
if (Vect_copy_tables(&In, &Out, 0))
G_warning(_("Failed to copy attribute table to output map"));
}
Vect_build(&Out);
Vect_close(&Out);
}
if (option == O_TRANS && nmodified > 0)
for(i = 1; i < nfields; i++)
G_important_message(_("Categories copied from layer %d to layer %d"),
fields[0], fields[i]);
if (option != O_REP && option != O_PRN)
G_done_msg(n_("%d feature modified.",
"%d features modified.",
nmodified), nmodified);
Vect_close(&In);
exit(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 read_points(const char *name, const char *field_name, const char *col, std::map<Point, Coord_type, K::Less_xy_2>& function_values,
std::vector<K::Point_2>& OutPoints)
{
int nrec, ctype = 0, npoints, field, with_z;
double x, y, z;
Point p;
struct Map_info Map;
struct field_info *Fi;
struct line_pnts *Points;
struct line_cats *Cats;
dbDriver *Driver;
dbCatValArray cvarr;
Vect_set_open_level(1); /* without topology */
if (Vect_open_old2(&Map, name, "", field_name) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), name);
field = Vect_get_field_number(&Map, field_name);
with_z = col == NULL && Vect_is_3d(&Map); /* read z-coordinates
only when column is
not defined */
if (!col) {
if (!with_z)
G_important_message(_("Input vector map <%s> is 2D - using categories to interpolate"),
Vect_get_full_name(&Map));
else
G_important_message(_("Input vector map <%s> is 3D - using z-coordinates to interpolate"),
Vect_get_full_name(&Map));
}
if (col) {
db_CatValArray_init(&cvarr);
Fi = Vect_get_field(&Map, field);
if (Fi == NULL)
G_fatal_error(_("Database connection not defined for layer %s"), field_name);
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);
nrec = db_select_CatValArray(Driver, Fi->table, Fi->key, col, NULL, &cvarr);
G_debug(3, "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"));
G_verbose_message("One record selected from table %d records selected from table", nrec);
db_close_database_shutdown_driver(Driver);
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
/* set constraints */
Vect_set_constraint_type(&Map, GV_POINTS);
if (field > 0)
Vect_set_constraint_field(&Map, field);
/* read points */
npoints = 0;
G_message(_("Reading points..."));
while(TRUE) {
double dval;
if (Vect_read_next_line(&Map, Points, Cats) < 0)
break;
G_progress(npoints, 1e3);
if (Points->n_points != 1) {
G_warning(_("Invalid point skipped"));
continue;
}
if (!with_z) {
int cat, ival, ret;
/* TODO: what to do with multiple cats */
Vect_cat_get(Cats, field, &cat);
if (cat < 0) /* skip features without category */
continue;
if (col) {
if (ctype == DB_C_TYPE_INT) {
ret = db_CatValArray_get_value_int(&cvarr, cat, &ival);
dval = ival;
}
else { /* DB_C_TYPE_DOUBLE */
ret = db_CatValArray_get_value_double(&cvarr, cat, &dval);
}
if (ret != DB_OK) {
G_warning(_("No record for point (cat = %d)"), cat);
continue;
}
}
else {
dval = cat;
}
}
else
dval = Points->z[0];
x = Points->x[0];
y = Points->y[0];
p = Point(x,y);
OutPoints.push_back(p);
function_values.insert(std::make_pair(p, dval));
G_debug(3, "new point added: %f, %f, %f", x, y, dval);
npoints++;
}
G_progress(1, 1);
if (col)
db_CatValArray_free(&cvarr);
Vect_set_release_support(&Map);
Vect_close(&Map);
Vect_destroy_line_struct(Points);
G_debug(1, "read_points(): %d", npoints);
G_message("%d point loaded", npoints);
return npoints;
}
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)
{
int i, nsites, warn_once = 0;
int all;
long x, y;
struct Cell_head window;
struct GModule *module;
struct
{
struct Option *input, *tests, *dfield, *layer;
} parm;
struct
{
struct Flag *q, *l, *region;
} flag;
double *w, *z;
struct Map_info Map;
int line, nlines, npoints;
int field;
struct line_pnts *Points;
struct line_cats *Cats;
struct bound_box box;
/* Attributes */
int nrecords;
int ctype;
struct field_info *Fi;
dbDriver *Driver;
dbCatValArray cvarr;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("statistics"));
G_add_keyword(_("points"));
G_add_keyword(_("point pattern"));
module->description = _("Tests for normality for vector points.");
parm.input = G_define_standard_option(G_OPT_V_MAP);
parm.layer = G_define_standard_option(G_OPT_V_FIELD);
parm.tests = G_define_option();
parm.tests->key = "tests";
parm.tests->key_desc = "range";
parm.tests->type = TYPE_STRING;
parm.tests->multiple = YES;
parm.tests->required = YES;
parm.tests->label = _("Lists of tests (1-15)");
parm.tests->description = _("E.g. 1,3-8,13");
parm.dfield = G_define_standard_option(G_OPT_DB_COLUMN);
parm.dfield->required = YES;
flag.region = G_define_flag();
flag.region->key = 'r';
flag.region->description = _("Use only points in current region");
flag.l = G_define_flag();
flag.l->key = 'l';
flag.l->description = _("Lognormality instead of normality");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
all = flag.region->answer ? 0 : 1;
/* Open input */
Vect_set_open_level(2);
if (Vect_open_old2(&Map, parm.input->answer, "", parm.layer->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), parm.input->answer);
field = Vect_get_field_number(&Map, parm.layer->answer);
/* Read attributes */
Fi = Vect_get_field(&Map, field);
if (Fi == NULL) {
G_fatal_error("Database connection not defined for layer %d", field);
}
Driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (Driver == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
nrecords = db_select_CatValArray(Driver, Fi->table, Fi->key, parm.dfield->answer,
NULL, &cvarr);
G_debug(1, "nrecords = %d", nrecords);
ctype = cvarr.ctype;
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Only numeric column type supported"));
if (nrecords < 0)
G_fatal_error(_("Unable to select data from table"));
G_verbose_message(_("%d records selected from table"), nrecords);
db_close_database_shutdown_driver(Driver);
/* Read points */
npoints = Vect_get_num_primitives(&Map, GV_POINT);
z = (double *)G_malloc(npoints * sizeof(double));
G_get_window(&window);
Vect_region_box(&window, &box);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
nlines = Vect_get_num_lines(&Map);
nsites = 0;
for (line = 1; line <= nlines; line++) {
int type, cat, ret, cval;
double dval;
G_debug(3, "line = %d", line);
type = Vect_read_line(&Map, Points, Cats, line);
if (!(type & GV_POINT))
continue;
if (!all) {
if (!Vect_point_in_box(Points->x[0], Points->y[0], 0.0, &box))
continue;
}
Vect_cat_get(Cats, 1, &cat);
G_debug(3, "cat = %d", cat);
/* find actual value */
if (ctype == DB_C_TYPE_INT) {
ret = db_CatValArray_get_value_int(&cvarr, cat, &cval);
if (ret != DB_OK) {
G_warning(_("No record for cat %d"), cat);
continue;
}
dval = cval;
}
else if (ctype == DB_C_TYPE_DOUBLE) {
ret = db_CatValArray_get_value_double(&cvarr, cat, &dval);
if (ret != DB_OK) {
G_warning(_("No record for cat %d"), cat);
continue;
}
}
G_debug(3, "dval = %e", dval);
z[nsites] = dval;
nsites++;
}
G_verbose_message(_("Number of points: %d"), nsites);
if (nsites <= 0)
G_fatal_error(_("No points found"));
if (nsites < 4)
G_warning(_("Too small sample"));
if (flag.l->answer) {
warn_once = 0;
for (i = 0; i < nsites; ++i) {
if (z[i] > 1.0e-10)
z[i] = log10(z[i]);
else if (!warn_once) {
G_warning(_("Negative or very small point values set to -10.0"));
z[i] = -10.0;
warn_once = 1;
}
}
}
for (i = 0; parm.tests->answers[i]; i++)
if (!scan_cats(parm.tests->answers[i], &x, &y)) {
G_usage();
exit(EXIT_FAILURE);
}
for (i = 0; parm.tests->answers[i]; i++) {
scan_cats(parm.tests->answers[i], &x, &y);
while (x <= y)
switch (x++) {
case 1: /* moments */
fprintf(stdout, _("Moments \\sqrt{b_1} and b_2: "));
w = Cdhc_omnibus_moments(z, nsites);
fprintf(stdout, "%g %g\n", w[0], w[1]);
break;
case 2: /* geary */
fprintf(stdout, _("Geary's a-statistic & an approx. normal: "));
w = Cdhc_geary_test(z, nsites);
fprintf(stdout, "%g %g\n", w[0], w[1]);
break;
case 3: /* extreme deviates */
fprintf(stdout, _("Extreme normal deviates: "));
w = Cdhc_extreme(z, nsites);
fprintf(stdout, "%g %g\n", w[0], w[1]);
break;
case 4: /* D'Agostino */
fprintf(stdout, _("D'Agostino's D & an approx. normal: "));
w = Cdhc_dagostino_d(z, nsites);
fprintf(stdout, "%g %g\n", w[0], w[1]);
break;
case 5: /* Kuiper */
fprintf(stdout,
_("Kuiper's V (regular & modified for normality): "));
w = Cdhc_kuipers_v(z, nsites);
fprintf(stdout, "%g %g\n", w[1], w[0]);
break;
case 6: /* Watson */
fprintf(stdout,
_("Watson's U^2 (regular & modified for normality): "));
w = Cdhc_watson_u2(z, nsites);
fprintf(stdout, "%g %g\n", w[1], w[0]);
break;
case 7: /* Durbin */
fprintf(stdout,
_("Durbin's Exact Test (modified Kolmogorov): "));
w = Cdhc_durbins_exact(z, nsites);
fprintf(stdout, "%g\n", w[0]);
break;
case 8: /* Anderson-Darling */
fprintf(stdout,
_("Anderson-Darling's A^2 (regular & modified for normality): "));
w = Cdhc_anderson_darling(z, nsites);
fprintf(stdout, "%g %g\n", w[1], w[0]);
break;
case 9: /* Cramer-Von Mises */
fprintf(stdout,
_("Cramer-Von Mises W^2(regular & modified for normality): "));
w = Cdhc_cramer_von_mises(z, nsites);
fprintf(stdout, "%g %g\n", w[1], w[0]);
break;
case 10: /* Kolmogorov-Smirnov */
fprintf(stdout,
_("Kolmogorov-Smirnov's D (regular & modified for normality): "));
w = Cdhc_kolmogorov_smirnov(z, nsites);
fprintf(stdout, "%g %g\n", w[1], w[0]);
break;
case 11: /* chi-square */
fprintf(stdout,
_("Chi-Square stat (equal probability classes) and d.f.: "));
w = Cdhc_chi_square(z, nsites);
fprintf(stdout, "%g %d\n", w[0], (int)w[1]);
break;
case 12: /* Shapiro-Wilk */
if (nsites > 50) {
G_warning(_("Shapiro-Wilk's W cannot be used for n > 50"));
if (nsites < 99)
G_message(_("Use Weisberg-Binghams's W''"));
}
else {
fprintf(stdout, _("Shapiro-Wilk W: "));
w = Cdhc_shapiro_wilk(z, nsites);
fprintf(stdout, "%g\n", w[0]);
}
break;
case 13: /* Weisberg-Bingham */
if (nsites > 99 || nsites < 50)
G_warning(_("Weisberg-Bingham's W'' cannot be used for n < 50 or n > 99"));
else {
fprintf(stdout, _("Weisberg-Bingham's W'': "));
w = Cdhc_weisberg_bingham(z, nsites);
fprintf(stdout, "%g\n", w[0]);
}
break;
case 14: /* Royston */
if (nsites > 2000)
G_warning(_("Royston only extended Shapiro-Wilk's W up to n = 2000"));
else {
fprintf(stdout, _("Shapiro-Wilk W'': "));
w = Cdhc_royston(z, nsites);
fprintf(stdout, "%g\n", w[0]);
}
break;
case 15: /* Kotz */
fprintf(stdout, _("Kotz' T'_f (Lognormality vs. Normality): "));
w = Cdhc_kotz_families(z, nsites);
fprintf(stdout, "%g\n", w[0]);
break;
default:
break;
}
}
exit(EXIT_SUCCESS);
}
