int edit_line_end(void *closure)
{
struct edit_line *el = closure;
if (el->phase > 1) {
if (el->reversed)
Vect_line_reverse(el->Points);
if (el->Points->n_points > 1) {
Vect_rewrite_line(&Map, el->line, el->line_type, el->Points,
el->Cats);
updated_lines_and_nodes_erase_refresh_display();
}
else {
int i;
/* delete lines with less than two points */
Vect_delete_line(&Map, el->line);
for (i = 0; i < el->Cats->n_cats; i++) {
check_record(el->Cats->field[i], el->Cats->cat[i]);
}
}
Vect_destroy_line_struct(el->Points);
Vect_destroy_cats_struct(el->Cats);
}
i_prompt("");
i_prompt_buttons("", "", "");
i_coor(COOR_NULL, COOR_NULL);
G_debug(3, "edit_line(): End");
return 1;
}
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);
}
/* break polygons using a memory-based search index */
void Vect_break_polygons_mem(struct Map_info *Map, int type, struct Map_info *Err)
{
struct line_pnts *BPoints, *Points;
struct line_cats *Cats, *ErrCats;
int i, j, k, ret, ltype, broken, last, nlines;
int nbreaks;
struct RB_TREE *RBTree;
int npoints, nallpoints, nmarks;
XPNT *XPnt_found, XPnt_search;
double dx, dy, a1 = 0, a2 = 0;
int closed, last_point, cross;
G_debug(1, "Memory-based version of Vect_break_polygons()");
RBTree = rbtree_create(compare_xpnts, sizeof(XPNT));
BPoints = Vect_new_line_struct();
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
ErrCats = Vect_new_cats_struct();
nlines = Vect_get_num_lines(Map);
G_debug(3, "nlines = %d", nlines);
/* Go through all lines in vector, and add each point to structure of points,
* if such point already exists check angles of segments and if differ mark for break */
nmarks = 0;
npoints = 0;
nallpoints = 0;
XPnt_search.used = 0;
G_message(_("Breaking polygons (pass 1: select break points)..."));
for (i = 1; i <= nlines; i++) {
G_percent(i, nlines, 1);
G_debug(3, "i = %d", i);
if (!Vect_line_alive(Map, i))
continue;
ltype = Vect_read_line(Map, Points, Cats, i);
if (!(ltype & type))
continue;
/* This would be confused by duplicate coordinates (angle cannot be calculated) ->
* prune line first */
Vect_line_prune(Points);
/* If first and last point are identical it is close polygon, we don't need to register last point
* and we can calculate angle for first.
* If first and last point are not identical we have to mark for break both */
last_point = Points->n_points - 1;
if (Points->x[0] == Points->x[last_point] &&
Points->y[0] == Points->y[last_point])
closed = 1;
else
closed = 0;
for (j = 0; j < Points->n_points; j++) {
G_debug(3, "j = %d", j);
nallpoints++;
if (j == last_point && closed)
continue; /* do not register last of close polygon */
XPnt_search.x = Points->x[j];
XPnt_search.y = Points->y[j];
/* Already in DB? */
XPnt_found = rbtree_find(RBTree, &XPnt_search);
if (Points->n_points <= 2 ||
(!closed && (j == 0 || j == last_point))) {
cross = 1; /* mark for cross in any case */
}
else { /* calculate angles */
cross = 0;
if (j == 0 && closed) { /* closed polygon */
dx = Points->x[last_point] - Points->x[0];
dy = Points->y[last_point] - Points->y[0];
a1 = atan2(dy, dx);
dx = Points->x[1] - Points->x[0];
dy = Points->y[1] - Points->y[0];
a2 = atan2(dy, dx);
}
else {
dx = Points->x[j - 1] - Points->x[j];
dy = Points->y[j - 1] - Points->y[j];
a1 = atan2(dy, dx);
dx = Points->x[j + 1] - Points->x[j];
dy = Points->y[j + 1] - Points->y[j];
a2 = atan2(dy, dx);
}
}
if (XPnt_found) { /* found */
if (XPnt_found->cross == 1)
continue; /* already marked */
/* check angles */
if (cross) {
XPnt_found->cross = 1;
nmarks++;
}
else {
G_debug(3, "a1 = %f xa1 = %f a2 = %f xa2 = %f", a1,
XPnt_found->a1, a2, XPnt_found->a2);
if ((a1 == XPnt_found->a1 && a2 == XPnt_found->a2) ||
(a1 == XPnt_found->a2 && a2 == XPnt_found->a1)) { /* identical */
}
else {
XPnt_found->cross = 1;
nmarks++;
}
}
}
else {
if (j == 0 || j == (Points->n_points - 1) ||
Points->n_points < 3) {
XPnt_search.a1 = 0;
XPnt_search.a2 = 0;
XPnt_search.cross = 1;
nmarks++;
}
else {
XPnt_search.a1 = a1;
XPnt_search.a2 = a2;
XPnt_search.cross = 0;
}
/* Add to tree */
rbtree_insert(RBTree, &XPnt_search);
npoints++;
}
}
}
nbreaks = 0;
nallpoints = 0;
G_debug(2, "Break polygons: unique vertices: %ld", (long int)RBTree->count);
/* uncomment to check if search tree is healthy */
/* if (rbtree_debug(RBTree, RBTree->root) == 0)
G_warning("Break polygons: RBTree not ok"); */
/* Second loop through lines (existing when loop is started, no need to process lines written again)
* and break at points marked for break */
G_message(_("Breaking polygons (pass 2: break at selected points)..."));
for (i = 1; i <= nlines; i++) {
int n_orig_points;
G_percent(i, nlines, 1);
G_debug(3, "i = %d", i);
if (!Vect_line_alive(Map, i))
continue;
ltype = Vect_read_line(Map, Points, Cats, i);
if (!(ltype & type))
continue;
if (!(ltype & GV_LINES))
continue; /* Nonsense to break points */
/* Duplicates would result in zero length lines -> prune line first */
n_orig_points = Points->n_points;
Vect_line_prune(Points);
broken = 0;
last = 0;
G_debug(3, "n_points = %d", Points->n_points);
for (j = 1; j < Points->n_points; j++) {
G_debug(3, "j = %d", j);
nallpoints++;
if (Points->n_points <= 1 ||
(j == (Points->n_points - 1) && !broken))
break;
/* One point only or
* last point and line is not broken, do nothing */
XPnt_search.x = Points->x[j];
XPnt_search.y = Points->y[j];
XPnt_found = rbtree_find(RBTree, &XPnt_search);
/* all points must be in the search tree, without duplicates */
if (XPnt_found == NULL)
G_fatal_error(_("Point not in search tree!"));
/* break or write last segment of broken line */
if ((j == (Points->n_points - 1) && broken) ||
XPnt_found->cross) {
Vect_reset_line(BPoints);
for (k = last; k <= j; k++) {
Vect_append_point(BPoints, Points->x[k], Points->y[k],
Points->z[k]);
}
/* Result may collapse to one point */
Vect_line_prune(BPoints);
if (BPoints->n_points > 1) {
ret = Vect_write_line(Map, ltype, BPoints, Cats);
G_debug(3,
"Line %d written j = %d n_points(orig,pruned) = %d n_points(new) = %d",
ret, j, Points->n_points, BPoints->n_points);
}
if (!broken)
Vect_delete_line(Map, i); /* not yet deleted */
/* Write points on breaks */
if (Err) {
if (XPnt_found->cross && !XPnt_found->used) {
Vect_reset_line(BPoints);
Vect_append_point(BPoints, Points->x[j], Points->y[j], 0);
Vect_write_line(Err, GV_POINT, BPoints, ErrCats);
}
XPnt_found->used = 1;
}
last = j;
broken = 1;
nbreaks++;
}
}
if (!broken && n_orig_points > Points->n_points) { /* was pruned before -> rewrite */
if (Points->n_points > 1) {
Vect_rewrite_line(Map, i, ltype, Points, Cats);
G_debug(3, "Line %d pruned, npoints = %d", i,
Points->n_points);
}
else {
Vect_delete_line(Map, i);
G_debug(3, "Line %d was deleted", i);
}
}
else {
G_debug(3, "Line %d was not changed", i);
}
}
rbtree_destroy(RBTree);
Vect_destroy_line_struct(Points);
Vect_destroy_line_struct(BPoints);
Vect_destroy_cats_struct(Cats);
G_verbose_message(_("Breaks: %d"), nbreaks);
}
/* break polygons using a file-based search index */
void Vect_break_polygons_file(struct Map_info *Map, int type, struct Map_info *Err)
{
struct line_pnts *BPoints, *Points;
struct line_cats *Cats, *ErrCats;
int i, j, k, ret, ltype, broken, last, nlines;
int nbreaks;
struct RTree *RTree;
int npoints, nallpoints, nmarks;
XPNT2 XPnt;
double dx, dy, a1 = 0, a2 = 0;
int closed, last_point;
char cross;
int fd, xpntfd;
char *filename;
static struct RTree_Rect rect;
static int rect_init = 0;
if (!rect_init) {
rect.boundary = G_malloc(6 * sizeof(RectReal));
rect_init = 6;
}
G_debug(1, "File-based version of Vect_break_polygons()");
filename = G_tempfile();
fd = open(filename, O_RDWR | O_CREAT | O_EXCL, 0600);
RTree = RTreeCreateTree(fd, 0, 2);
remove(filename);
filename = G_tempfile();
xpntfd = open(filename, O_RDWR | O_CREAT | O_EXCL, 0600);
remove(filename);
BPoints = Vect_new_line_struct();
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
ErrCats = Vect_new_cats_struct();
nlines = Vect_get_num_lines(Map);
G_debug(3, "nlines = %d", nlines);
/* Go through all lines in vector, and add each point to structure of points,
* if such point already exists check angles of segments and if differ mark for break */
nmarks = 0;
npoints = 1; /* index starts from 1 ! */
nallpoints = 0;
XPnt.used = 0;
G_message(_("Breaking polygons (pass 1: select break points)..."));
for (i = 1; i <= nlines; i++) {
G_percent(i, nlines, 1);
G_debug(3, "i = %d", i);
if (!Vect_line_alive(Map, i))
continue;
ltype = Vect_read_line(Map, Points, Cats, i);
if (!(ltype & type))
continue;
/* This would be confused by duplicate coordinates (angle cannot be calculated) ->
* prune line first */
Vect_line_prune(Points);
/* If first and last point are identical it is close polygon, we don't need to register last point
* and we can calculate angle for first.
* If first and last point are not identical we have to mark for break both */
last_point = Points->n_points - 1;
if (Points->x[0] == Points->x[last_point] &&
Points->y[0] == Points->y[last_point])
closed = 1;
else
closed = 0;
for (j = 0; j < Points->n_points; j++) {
G_debug(3, "j = %d", j);
nallpoints++;
if (j == last_point && closed)
continue; /* do not register last of close polygon */
/* Box */
rect.boundary[0] = Points->x[j];
rect.boundary[3] = Points->x[j];
rect.boundary[1] = Points->y[j];
rect.boundary[4] = Points->y[j];
rect.boundary[2] = 0;
rect.boundary[5] = 0;
/* Already in DB? */
fpoint = -1;
RTreeSearch(RTree, &rect, (void *)srch, NULL);
G_debug(3, "fpoint = %d", fpoint);
if (Points->n_points <= 2 ||
(!closed && (j == 0 || j == last_point))) {
cross = 1; /* mark for cross in any case */
}
else { /* calculate angles */
cross = 0;
if (j == 0 && closed) { /* closed polygon */
dx = Points->x[last_point] - Points->x[0];
dy = Points->y[last_point] - Points->y[0];
a1 = atan2(dy, dx);
dx = Points->x[1] - Points->x[0];
dy = Points->y[1] - Points->y[0];
a2 = atan2(dy, dx);
}
else {
dx = Points->x[j - 1] - Points->x[j];
dy = Points->y[j - 1] - Points->y[j];
a1 = atan2(dy, dx);
dx = Points->x[j + 1] - Points->x[j];
dy = Points->y[j + 1] - Points->y[j];
a2 = atan2(dy, dx);
}
}
if (fpoint > 0) { /* Found */
/* read point */
lseek(xpntfd, (off_t) (fpoint - 1) * sizeof(XPNT2), SEEK_SET);
read(xpntfd, &XPnt, sizeof(XPNT2));
if (XPnt.cross == 1)
continue; /* already marked */
/* Check angles */
if (cross) {
XPnt.cross = 1;
nmarks++;
/* write point */
lseek(xpntfd, (off_t) (fpoint - 1) * sizeof(XPNT2), SEEK_SET);
write(xpntfd, &XPnt, sizeof(XPNT2));
}
else {
G_debug(3, "a1 = %f xa1 = %f a2 = %f xa2 = %f", a1,
XPnt.a1, a2, XPnt.a2);
if ((a1 == XPnt.a1 && a2 == XPnt.a2) ||
(a1 == XPnt.a2 && a2 == XPnt.a1)) { /* identical */
}
else {
XPnt.cross = 1;
nmarks++;
/* write point */
lseek(xpntfd, (off_t) (fpoint - 1) * sizeof(XPNT2), SEEK_SET);
write(xpntfd, &XPnt, sizeof(XPNT2));
}
}
}
else {
/* Add to tree and to structure */
RTreeInsertRect(&rect, npoints, RTree);
if (j == 0 || j == (Points->n_points - 1) ||
Points->n_points < 3) {
XPnt.a1 = 0;
XPnt.a2 = 0;
XPnt.cross = 1;
nmarks++;
}
else {
XPnt.a1 = a1;
XPnt.a2 = a2;
XPnt.cross = 0;
}
/* write point */
lseek(xpntfd, (off_t) (npoints - 1) * sizeof(XPNT2), SEEK_SET);
write(xpntfd, &XPnt, sizeof(XPNT2));
npoints++;
}
}
}
nbreaks = 0;
/* Second loop through lines (existing when loop is started, no need to process lines written again)
* and break at points marked for break */
G_message(_("Breaking polygons (pass 2: break at selected points)..."));
for (i = 1; i <= nlines; i++) {
int n_orig_points;
G_percent(i, nlines, 1);
G_debug(3, "i = %d", i);
if (!Vect_line_alive(Map, i))
continue;
ltype = Vect_read_line(Map, Points, Cats, i);
if (!(ltype & type))
continue;
if (!(ltype & GV_LINES))
continue; /* Nonsense to break points */
/* Duplicates would result in zero length lines -> prune line first */
n_orig_points = Points->n_points;
Vect_line_prune(Points);
broken = 0;
last = 0;
G_debug(3, "n_points = %d", Points->n_points);
for (j = 1; j < Points->n_points; j++) {
G_debug(3, "j = %d", j);
nallpoints++;
/* Box */
rect.boundary[0] = Points->x[j];
rect.boundary[3] = Points->x[j];
rect.boundary[1] = Points->y[j];
rect.boundary[4] = Points->y[j];
rect.boundary[2] = 0;
rect.boundary[5] = 0;
if (Points->n_points <= 1 ||
(j == (Points->n_points - 1) && !broken))
break;
/* One point only or
* last point and line is not broken, do nothing */
RTreeSearch(RTree, &rect, (void *)srch, 0);
G_debug(3, "fpoint = %d", fpoint);
/* read point */
lseek(xpntfd, (off_t) (fpoint - 1) * sizeof(XPNT2), SEEK_SET);
read(xpntfd, &XPnt, sizeof(XPNT2));
/* break or write last segment of broken line */
if ((j == (Points->n_points - 1) && broken) ||
XPnt.cross) {
Vect_reset_line(BPoints);
for (k = last; k <= j; k++) {
Vect_append_point(BPoints, Points->x[k], Points->y[k],
Points->z[k]);
}
/* Result may collapse to one point */
Vect_line_prune(BPoints);
if (BPoints->n_points > 1) {
ret = Vect_write_line(Map, ltype, BPoints, Cats);
G_debug(3,
"Line %d written j = %d n_points(orig,pruned) = %d n_points(new) = %d",
ret, j, Points->n_points, BPoints->n_points);
}
if (!broken)
Vect_delete_line(Map, i); /* not yet deleted */
/* Write points on breaks */
if (Err) {
if (XPnt.cross && !XPnt.used) {
Vect_reset_line(BPoints);
Vect_append_point(BPoints, Points->x[j], Points->y[j], 0);
Vect_write_line(Err, GV_POINT, BPoints, ErrCats);
}
if (!XPnt.used) {
XPnt.used = 1;
/* write point */
lseek(xpntfd, (off_t) (fpoint - 1) * sizeof(XPNT2), SEEK_SET);
write(xpntfd, &XPnt, sizeof(XPNT2));
}
}
last = j;
broken = 1;
nbreaks++;
}
}
if (!broken && n_orig_points > Points->n_points) { /* was pruned before -> rewrite */
if (Points->n_points > 1) {
Vect_rewrite_line(Map, i, ltype, Points, Cats);
G_debug(3, "Line %d pruned, npoints = %d", i,
Points->n_points);
}
else {
Vect_delete_line(Map, i);
G_debug(3, "Line %d was deleted", i);
}
}
else {
G_debug(3, "Line %d was not changed", i);
}
}
close(RTree->fd);
RTreeDestroyTree(RTree);
close(xpntfd);
Vect_destroy_line_struct(Points);
Vect_destroy_line_struct(BPoints);
Vect_destroy_cats_struct(Cats);
Vect_destroy_cats_struct(ErrCats);
G_verbose_message(_("Breaks: %d"), nbreaks);
}
/*!
\brief Split selected lines on given position
\param Map pointer to Map_info
\param List list of selected lines
\param coord points location
\param thresh threshold
\param[out] List_updated list of rewritten features (or NULL)
\return number of modified lines
\return -1 on error
*/
int Vedit_split_lines(struct Map_info *Map, struct ilist *List,
struct line_pnts *coord, double thresh,
struct ilist *List_updated)
{
int i, j, l;
int type, line, seg, newline;
int nlines_modified;
double px, py, spdist, lpdist, dist;
double *x, *y, *z;
struct line_pnts *Points, *Points2;
struct line_cats *Cats;
struct ilist *List_in_box;
nlines_modified = 0;
Points = Vect_new_line_struct();
Points2 = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
List_in_box = Vect_new_list();
for (i = 0; i < List->n_values; i++) {
line = List->value[i];
if (!Vect_line_alive(Map, line))
continue;
type = Vect_read_line(Map, Points, Cats, line);
if (!(type & GV_LINES))
continue;
x = Points->x;
y = Points->y;
z = Points->z;
for (j = 0; j < coord->n_points; j++) {
seg =
Vect_line_distance(Points, coord->x[j], coord->y[j],
coord->z[j], WITHOUT_Z, &px, &py, NULL,
&dist, &spdist, &lpdist);
if (dist > thresh) {
continue;
}
G_debug(3, "Vedit_split_lines(): line=%d, x=%f, y=%f, px=%f, py=%f, seg=%d, "
"dist=%f, spdist=%f, lpdist=%f", line, coord->x[j],
coord->y[j], px, py, seg, dist, spdist, lpdist);
if (spdist <= 0.0 || spdist >= Vect_line_length(Points))
continue;
G_debug(3, "Vedit_split_lines(): line=%d", line);
/* copy first line part */
for (l = 0; l < seg; l++) {
Vect_append_point(Points2, x[l], y[l], z[l]);
}
/* add last vertex */
Vect_append_point(Points2, px, py, 0.0);
/* rewrite the line */
newline = Vect_rewrite_line(Map, line, type, Points2, Cats);
if (newline < 0) {
return -1;
}
if (List_updated)
Vect_list_append(List_updated, newline);
Vect_reset_line(Points2);
/* add given vertex */
Vect_append_point(Points2, px, py, 0.0);
/* copy second line part */
for (l = seg; l < Points->n_points; l++) {
Vect_append_point(Points2, x[l], y[l], z[l]);
}
/* rewrite the line */
newline = Vect_write_line(Map, type, Points2, Cats);
if (newline < 0) {
return -1;
}
if (List_updated)
Vect_list_append(List_updated, newline);
nlines_modified++;
} /* for each bounding box */
} /* for each selected line */
Vect_destroy_line_struct(Points);
Vect_destroy_line_struct(Points2);
Vect_destroy_cats_struct(Cats);
Vect_destroy_list(List_in_box);
return nlines_modified;
}
int connect_lines(struct Map_info *Map, int first, int line_from, int line_to,
double thresh, struct ilist *List)
{
int line_new;
int type_from, type_to;
int n_points, seg, is;
double x, y, px, py, x1, y1;
double dist, spdist, lpdist, length, dist_p;
double angle_t, angle_f, angle;
struct line_pnts *Points_from, *Points_to, *Points_final;
struct line_cats *Cats_from, *Cats_to;
Points_from = Vect_new_line_struct();
Points_to = Vect_new_line_struct();
Points_final = Vect_new_line_struct();
Cats_from = Vect_new_cats_struct();
Cats_to = Vect_new_cats_struct();
type_from = Vect_read_line(Map, Points_from, Cats_from, line_from);
type_to = Vect_read_line(Map, Points_to, Cats_to, line_to);
line_new = 0;
if (!(type_from & GV_LINES) || !(type_to & GV_LINES))
line_new = -1;
if (line_new > -1) {
if (first) {
x = Points_from->x[0];
y = Points_from->y[0];
}
else {
n_points = Points_from->n_points - 1;
x = Points_from->x[n_points];
y = Points_from->y[n_points];
}
seg = Vect_line_distance(Points_to, x, y, 0.0, WITHOUT_Z,
&px, &py, NULL, &dist, &spdist, &lpdist);
if (seg > 0 && dist > 0.0 && (thresh < 0. || dist <= thresh)) {
/* lines in threshold */
if (first)
length = 0;
else
length = Vect_line_length(Points_from);
if (Vect_point_on_line(Points_from, length,
NULL, NULL, NULL, &angle_f, NULL) > 0) {
if (Vect_point_on_line(Points_to, lpdist,
NULL, NULL, NULL, &angle_t,
NULL) > 0) {
angle = angle_t - angle_f;
dist_p = fabs(dist / sin(angle));
if (first) {
if (angle_f < 0)
angle_f -= M_PI;
else
angle_f += M_PI;
}
x1 = x + dist_p * cos(angle_f);
y1 = y + dist_p * sin(angle_f);
length = Vect_line_length(Points_to);
Vect_line_insert_point(Points_to, seg, x1, y1, 0.);
if (fabs(Vect_line_length(Points_to) - length) < length * 1e-3) {
/* lines connected -> split line_to */
/* update line_from */
if (first) {
Points_from->x[0] = x1;
Points_from->y[0] = y1;
}
else {
Points_from->x[n_points] = x1;
Points_from->y[n_points] = y1;
}
line_new = Vect_rewrite_line(Map, line_from, type_from,
Points_from, Cats_from);
/* Vect_list_append(List, line_new); */
/* update line_to -- first part */
Vect_reset_line(Points_final);
for (is = 0; is < seg; is++) {
Vect_append_point(Points_final, Points_to->x[is],
Points_to->y[is],
Points_to->z[is]);
}
Vect_append_point(Points_final, x1, y1, 0.0);
line_new = Vect_rewrite_line(Map, line_to, type_to,
Points_final, Cats_to);
/* Vect_list_append(List, line_new); */
/* write second part */
Vect_reset_line(Points_final);
Vect_append_point(Points_final, x1, y1, 0.0);
for (is = seg; is < Points_to->n_points; is++) {
Vect_append_point(Points_final, Points_to->x[is],
Points_to->y[is],
Points_to->z[is]);
}
/* rewrite first part */
line_new = Vect_write_line(Map, type_to,
Points_final, Cats_to);
/* Vect_list_append(List, line_new); */
}
}
}
}
}
Vect_destroy_line_struct(Points_from);
Vect_destroy_line_struct(Points_to);
Vect_destroy_line_struct(Points_final);
Vect_destroy_cats_struct(Cats_from);
Vect_destroy_cats_struct(Cats_to);
return line_new > 0 ? 1 : 0;
}
/**
* \brief Consolidate network arcs (edge) based on given point vector map (nodes)
*
* If there is no connection between network edge and point, new edge
* is added, the line broken, and new point added to nfield layer
*
* \param In,Points input vector maps
* \param Out output vector map
* \param nfield nodes layer
* \param thresh threshold value to find neareast line
*
* \return number of new arcs
*/
int connect_arcs(struct Map_info *In, struct Map_info *Pnts,
struct Map_info *Out, int afield, int nfield,
double thresh, int snap)
{
int narcs;
int type, line, seg, i, ltype, broken;
double px, py, pz, spdist, dist;
struct line_pnts *Points, *Pline, *Pout;
struct line_cats *Cats, *Cline, *Cnew;
int maxcat, findex, ncats;
narcs = 0;
Points = Vect_new_line_struct();
Pline = Vect_new_line_struct();
Pout = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Cline = Vect_new_cats_struct();
Cnew = Vect_new_cats_struct();
/* rewrite all primitives to output file */
Vect_copy_map_lines(In, Out);
Vect_build_partial(Out, GV_BUILD_BASE);
findex = Vect_cidx_get_field_index(In, afield);
ncats = Vect_cidx_get_num_cats_by_index(In, findex);
Vect_cidx_get_cat_by_index(In, findex, ncats - 1, &maxcat, &type, &line);
/* go thorough all points in point map and write a new arcs if missing */
while ((type = Vect_read_next_line(Pnts, Points, Cats)) >= 0) {
if (type != GV_POINT)
continue;
/* find the nearest line in given threshold */
line = Vect_find_line(Out,
Points->x[0], Points->y[0], Points->z[0],
GV_LINES, thresh, WITHOUT_Z, 0);
if (line < 1 || !Vect_line_alive(Out, line))
continue;
ltype = Vect_read_line(Out, Pline, Cline, line);
/* find point on the line */
seg = Vect_line_distance(Pline,
Points->x[0], Points->y[0], Points->z[0],
WITHOUT_Z, &px, &py, &pz, &dist, &spdist,
NULL);
if (seg == 0)
G_fatal_error(_("Failed to find intersection segment"));
/* break the line */
broken = 0;
Vect_reset_line(Pout);
for (i = 0; i < seg; i++) {
Vect_append_point(Pout, Pline->x[i], Pline->y[i], Pline->z[i]);
}
Vect_append_point(Pout, px, py, pz);
Vect_line_prune(Pout);
if (Pout->n_points > 1) {
Vect_rewrite_line(Out, line, ltype, Pout, Cline);
broken++;
}
Vect_reset_line(Pout);
Vect_append_point(Pout, px, py, pz);
for (i = seg; i < Pline->n_points; i++) {
Vect_append_point(Pout, Pline->x[i], Pline->y[i], Pline->z[i]);
}
Vect_line_prune(Pout);
if (Pout->n_points > 1) {
if (broken)
Vect_write_line(Out, ltype, Pout, Cline);
else
Vect_rewrite_line(Out, line, ltype, Pout, Cline);
broken++;
}
if (broken == 2)
narcs++;
if (dist > 0.0) {
if (snap) {
/* snap point */
Points->x[0] = px;
Points->y[0] = py;
Points->z[0] = pz;
}
else {
/* write new arc */
Vect_reset_line(Pout);
Vect_append_point(Pout, px, py, pz);
Vect_append_point(Pout, Points->x[0], Points->y[0], Points->z[0]);
maxcat++;
Vect_reset_cats(Cnew);
Vect_cat_set(Cnew, afield, maxcat);
Vect_write_line(Out, ltype, Pout, Cnew);
narcs++;
}
}
/* add points to 'nfield' layer */
for (i = 0; i < Cats->n_cats; i++) {
Cats->field[i] = nfield; /* all points to 'nfield' layer */
}
Vect_write_line(Out, type, Points, Cats);
}
Vect_destroy_line_struct(Points);
Vect_destroy_line_struct(Pline);
Vect_destroy_line_struct(Pout);
Vect_destroy_cats_struct(Cats);
Vect_destroy_cats_struct(Cline);
Vect_destroy_cats_struct(Cnew);
return narcs;
}
/*
Called by Vect_remove_bridges() and Vect_chtype_bridges():
chtype = 0 -> works like Vect_remove_bridges()
chtype = 1 -> works like Vect_chtype_bridges()
Algorithm: Go thorough all lines,
if both sides of the line have left and side 0 (candidate) do this check:
follow adjacent lines in one direction (nearest to the right at the end node),
if we reach this line again without dangle in the way, but with this line
traversed from other side it is a bridge.
List of all lines in chain is created during the cycle.
*/
void
remove_bridges(struct Map_info *Map, int chtype, struct Map_info *Err)
{
int i, type, nlines, line;
int left, right, node1, node2, current_line, next_line;
int bridges_removed = 0; /* number of removed bridges */
int lines_removed = 0; /* number of lines removed */
char *lmsg;
struct Plus_head *Plus;
struct line_pnts *Points;
struct line_cats *Cats;
struct ilist *CycleList;
struct ilist *BridgeList;
int dangle, other_side;
if (chtype)
lmsg = "changed lines";
else
lmsg = "removed lines";
Plus = &(Map->plus);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
CycleList = Vect_new_list();
BridgeList = Vect_new_list();
nlines = Vect_get_num_lines(Map);
G_debug(1, "nlines = %d", nlines);
for (line = 1; line <= nlines; line++) {
G_percent(line, nlines, 1);
if (!Vect_line_alive(Map, line))
continue;
type = Vect_read_line(Map, NULL, NULL, line);
if (!(type & GV_BOUNDARY))
continue;
Vect_get_line_areas(Map, line, &left, &right);
if (left != 0 || right != 0)
continue; /* Cannot be bridge */
G_debug(2, "line %d - bridge candidate", line);
Vect_get_line_nodes(Map, line, &node1, &node2);
if (abs(node1) == abs(node2))
continue; /* either zero length or loop -> cannot be a bridge */
current_line = -line; /* we start with negative (go forward, node2 ) */
dangle = 0;
other_side = 0;
Vect_reset_list(CycleList);
Vect_reset_list(BridgeList);
while (1) {
next_line =
dig_angle_next_line(Plus, current_line, GV_RIGHT,
GV_BOUNDARY);
/* Add this line to the list */
/* TODO: Vect_val_in_list() and Vect_list_append() behave O(n)
* change to O(log n) */
if (Vect_val_in_list(CycleList, abs(next_line))) /* other side -> bridge chain */
Vect_list_append(BridgeList, abs(next_line));
else
dig_list_add(CycleList, abs(next_line)); /* not in list, can add new line fast */
if (abs(next_line) == abs(current_line)) {
G_debug(4, " dangle -> no bridge");
dangle = 1;
break;
}
if (abs(next_line) == line) { /* start line reached */
/* which side */
if (next_line < 0) { /* other side (connected by node 2) */
G_debug(5, " other side reached");
other_side = 1;
}
else { /* start side */
break;
}
}
current_line = -next_line; /* change the sign to look at the next node in following cycle */
}
if (!dangle && other_side) {
G_debug(3, " line %d is part of bridge chain", line);
for (i = 0; i < BridgeList->n_values; i++) {
Vect_read_line(Map, Points, Cats, BridgeList->value[i]);
if (Err) {
Vect_write_line(Err, GV_BOUNDARY, Points, Cats);
}
if (!chtype)
Vect_delete_line(Map, BridgeList->value[i]);
else
Vect_rewrite_line(Map, BridgeList->value[i], GV_LINE,
Points, Cats);
lines_removed++;
}
bridges_removed++;
}
}
G_verbose_message("Removed lines: %d", lines_removed);
G_verbose_message("Removed bridges: %d", bridges_removed);
}
/*!
\brief Remove duplicate features from vector map.
Remove duplicate lines of given types from vector map. Duplicate
lines may be optionally written to error map. Input map must be
opened on level 2 for update. Categories are merged.
GV_BUILD_BASE is sufficient.
\param[in,out] Map vector map where duplicate lines will be deleted
\param type type of line to be delete
\param[out] Err vector map where duplicate lines will be written or NULL
\return void
*/
void
Vect_remove_duplicates(struct Map_info *Map, int type, struct Map_info *Err)
{
struct line_pnts *APoints, *BPoints;
struct line_cats *ACats, *BCats, *Cats;
int i, j, c, atype, btype, bline;
int nlines, nbcats_orig;
struct bound_box ABox;
struct boxlist *List;
int ndupl;
APoints = Vect_new_line_struct();
BPoints = Vect_new_line_struct();
ACats = Vect_new_cats_struct();
BCats = Vect_new_cats_struct();
Cats = Vect_new_cats_struct();
List = Vect_new_boxlist(0);
nlines = Vect_get_num_lines(Map);
G_debug(1, "nlines = %d", nlines);
/* Go through all lines in vector, for each select lines which overlap MBR of
* this line and check if some of them is identical. If someone is identical
* remove current line. (In each step just one line is deleted)
*/
ndupl = 0;
for (i = 1; i <= nlines; i++) {
G_percent(i, nlines, 1);
if (!Vect_line_alive(Map, i))
continue;
atype = Vect_read_line(Map, APoints, ACats, i);
if (!(atype & type))
continue;
Vect_line_box(APoints, &ABox);
Vect_select_lines_by_box(Map, &ABox, type, List);
G_debug(3, " %d lines selected by box", List->n_values);
for (j = 0; j < List->n_values; j++) {
bline = List->id[j];
G_debug(3, " j = %d bline = %d", j, bline);
if (i == bline)
continue;
btype = Vect_read_line(Map, BPoints, BCats, bline);
/* check for duplicates */
if (!Vect_line_check_duplicate(APoints, BPoints, Vect_is_3d(Map)))
continue;
/* Lines area identical -> remove current */
if (Err) {
Vect_write_line(Err, atype, APoints, ACats);
}
Vect_delete_line(Map, i);
/* Merge categories */
nbcats_orig = BCats->n_cats;
for (c = 0; c < ACats->n_cats; c++)
Vect_cat_set(BCats, ACats->field[c], ACats->cat[c]);
if (BCats->n_cats > nbcats_orig) {
G_debug(4, "cats merged: n_cats %d -> %d", nbcats_orig,
BCats->n_cats);
Vect_rewrite_line(Map, bline, btype, BPoints, BCats);
}
ndupl++;
break; /* line was deleted -> take the next one */
}
nlines = Vect_get_num_lines(Map); /* For future when lines with cats will be rewritten */
G_debug(3, "nlines = %d\n", nlines);
}
G_verbose_message("Removed duplicates: %d", ndupl);
}
/* check topology corruption by boundary modification
* return 0 on corruption, 1 if modification is ok */
int check_topo(struct Map_info *Out, int line, struct line_pnts *APoints,
struct line_pnts *Points, struct line_cats *Cats)
{
int i, j, intersect, newline, left_old, right_old,
left_new, right_new;
struct bound_box box;
struct line_pnts **AXLines, **BXLines;
int naxlines, nbxlines;
static struct line_pnts *BPoints = NULL;
static struct boxlist *List = NULL;
if (!BPoints)
BPoints = Vect_new_line_struct();
if (!List)
List = Vect_new_boxlist(1);
Vect_line_box(Points, &box);
/* Check the modified boundary for self-intersection */
AXLines = BXLines = NULL;
Vect_line_intersection2(Points, NULL, &box, &box, &AXLines, &BXLines,
&naxlines, &nbxlines, 0);
/* Free */
if (naxlines > 0) {
for (j = 0; j < naxlines; j++) {
Vect_destroy_line_struct(AXLines[j]);
}
}
if (AXLines)
G_free(AXLines);
if (naxlines > 0)
return 0;
/* Check intersection of the modified boundary with other boundaries */
Vect_select_lines_by_box(Out, &box, GV_BOUNDARY, List);
intersect = 0;
for (i = 0; i < List->n_values; i++) {
int bline;
bline = List->id[i];
if (bline == line)
continue;
Vect_read_line(Out, BPoints, NULL, bline);
/* Vect_line_intersection is quite slow, hopefully not so bad because only few
* intersections should be found if any */
AXLines = BXLines = NULL;
Vect_line_intersection2(Points, BPoints, &box, &List->box[i],
&AXLines, &BXLines,
&naxlines, &nbxlines, 0);
G_debug(4,
"bline = %d intersect = %d naxlines = %d nbxlines = %d",
bline, intersect, naxlines, nbxlines);
/* Free */
if (naxlines > 0) {
for (j = 0; j < naxlines; j++) {
Vect_destroy_line_struct(AXLines[j]);
}
}
if (AXLines)
G_free(AXLines);
if (nbxlines > 0) {
for (j = 0; j < nbxlines; j++) {
Vect_destroy_line_struct(BXLines[j]);
}
}
if (BXLines)
G_free(BXLines);
if (naxlines > 1 || nbxlines > 1) {
intersect = 1;
break;
}
}
/* modified boundary intersects another boundary */
if (intersect)
return 0;
/* Get centroids on the left and right side */
Vect_get_line_areas(Out, line, &left_old, &right_old);
if (left_old < 0)
left_old = Vect_get_isle_area(Out, abs(left_old));
if (left_old > 0)
left_old = Vect_get_area_centroid(Out, left_old);
if (right_old < 0)
right_old = Vect_get_isle_area(Out, abs(right_old));
if (right_old > 0)
right_old = Vect_get_area_centroid(Out, right_old);
/* OK, rewrite modified boundary */
newline = Vect_rewrite_line(Out, line, GV_BOUNDARY, Points, Cats);
/* Check position of centroids */
Vect_get_line_areas(Out, newline, &left_new, &right_new);
if (left_new < 0)
left_new = Vect_get_isle_area(Out, abs(left_new));
if (left_new > 0)
left_new = Vect_get_area_centroid(Out, left_new);
if (right_new < 0)
right_new = Vect_get_isle_area(Out, abs(right_new));
if (right_new > 0)
right_new = Vect_get_area_centroid(Out, right_new);
if (left_new != left_old || right_new != right_old) {
G_debug(3,
"The modified boundary changes attachment of centroid -> not modified");
Vect_rewrite_line(Out, newline, GV_BOUNDARY, APoints, Cats);
return 0;
}
return 1;
}
int move_line_update(void *closure, int sxn, int syn, int button)
{
struct move_line *ml = closure;
double x = D_d_to_u_col(sxn);
double y = D_d_to_u_row(syn);
G_debug(3, "button = %d x = %d = %f y = %d = %f", button, sxn, x, syn, y);
if (ml->last_line > 0) {
display_line(ml->last_line, SYMB_DEFAULT, 1);
}
if (button == 3)
return 1;
if (button == 1) { /* Select / new location */
int type;
if (ml->last_line == 0) { /* Select line */
ml->line =
Vect_find_line(&Map, x, y, 0, GV_POINT | GV_CENTROID,
ml->thresh, 0, 0);
G_debug(2, "point found = %d", ml->line);
if (ml->line == 0)
ml->line =
Vect_find_line(&Map, x, y, 0, GV_LINE | GV_BOUNDARY,
ml->thresh, 0, 0);
G_debug(2, "line found = %d", ml->line);
/* Display new selected line if any */
if (ml->line > 0) {
display_line(ml->line, SYMB_HIGHLIGHT, 1);
/* Find the nearest point on the line */
type = Vect_read_line(&Map, ml->Points, NULL, ml->line);
Vect_line_distance(ml->Points, x, y, 0, 0, &ml->xo, &ml->yo,
NULL, NULL, NULL, NULL);
set_location(D_u_to_d_col(ml->xo), D_u_to_d_row(ml->yo));
i_prompt_buttons(_("New location"), _("Unselect"), _("Quit tool"));
}
ml->last_line = ml->line;
}
else { /* Line is already selected */
int node1, node2;
int i;
display_line(ml->last_line, SYMB_BACKGROUND, 1);
Vect_get_line_nodes(&Map, ml->last_line, &node1, &node2);
display_node(node1, SYMB_BACKGROUND, 1);
display_node(node2, SYMB_BACKGROUND, 1);
type = Vect_read_line(&Map, ml->Points, ml->Cats, ml->last_line);
for (i = 0; i < ml->Points->n_points; i++) {
ml->Points->x[i] = ml->Points->x[i] + x - ml->xo;
ml->Points->y[i] = ml->Points->y[i] + y - ml->yo;
}
Vect_rewrite_line(&Map, ml->last_line, type, ml->Points,
ml->Cats);
updated_lines_and_nodes_erase_refresh_display();
ml->last_line = 0;
}
}
if (button == 2) { /* Unselect */
if (ml->last_line > 0) {
ml->last_line = 0;
}
}
if (ml->last_line == 0) {
i_prompt_buttons(_("Select"), "", _("Quit tool"));
set_mode(MOUSE_POINT);
}
else
set_mode(MOUSE_LINE);
return 0;
}
/*!
\brief Merge lines/boundaries
At least two lines need to be given.
\param Map pointer to Map_info
\param List list of selected lines
\return number of merged lines
\return -1 on error
*/
int Vedit_merge_lines(struct Map_info *Map, struct ilist *List)
{
struct ilist *List_in_box;
struct line_pnts *Points1, *Points2, *Points;
struct line_cats *Cats1, *Cats2;
int line_i, i, j;
int line, line1, type1, line2;
int do_merge;
/* number of lines (original, selected, merged) */
int nlines, nlines_merged;
nlines_merged = 0;
if (List->n_values < 2) {
return 0;
}
Points1 = Vect_new_line_struct();
Cats1 = Vect_new_cats_struct();
Points2 = Vect_new_line_struct();
Cats2 = Vect_new_cats_struct();
Points = Vect_new_line_struct();
List_in_box = Vect_new_list();
nlines = Vect_get_num_lines(Map);
/* merge lines */
for (line_i = 0; line_i < List->n_values; line_i++) {
line1 = List->value[line_i];
if (!Vect_line_alive(Map, line1))
continue;
type1 = Vect_read_line(Map, Points1, Cats1, line1);
if (!(type1 & GV_LINES))
continue;
Vect_reset_line(Points);
for (i = 0; i < Points1->n_points; i += Points1->n_points - 1) {
Vect_reset_list(List_in_box);
/* define searching region */
Vect_reset_line(Points2);
/*
Vect_append_point (Points2, Points1 -> x[i] - thresh,
Points1 -> y[i] + thresh, Points1 -> z[i]);
Vect_append_point (Points2, Points1 -> x[i] + thresh,
Points1 -> y[i] + thresh, Points1 -> z[i]);
Vect_append_point (Points2, Points1 -> x[i] + thresh,
Points1 -> y[i] - thresh, Points1 -> z[i]);
Vect_append_point (Points2, Points1 -> x[i] - thresh,
Points1 -> y[i] - thresh, Points1 -> z[i]);
*/
Vect_append_point(Points2, Points1->x[i],
Points1->y[i], Points1->z[i]);
/*
* merge lines only if two lines found in the region
* i.e. the current line and an adjacent line
*/
if (1 < Vect_select_lines_by_polygon(Map, Points2, 0, NULL,
GV_LINES, List_in_box)) {
do_merge = 1;
line2 = -1;
for (j = 0; do_merge && j < List->n_values; j++) {
if (List->value[j] == line1 ||
!Vect_line_alive(Map, List->value[j]))
continue;
if (Vect_val_in_list(List_in_box, List->value[j])) {
if (line2 > 0) {
/* three lines found
* selected lines will be not merged
*/
do_merge = 0;
}
else {
line2 = List->value[j];
}
}
}
if (!do_merge || line2 < 0)
continue;
Vect_read_line(Map, Points2, Cats2, line2);
merge_lines(Points1, Cats1, Points2, Cats2, -1.0, &Points); /* do not use threshold value */
G_debug(3, "Vedit_merge_lines(): lines=%d,%d", line1, line2);
if (Points->n_points > 0) {
if (Vect_delete_line(Map, line2) == -1) {
return -1;
}
if (line2 <= nlines)
nlines_merged++;
}
}
} /* for each node */
if (Points->n_points > 0) {
line = Vect_rewrite_line(Map, line1, type1, Points, Cats1);
if (line < 0) {
return -1;
}
if (line1 <= nlines)
nlines_merged++;
/* update number of lines */
Vect_list_append(List, line);
}
} /* for each line */
/* destroy stuctures */
Vect_destroy_line_struct(Points1);
Vect_destroy_line_struct(Points2);
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats1);
Vect_destroy_cats_struct(Cats2);
return nlines_merged;
}
/*!
\brief Lines z-bulk labeling
Automated labeling (z coordinate assignment) of vector lines (iso-lines).
\param Map pointer to Map_info
\param List list of selected lines
\param point_start_end staring and ending point
\param start starting value
\param step step value
\return number of modified features
\return -1 on error
*/
int Vedit_bulk_labeling(struct Map_info *Map, struct ilist *List,
double x1, double y1, double x2, double y2,
double start, double step)
{
int i, cv_i, p_i;
int line, type, temp_line;
int nlines_modified;
double value, dist;
struct line_cats *Cats;
struct line_pnts *Points, *Points_se; /* start - end */
struct bound_box box, box_se;
/* for intersection */
struct line_pnts **Points_a, **Points_b;
int nlines_a, nlines_b;
dbCatValArray cv; /* line_id / dist */
nlines_modified = 0;
value = start;
Points = Vect_new_line_struct();
Points_se = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
db_CatValArray_alloc(&cv, List->n_values);
cv.ctype = DB_C_TYPE_DOUBLE;
cv.n_values = 0;
Vect_append_point(Points_se, x1, y1, -PORT_DOUBLE_MAX);
Vect_append_point(Points_se, x2, y2, PORT_DOUBLE_MAX);
/* write temporaly line */
temp_line = Vect_write_line(Map, GV_LINE, Points_se, Cats);
if (temp_line < 0) {
return -1;
}
Vect_line_box(Points_se, &box_se);
/* determine order of lines */
cv_i = 0;
for (i = 0; i < List->n_values; i++) {
line = List->value[i];
if (!Vect_line_alive(Map, line))
continue;
type = Vect_read_line(Map, Points, NULL, line);
if (!(type & GV_LINE))
continue;
Vect_line_box(Points, &box);
if (Vect_line_check_intersection(Points_se, Points, WITH_Z)) {
Vect_line_intersection(Points_se, Points, &box_se, &box,
&Points_a, &Points_b, &nlines_a, &nlines_b,
WITHOUT_Z);
if (nlines_a < 2 || nlines_b < 1) /* should not happen */
continue;
/* calculate distance start point -> point of intersection */
for (p_i = 0; p_i < Points_a[0]->n_points; p_i++) {
Points_a[0]->z[p_i] = 0;
}
dist = Vect_line_length(Points_a[0]); /* always first line in array? */
cv.value[cv_i].cat = line;
cv.value[cv_i++].val.d = dist;
cv.n_values++;
}
}
/* sort array by distance */
db_CatValArray_sort_by_value(&cv);
/* z bulk-labeling */
for (cv_i = 0; cv_i < cv.n_values; cv_i++) {
line = cv.value[cv_i].cat;
type = Vect_read_line(Map, Points, Cats, line);
for (p_i = 0; p_i < Points->n_points; p_i++) {
Points->z[p_i] = value;
}
if (Vect_rewrite_line(Map, line, type, Points, Cats) < 0) {
return -1;
}
nlines_modified++;
value += step;
}
if (Vect_delete_line(Map, temp_line) < 0) {
return -1;
}
db_CatValArray_free(&cv);
Vect_destroy_line_struct(Points);
Vect_destroy_line_struct(Points_se);
Vect_destroy_cats_struct(Cats);
return nlines_modified;
}
