double Vect_get_area_perimeter(const struct Map_info *Map, int area)
{
const struct Plus_head *Plus;
struct P_area *Area;
struct line_pnts *Points;
double d;
int i;
G_debug(3, "Vect_get_area_perimeter(): area = %d", area);
Points = Vect_new_line_struct();
Plus = &(Map->plus);
Area = Plus->Area[area];
Vect_get_area_points(Map, area, Points);
Vect_line_prune(Points);
d = Vect_line_geodesic_length(Points);
/* adding island perimeters */
for (i = 0; i < Area->n_isles; i++) {
Vect_get_isle_points(Map, Area->isles[i], Points);
Vect_line_prune(Points);
d += Vect_line_geodesic_length(Points);
}
Vect_destroy_line_struct(Points);
G_debug(3, " perimeter = %f", d);
return (d);
}
/*!
\brief Creates buffer around area.
\param Map vector map
\param area area id
\param da distance along major axis
\param db distance along minor axis
\param dalpha angle between 0x and major axis
\param round make corners round
\param caps add caps at line ends
\param tol maximum distance between theoretical arc and output segments
\param[out] oPoints output polygon outer border (ccw order)
\param[out] inner_count number of holes
\param[out] iPoints array of output polygon's holes (cw order)
*/
void Vect_area_buffer2(struct Map_info *Map, int area, double da, double db,
double dalpha, int round, int caps, double tol,
struct line_pnts **oPoints,
struct line_pnts ***iPoints, int *inner_count)
{
struct line_pnts *tPoints, *outer;
struct line_pnts **isles;
int isles_count = 0, n_isles;
int i, isle;
int more = 8;
int isles_allocated = 0;
G_debug(2, "Vect_area_buffer()");
/* initializations */
tPoints = Vect_new_line_struct();
n_isles = Vect_get_area_num_isles(Map, area);
isles_allocated = n_isles;
isles = G_malloc(isles_allocated * sizeof(struct line_pnts *));
/* outer contour */
outer = Vect_new_line_struct();
Vect_get_area_points(Map, area, outer);
/* does not work with zero length line segments */
Vect_line_prune(outer);
/* inner contours */
for (i = 0; i < n_isles; i++) {
isle = Vect_get_area_isle(Map, area, i);
Vect_get_isle_points(Map, isle, tPoints);
/* Check if the isle is big enough */
/*
if (Vect_line_length(tPoints) < 2*PI*max)
continue;
*/
/* does not work with zero length line segments */
Vect_line_prune(tPoints);
add_line_to_array(tPoints, &isles, &isles_count, &isles_allocated,
more);
tPoints = Vect_new_line_struct();
}
buffer_lines(outer, isles, isles_count, 0, da, db, dalpha, round, caps,
tol, oPoints, iPoints, inner_count);
Vect_destroy_line_struct(tPoints);
Vect_destroy_line_struct(outer);
destroy_lines_array(isles, isles_count);
return;
}
static int merge_lines(struct line_pnts *Points1, struct line_cats *Cats1,
struct line_pnts *Points2, struct line_cats *Cats2,
double thresh, struct line_pnts **Points)
{
struct line_pnts *ps = *Points;
struct line_cats *cs = Cats1;
int i, mindistidx;
double mindist;
/* find mininal distance and its index */
mindist = Vedit_get_min_distance(Points1, Points2, 0, /* TODO 3D */
&mindistidx);
G_debug(3, " merge line ? index: %d, mindist: %g, thresh: %g",
mindistidx, mindist, thresh);
if (thresh > 0 && mindist > thresh) {
return 0;
}
/* set index and other things */
switch (mindistidx) {
/* for each mindistidx create new line */
case 0:
Vect_append_points(ps, Points2, GV_BACKWARD);
if (ps->n_points == Points2->n_points)
Vect_append_points(ps, Points1, GV_FORWARD);
break;
case 1:
Vect_append_points(ps, Points2, GV_FORWARD);
if (ps->n_points == Points2->n_points)
Vect_append_points(ps, Points1, GV_FORWARD);
break;
case 2:
if (ps->n_points == 0)
Vect_append_points(ps, Points1, GV_FORWARD);
Vect_append_points(ps, Points2, GV_FORWARD);
break;
case 3:
if (ps->n_points == 0)
Vect_append_points(ps, Points1, GV_FORWARD);
Vect_append_points(ps, Points2, GV_BACKWARD);
break;
default:
break;
}
/* remove duplicate points */
Vect_line_prune(ps);
/* copy categories if needed */
for (i = 0; i < Cats2->n_cats; i++) {
Vect_cat_set(cs, Cats2->field[i], Cats2->cat[i]);
}
return 1;
}
/*!
\brief Returns area of area without areas of isles
\param Map pointer to Map_info structure
\param area area id
\return area of area without areas of isles
*/
double Vect_get_area_area(const struct Map_info *Map, int area)
{
const struct Plus_head *Plus;
struct P_area *Area;
struct line_pnts *Points;
double size;
int i;
static int first_time = 1;
G_debug(3, "Vect_get_area_area(): area = %d", area);
if (first_time == 1) {
G_begin_polygon_area_calculations();
first_time = 0;
}
Points = Vect_new_line_struct();
Plus = &(Map->plus);
Area = Plus->Area[area];
Vect_get_area_points(Map, area, Points);
Vect_line_prune(Points);
size = G_area_of_polygon(Points->x, Points->y, Points->n_points);
/* substracting island areas */
for (i = 0; i < Area->n_isles; i++) {
Vect_get_isle_points(Map, Area->isles[i], Points);
Vect_line_prune(Points);
size -= G_area_of_polygon(Points->x, Points->y, Points->n_points);
}
Vect_destroy_line_struct(Points);
G_debug(3, " area = %f", size);
return (size);
}
/*!
\brief Creates buffer around line.
See also Vect_line_buffer().
\param InPoints input line geometry
\param da distance along major axis
\param db distance along minor axis
\param dalpha angle between 0x and major axis
\param round make corners round
\param caps add caps at line ends
\param tol maximum distance between theoretical arc and output segments
\param[out] oPoints output polygon outer border (ccw order)
\param[out] inner_count number of holes
\param[out] iPoints array of output polygon's holes (cw order)
*/
void Vect_line_buffer2(struct line_pnts *Points, double da, double db,
double dalpha, int round, int caps, double tol,
struct line_pnts **oPoints,
struct line_pnts ***iPoints, int *inner_count)
{
struct planar_graph *pg;
struct line_pnts *tPoints, *outer;
struct line_pnts **isles;
int isles_count = 0;
int res, winding;
int more = 8;
int isles_allocated = 0;
G_debug(2, "Vect_line_buffer()");
Vect_line_prune(Points);
if (Points->n_points == 1)
return Vect_point_buffer2(Points->x[0], Points->y[0], da, db,
dalpha, round, tol, oPoints);
/* initializations */
tPoints = Vect_new_line_struct();
isles = NULL;
pg = pg_create(Points);
/* outer contour */
outer = Vect_new_line_struct();
extract_outer_contour(pg, 0, outer);
/* inner contours */
res = extract_inner_contour(pg, &winding, tPoints);
while (res != 0) {
add_line_to_array(tPoints, &isles, &isles_count, &isles_allocated,
more);
tPoints = Vect_new_line_struct();
res = extract_inner_contour(pg, &winding, tPoints);
}
buffer_lines(outer, isles, isles_count, RIGHT_SIDE, da, db, dalpha, round,
caps, tol, oPoints, iPoints, inner_count);
Vect_destroy_line_struct(tPoints);
Vect_destroy_line_struct(outer);
destroy_lines_array(isles, isles_count);
pg_destroy_struct(pg);
return;
}
/*!
\brief Create line segment.
Creates segment of InPoints from start to end measured along the
line and write it to OutPoints.
If the distance is greater than line length or negative, error is
returned.
\param InPoints input line
\param start segment number
\param end segment number
\param OutPoints output line
\return 1 success
\return 0 error when start > length or end < 0 or start < 0 or end > length
*/
int Vect_line_segment(const struct line_pnts *InPoints, double start, double end,
struct line_pnts *OutPoints)
{
int i, seg1, seg2;
double length, tmp;
double x1, y1, z1, x2, y2, z2;
G_debug(3, "Vect_line_segment(): start = %f, end = %f, n_points = %d",
start, end, InPoints->n_points);
Vect_reset_line(OutPoints);
if (start > end) {
tmp = start;
start = end;
end = tmp;
}
/* Check start/end */
if (end < 0)
return 0;
length = Vect_line_length(InPoints);
if (start > length)
return 0;
/* Find coordinates and segments of start/end */
seg1 = Vect_point_on_line(InPoints, start, &x1, &y1, &z1, NULL, NULL);
seg2 = Vect_point_on_line(InPoints, end, &x2, &y2, &z2, NULL, NULL);
G_debug(3, " -> seg1 = %d seg2 = %d", seg1, seg2);
if (seg1 == 0 || seg2 == 0) {
G_warning(_("Segment outside line, no segment created"));
return 0;
}
Vect_append_point(OutPoints, x1, y1, z1);
for (i = seg1; i < seg2; i++) {
Vect_append_point(OutPoints, InPoints->x[i], InPoints->y[i],
InPoints->z[i]);
};
Vect_append_point(OutPoints, x2, y2, z2);
Vect_line_prune(OutPoints);
return 1;
}
int QgsGrassEdit::writeLine( int type, struct line_pnts *Points )
{
int mode = mCatModeBox->currentIndex();
int field = mFieldBox->currentText().toInt();
int cat = mCatEntry->text().toInt();
Vect_reset_cats( mCats );
if ( mode == CAT_MODE_NEXT || mode == CAT_MODE_MANUAL )
{
Vect_cat_set( mCats, field, cat );
// Insert new DB record if link is defined and the record for this cat does not exist
QString *key = mProvider->key( field );
if ( !key->isEmpty() ) // Database link defined
{
QgsAttributeMap *atts = mProvider->attributes( field, cat );
if ( atts->count() == 0 ) // Nothing selected
{
QString *error = mProvider->insertAttributes( field, cat );
if ( !error->isEmpty() )
{
QMessageBox::warning( 0, tr( "Warning" ), *error );
}
delete error;
}
delete atts;
}
}
Vect_line_prune( Points );
int line = mProvider->writeLine( type, Points, mCats );
increaseMaxCat();
return line;
}
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[])
{
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);
}
static int write_smooth_bnd(struct COOR *line_begin, struct COOR *line_end, /* start and end point of line */
int n /* number of points to write */
)
{
static struct line_pnts *points = NULL;
double x, y;
double dx, dy;
int idx, idy;
struct COOR *p, *last;
int i, total;
if (!points)
points = Vect_new_line_struct();
Vect_reset_line(points);
n++; /* %% 6.4.88 */
p = line_begin;
/* allocate the arrays and get the first point */
y = cell_head.north - (double)p->row * cell_head.ns_res;
x = cell_head.west + (double)p->col * cell_head.ew_res;
Vect_append_point(points, x, y, 0.0);
/* generate the list of smoothed points, may be duplicate points */
total = 1;
for (i = 1; i < n; i++) {
if (i < 10)
G_debug(3, " row: %d col: %d\n", p->row, p->col);
last = p;
if ((p = move(p)) == NULPTR) { /* this should NEVER happen */
G_debug(3, "write_line: line terminated unexpectedly\n");
G_debug(3, " previous (%d) point %p (%d,%d,%d) %p %p\n",
direction, last, last->row, last->col, last->node,
last->fptr, last->bptr);
exit(EXIT_FAILURE);
}
idy = (p->row - last->row);
idx = (p->col - last->col);
dy = (idy > 0) ? 0.5 : ((idy < 0) ? -0.5 : 0.0); /* dy = 0.0, 0.5, or -0.5 */
dx = (idx > 0) ? 0.5 : ((idx < 0) ? -0.5 : 0.0); /* dx = 0.0, 0.5, or -0.5 */
y = cell_head.north - (last->row + dy) * cell_head.ns_res;
x = cell_head.west + (last->col + dx) * cell_head.ew_res;
total++;
Vect_append_point(points, x, y, 0.0);
y = cell_head.north - (p->row - dy) * cell_head.ns_res;
x = cell_head.west + (p->col - dx) * cell_head.ew_res;
total++;
Vect_append_point(points, x, y, 0.0);
} /* end of for i */
y = cell_head.north - (double)p->row * cell_head.ns_res;
x = cell_head.west + (double)p->col * cell_head.ew_res;
total++;
Vect_append_point(points, x, y, 0.0);
/* strip out the duplicate points from the list */
Vect_line_prune(points);
G_debug(3, "removed duplicates: %d", total - points->n_points);
/* write files */
Vect_write_line(&Map, GV_BOUNDARY, points, Cats);
/* now free all the pointers */
p = line_begin;
for (i = 1; i < n; i++) {
if (i < 10)
G_debug(3, " row: %d col: %d\n", p->row, p->col);
last = p;
if ((p = move(p)) == NULPTR)
break;
if (last == p)
break;
if (last->fptr != NULPTR)
if (last->fptr->fptr == last)
last->fptr->fptr = NULPTR;
/* now it can already ne NULL */
if (last->fptr != NULPTR)
if (last->fptr->bptr == last)
last->fptr->bptr = NULPTR;
if (last->bptr != NULPTR)
if (last->bptr->fptr == last)
last->bptr->fptr = NULPTR;
if (last->bptr != NULPTR)
if (last->bptr->bptr == last)
last->bptr->bptr = NULPTR;
G_free(last);
} /* end of for i */
if (p != NULPTR)
G_free(p);
return 0;
}
/* 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);
}
/* parallel_line - remove duplicate points from input line and
* creates new parallel line in 'd' offset distance;
* 'tol' is tolerance between arc and polyline;
* this function doesn't care about created loops;
*
* New line is written to existing nPoints structure.
*/
static void parallel_line(struct line_pnts *Points, double d, double tol,
struct line_pnts *nPoints)
{
int i, j, np, na, side;
double *x, *y, nx, ny, tx, ty, vx, vy, ux, uy, wx, wy;
double atol, atol2, a, av, aw;
G_debug(4, "parallel_line()");
Vect_reset_line(nPoints);
Vect_line_prune(Points);
np = Points->n_points;
x = Points->x;
y = Points->y;
if (np == 0)
return;
if (np == 1) {
Vect_append_point(nPoints, x[0], y[0], 0); /* ? OK, should make circle for points ? */
return;
}
if (d == 0) {
Vect_copy_xyz_to_pnts(nPoints, x, y, NULL, np);
return;
}
side = (int)(d / fabs(d));
atol = 2 * acos(1 - tol / fabs(d));
for (i = 0; i < np - 1; i++) {
vect(x[i], y[i], x[i + 1], y[i + 1], &tx, &ty);
vx = ty * d;
vy = -tx * d;
nx = x[i] + vx;
ny = y[i] + vy;
Vect_append_point(nPoints, nx, ny, 0);
nx = x[i + 1] + vx;
ny = y[i + 1] + vy;
Vect_append_point(nPoints, nx, ny, 0);
if (i < np - 2) { /* use polyline instead of arc between line segments */
vect(x[i + 1], y[i + 1], x[i + 2], y[i + 2], &ux, &uy);
wx = uy * d;
wy = -ux * d;
av = atan2(vy, vx);
aw = atan2(wy, wx);
a = (aw - av) * side;
if (a < 0)
a += 2 * PI;
/* TODO: a <= PI can probably fail because of representation error */
if (a <= PI && a > atol) {
na = (int)(a / atol);
atol2 = a / (na + 1) * side;
for (j = 0; j < na; j++) {
av += atol2;
nx = x[i + 1] + fabs(d) * cos(av);
ny = y[i + 1] + fabs(d) * sin(av);
Vect_append_point(nPoints, nx, ny, 0);
}
}
}
}
Vect_line_prune(nPoints);
}
int main(int argc, char *argv[])
{
int i, type, stat;
int day, yr, Out_proj;
int out_zone = 0;
int overwrite; /* overwrite output map */
const char *mapset;
const char *omap_name, *map_name, *iset_name, *iloc_name;
struct pj_info info_in;
struct pj_info info_out;
const char *gbase;
char date[40], mon[4];
struct GModule *module;
struct Option *omapopt, *mapopt, *isetopt, *ilocopt, *ibaseopt, *smax;
struct Key_Value *in_proj_keys, *in_unit_keys;
struct Key_Value *out_proj_keys, *out_unit_keys;
struct line_pnts *Points, *Points2;
struct line_cats *Cats;
struct Map_info Map;
struct Map_info Out_Map;
struct bound_box src_box, tgt_box;
int nowrap = 0, recommend_nowrap = 0;
double lmax;
struct
{
struct Flag *list; /* list files in source location */
struct Flag *transformz; /* treat z as ellipsoidal height */
struct Flag *wrap; /* latlon output: wrap to 0,360 */
struct Flag *no_topol; /* do not build topology */
} flag;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("projection"));
G_add_keyword(_("transformation"));
G_add_keyword(_("import"));
module->description = _("Re-projects a vector map from one location to the current location.");
/* set up the options and flags for the command line parser */
ilocopt = G_define_standard_option(G_OPT_M_LOCATION);
ilocopt->required = YES;
ilocopt->label = _("Location containing input vector map");
ilocopt->guisection = _("Source");
isetopt = G_define_standard_option(G_OPT_M_MAPSET);
isetopt->label = _("Mapset containing input vector map");
isetopt->description = _("Default: name of current mapset");
isetopt->guisection = _("Source");
mapopt = G_define_standard_option(G_OPT_V_INPUT);
mapopt->required = NO;
mapopt->label = _("Name of input vector map to re-project");
mapopt->description = NULL;
mapopt->guisection = _("Source");
ibaseopt = G_define_standard_option(G_OPT_M_DBASE);
ibaseopt->label = _("Path to GRASS database of input location");
smax = G_define_option();
smax->key = "smax";
smax->type = TYPE_DOUBLE;
smax->required = NO;
smax->answer = "10000";
smax->label = _("Maximum segment length in meters in output vector map");
smax->description = _("Increases accuracy of reprojected shapes, disable with smax=0");
smax->guisection = _("Target");
omapopt = G_define_standard_option(G_OPT_V_OUTPUT);
omapopt->required = NO;
omapopt->description = _("Name for output vector map (default: input)");
omapopt->guisection = _("Target");
flag.list = G_define_flag();
flag.list->key = 'l';
flag.list->description = _("List vector maps in input mapset and exit");
flag.transformz = G_define_flag();
flag.transformz->key = 'z';
flag.transformz->description = _("3D vector maps only");
flag.transformz->label =
_("Assume z coordinate is ellipsoidal height and "
"transform if possible");
flag.transformz->guisection = _("Target");
flag.wrap = G_define_flag();
flag.wrap->key = 'w';
flag.wrap->description = _("Latlon output only, default is -180,180");
flag.wrap->label =
_("Disable wrapping to -180,180 for latlon output");
flag.transformz->guisection = _("Target");
flag.no_topol = G_define_flag();
flag.no_topol->key = 'b';
flag.no_topol->label = _("Do not build vector topology");
flag.no_topol->description = _("Recommended for massive point projection");
/* The parser checks if the map already exists in current mapset,
we switch out the check and do it
in the module after the parser */
overwrite = G_check_overwrite(argc, argv);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* start checking options and flags */
/* set input vector map name and mapset */
map_name = mapopt->answer;
if (omapopt->answer)
omap_name = omapopt->answer;
else
omap_name = map_name;
if (omap_name && !flag.list->answer && !overwrite &&
G_find_vector2(omap_name, G_mapset()))
G_fatal_error(_("option <%s>: <%s> exists. To overwrite, use the --overwrite flag"), omapopt->key,
omap_name);
if (isetopt->answer)
iset_name = isetopt->answer;
else
iset_name = G_store(G_mapset());
iloc_name = ilocopt->answer;
if (ibaseopt->answer)
gbase = ibaseopt->answer;
else
gbase = G_store(G_gisdbase());
if (!ibaseopt->answer && strcmp(iloc_name, G_location()) == 0)
G_fatal_error(_("Input and output locations can not be the same"));
lmax = atof(smax->answer);
if (lmax < 0)
lmax = 0;
Out_proj = G_projection();
if (Out_proj == PROJECTION_LL && flag.wrap->answer)
nowrap = 1;
G_begin_distance_calculations();
/* Change the location here and then come back */
select_target_env();
G_setenv_nogisrc("GISDBASE", gbase);
G_setenv_nogisrc("LOCATION_NAME", iloc_name);
stat = G_mapset_permissions(iset_name);
if (stat >= 0) { /* yes, we can access the mapset */
/* if requested, list the vector maps in source location - MN 5/2001 */
if (flag.list->answer) {
int i;
char **list;
G_verbose_message(_("Checking location <%s> mapset <%s>"),
iloc_name, iset_name);
list = G_list(G_ELEMENT_VECTOR, G_getenv_nofatal("GISDBASE"),
G_getenv_nofatal("LOCATION_NAME"), iset_name);
if (list[0]) {
for (i = 0; list[i]; i++) {
fprintf(stdout, "%s\n", list[i]);
}
fflush(stdout);
}
else {
G_important_message(_("No vector maps found"));
}
exit(EXIT_SUCCESS); /* leave v.proj after listing */
}
if (mapopt->answer == NULL) {
G_fatal_error(_("Required parameter <%s> not set"), mapopt->key);
}
G_setenv_nogisrc("MAPSET", iset_name);
/* Make sure map is available */
mapset = G_find_vector2(map_name, iset_name);
if (mapset == NULL)
G_fatal_error(_("Vector map <%s> in location <%s> mapset <%s> not found"),
map_name, iloc_name, iset_name);
/*** Get projection info for input mapset ***/
in_proj_keys = G_get_projinfo();
if (in_proj_keys == NULL)
exit(EXIT_FAILURE);
/* apparently the +over switch must be set in the input projection,
* not the output latlon projection */
if (Out_proj == PROJECTION_LL && nowrap == 1)
G_set_key_value("+over", "defined", in_proj_keys);
in_unit_keys = G_get_projunits();
if (in_unit_keys == NULL)
exit(EXIT_FAILURE);
if (pj_get_kv(&info_in, in_proj_keys, in_unit_keys) < 0)
exit(EXIT_FAILURE);
Vect_set_open_level(1);
G_debug(1, "Open old: location: %s mapset : %s", G_location_path(),
G_mapset());
if (Vect_open_old(&Map, map_name, mapset) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), map_name);
}
else if (stat < 0)
{ /* allow 0 (i.e. denied permission) */
/* need to be able to read from others */
if (stat == 0)
G_fatal_error(_("Mapset <%s> in input location <%s> - permission denied"),
iset_name, iloc_name);
else
G_fatal_error(_("Mapset <%s> in input location <%s> not found"),
iset_name, iloc_name);
}
select_current_env();
/****** get the output projection parameters ******/
out_proj_keys = G_get_projinfo();
if (out_proj_keys == NULL)
exit(EXIT_FAILURE);
out_unit_keys = G_get_projunits();
if (out_unit_keys == NULL)
exit(EXIT_FAILURE);
if (pj_get_kv(&info_out, out_proj_keys, out_unit_keys) < 0)
exit(EXIT_FAILURE);
G_free_key_value(in_proj_keys);
G_free_key_value(in_unit_keys);
G_free_key_value(out_proj_keys);
G_free_key_value(out_unit_keys);
if (G_verbose() == G_verbose_max()) {
pj_print_proj_params(&info_in, &info_out);
}
/* Initialize the Point / Cat structure */
Points = Vect_new_line_struct();
Points2 = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
/* test if latlon wrapping to -180,180 should be disabled */
if (Out_proj == PROJECTION_LL && nowrap == 0) {
int first = 1, counter = 0;
double x, y;
/* Cycle through all lines */
Vect_rewind(&Map);
while (1) {
type = Vect_read_next_line(&Map, Points, Cats); /* read line */
if (type == 0)
continue; /* Dead */
if (type == -1)
G_fatal_error(_("Reading input vector map"));
if (type == -2)
break;
if (first && Points->n_points > 0) {
first = 0;
src_box.E = src_box.W = Points->x[0];
src_box.N = src_box.S = Points->y[0];
src_box.T = src_box.B = Points->z[0];
}
for (i = 0; i < Points->n_points; i++) {
if (src_box.E < Points->x[i])
src_box.E = Points->x[i];
if (src_box.W > Points->x[i])
src_box.W = Points->x[i];
if (src_box.N < Points->y[i])
src_box.N = Points->y[i];
if (src_box.S > Points->y[i])
src_box.S = Points->y[i];
}
counter++;
}
if (counter == 0) {
G_warning(_("Input vector map <%s> is empty"), omap_name);
exit(EXIT_SUCCESS);
}
/* NW corner */
x = src_box.W;
y = src_box.N;
if (pj_do_transform(1, &x, &y, NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Error in pj_do_transform"));
}
tgt_box.E = x;
tgt_box.W = x;
tgt_box.N = y;
tgt_box.S = y;
/* SW corner */
x = src_box.W;
y = src_box.S;
if (pj_do_transform(1, &x, &y, NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Error in pj_do_transform"));
}
if (tgt_box.W > x)
tgt_box.W = x;
if (tgt_box.E < x)
tgt_box.E = x;
if (tgt_box.N < y)
tgt_box.N = y;
if (tgt_box.S > y)
tgt_box.S = y;
/* NE corner */
x = src_box.E;
y = src_box.N;
if (pj_do_transform(1, &x, &y, NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Error in pj_do_transform"));
}
if (tgt_box.W > x) {
tgt_box.E = x + 360;
recommend_nowrap = 1;
}
if (tgt_box.N < y)
tgt_box.N = y;
if (tgt_box.S > y)
tgt_box.S = y;
/* SE corner */
x = src_box.E;
y = src_box.S;
if (pj_do_transform(1, &x, &y, NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Error in pj_do_transform"));
}
if (tgt_box.W > x) {
if (tgt_box.E < x + 360)
tgt_box.E = x + 360;
recommend_nowrap = 1;
}
if (tgt_box.N < y)
tgt_box.N = y;
if (tgt_box.S > y)
tgt_box.S = y;
}
G_debug(1, "Open new: location: %s mapset : %s", G_location_path(),
G_mapset());
if (Vect_open_new(&Out_Map, omap_name, Vect_is_3d(&Map)) < 0)
G_fatal_error(_("Unable to create vector map <%s>"), omap_name);
Vect_set_error_handler_io(NULL, &Out_Map); /* register standard i/o error handler */
Vect_copy_head_data(&Map, &Out_Map);
Vect_hist_copy(&Map, &Out_Map);
Vect_hist_command(&Out_Map);
out_zone = info_out.zone;
Vect_set_zone(&Out_Map, out_zone);
/* Read and write header info */
sprintf(date, "%s", G_date());
sscanf(date, "%*s%s%d%*s%d", mon, &day, &yr);
if (yr < 2000)
yr = yr - 1900;
else
yr = yr - 2000;
sprintf(date, "%s %d %d", mon, day, yr);
Vect_set_date(&Out_Map, date);
/* line densification works only with vector topology */
if (Map.format != GV_FORMAT_NATIVE)
lmax = 0;
/* Cycle through all lines */
Vect_rewind(&Map);
i = 0;
G_message(_("Reprojecting primitives ..."));
while (TRUE) {
++i;
G_progress(i, 1e3);
type = Vect_read_next_line(&Map, Points, Cats); /* read line */
if (type == 0)
continue; /* Dead */
if (type == -1)
G_fatal_error(_("Reading input vector map"));
if (type == -2)
break;
Vect_line_prune(Points);
if (lmax > 0 && (type & GV_LINES) && Points->n_points > 1) {
double x1, y1, z1, x2, y2, z2;
double dx, dy, dz;
double l;
int i, n;
Vect_reset_line(Points2);
for (i = 0; i < Points->n_points - 1; i++) {
x1 = Points->x[i];
y1 = Points->y[i];
z1 = Points->z[i];
n = i + 1;
x2 = Points->x[n];
y2 = Points->y[n];
z2 = Points->z[n];
dx = x2 - x1;
dy = y2 - y1;
dz = z2 - z1;
if (pj_do_transform(1, &x1, &y1,
flag.transformz->answer ? &z1 : NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Unable to re-project vector map <%s> from <%s>"),
Vect_get_full_name(&Map), ilocopt->answer);
}
if (pj_do_transform(1, &x2, &y2,
flag.transformz->answer ? &z2 : NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Unable to re-project vector map <%s> from <%s>"),
Vect_get_full_name(&Map), ilocopt->answer);
}
Vect_append_point(Points2, x1, y1, z1);
l = G_distance(x1, y1, x2, y2);
if (l > lmax) {
int j;
double x, y, z;
x1 = Points->x[i];
y1 = Points->y[i];
z1 = Points->z[i];
n = ceil(l / lmax);
for (j = 1; j < n; j++) {
x = x1 + dx * j / n;
y = y1 + dy * j / n;
z = z1 + dz * j / n;
if (pj_do_transform(1, &x, &y,
flag.transformz->answer ? &z : NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Unable to re-project vector map <%s> from <%s>"),
Vect_get_full_name(&Map), ilocopt->answer);
}
Vect_append_point(Points2, x, y, z);
}
}
}
Vect_append_point(Points2, x2, y2, z2);
Vect_write_line(&Out_Map, type, Points2, Cats); /* write line */
}
else {
if (pj_do_transform(Points->n_points, Points->x, Points->y,
flag.transformz->answer ? Points->z : NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Unable to re-project vector map <%s> from <%s>"),
Vect_get_full_name(&Map), ilocopt->answer);
}
Vect_write_line(&Out_Map, type, Points, Cats); /* write line */
}
} /* end lines section */
G_progress(1, 1);
/* Copy tables */
if (Vect_copy_tables(&Map, &Out_Map, 0))
G_warning(_("Failed to copy attribute table to output map"));
Vect_close(&Map);
if (!flag.no_topol->answer)
Vect_build(&Out_Map);
Vect_close(&Out_Map);
if (recommend_nowrap)
G_important_message(_("Try to disable wrapping to -180,180 "
"if topological errors occurred"));
exit(EXIT_SUCCESS);
}
/*
* This function generates parallel line (with loops, but not like the old ones).
* It is not to be used directly for creating buffers.
* + added elliptical buffers/par.lines support
*
* dalpha - direction of elliptical buffer major axis in degrees
* da - distance along major axis
* db: distance along minor (perp.) axis
* side: side >= 0 - right side, side < 0 - left side
* when (da == db) we have plain distances (old case)
* round - 1 for round corners, 0 for sharp corners. (tol is used only if round == 1)
*/
static void parallel_line(struct line_pnts *Points, double da, double db,
double dalpha, int side, int round, int caps, int looped,
double tol, struct line_pnts *nPoints)
{
int i, j, res, np;
double *x, *y;
double tx, ty, vx, vy, wx, wy, nx, ny, mx, my, rx, ry;
double vx1, vy1, wx1, wy1;
double a0, b0, c0, a1, b1, c1;
double phi1, phi2, delta_phi;
double nsegments, angular_tol, angular_step;
int inner_corner, turns360;
G_debug(3, "parallel_line()");
if (looped && 0) {
/* start point != end point */
return;
}
Vect_reset_line(nPoints);
if (looped) {
Vect_append_point(Points, Points->x[1], Points->y[1], Points->z[1]);
}
np = Points->n_points;
x = Points->x;
y = Points->y;
if ((np == 0) || (np == 1))
return;
if ((da == 0) || (db == 0)) {
Vect_copy_xyz_to_pnts(nPoints, x, y, NULL, np);
return;
}
side = (side >= 0) ? (1) : (-1); /* normalize variable */
dalpha *= PI / 180; /* convert dalpha from degrees to radians */
angular_tol = angular_tolerance(tol, da, db);
for (i = 0; i < np - 1; i++) {
/* save the old values */
a0 = a1;
b0 = b1;
c0 = c1;
wx = vx;
wy = vy;
norm_vector(x[i], y[i], x[i + 1], y[i + 1], &tx, &ty);
if ((tx == 0) && (ty == 0))
continue;
elliptic_tangent(side * tx, side * ty, da, db, dalpha, &vx, &vy);
nx = x[i] + vx;
ny = y[i] + vy;
mx = x[i + 1] + vx;
my = y[i + 1] + vy;
line_coefficients(nx, ny, mx, my, &a1, &b1, &c1);
if (i == 0) {
if (!looped)
Vect_append_point(nPoints, nx, ny, 0);
continue;
}
delta_phi = atan2(ty, tx) - atan2(y[i] - y[i - 1], x[i] - x[i - 1]);
if (delta_phi > PI)
delta_phi -= 2 * PI;
else if (delta_phi <= -PI)
delta_phi += 2 * PI;
/* now delta_phi is in [-pi;pi] */
turns360 = (fabs(fabs(delta_phi) - PI) < 1e-15);
inner_corner = (side * delta_phi <= 0) && (!turns360);
if ((turns360) && (!(caps && round))) {
if (caps) {
norm_vector(0, 0, vx, vy, &tx, &ty);
elliptic_tangent(side * tx, side * ty, da, db, dalpha, &tx,
&ty);
}
else {
tx = 0;
ty = 0;
}
Vect_append_point(nPoints, x[i] + wx + tx, y[i] + wy + ty, 0);
Vect_append_point(nPoints, nx + tx, ny + ty, 0); /* nx == x[i] + vx, ny == y[i] + vy */
}
else if ((!round) || inner_corner) {
res = line_intersection(a0, b0, c0, a1, b1, c1, &rx, &ry);
/* if (res == 0) {
G_debug(4, "a0=%.18f, b0=%.18f, c0=%.18f, a1=%.18f, b1=%.18f, c1=%.18f", a0, b0, c0, a1, b1, c1);
G_fatal_error("Two consequtive line segments are parallel, but not on one straight line! This should never happen.");
return;
} */
if (res == 1) {
if (!round)
Vect_append_point(nPoints, rx, ry, 0);
else {
/* d = dig_distance2_point_to_line(rx, ry, 0, x[i-1], y[i-1], 0, x[i], y[i], 0,
0, NULL, NULL, NULL, NULL, NULL);
if ( */
Vect_append_point(nPoints, rx, ry, 0);
}
}
}
else {
/* we should draw elliptical arc for outside corner */
/* inverse transforms */
elliptic_transform(wx, wy, 1 / da, 1 / db, dalpha, &wx1, &wy1);
elliptic_transform(vx, vy, 1 / da, 1 / db, dalpha, &vx1, &vy1);
phi1 = atan2(wy1, wx1);
phi2 = atan2(vy1, vx1);
delta_phi = side * (phi2 - phi1);
/* make delta_phi in [0, 2pi] */
if (delta_phi < 0)
delta_phi += 2 * PI;
nsegments = (int)(delta_phi / angular_tol) + 1;
angular_step = side * (delta_phi / nsegments);
for (j = 0; j <= nsegments; j++) {
elliptic_transform(cos(phi1), sin(phi1), da, db, dalpha, &tx,
&ty);
Vect_append_point(nPoints, x[i] + tx, y[i] + ty, 0);
phi1 += angular_step;
}
}
if ((!looped) && (i == np - 2)) {
Vect_append_point(nPoints, mx, my, 0);
}
}
if (looped) {
Vect_append_point(nPoints, nPoints->x[0], nPoints->y[0],
nPoints->z[0]);
}
Vect_line_prune(nPoints);
if (looped) {
Vect_line_delete_point(Points, Points->n_points - 1);
}
}
void QgsGrassEditAddVertex::mouseClick( QgsPoint & point, Qt::MouseButton button )
{
double thresh = e->threshold();
switch ( button )
{
case Qt::LeftButton:
// Add vertex to previously selected line
if ( e->mSelectedLine > 0 )
{
e->eraseDynamic();
e->eraseElement( e->mSelectedLine );
// Move vertex
int type = e->mProvider->readLine( e->mPoints, e->mCats, e->mSelectedLine );
if ( e->mAddVertexEnd && e->mSelectedPart == e->mEditPoints->n_points - 1 )
{
e->snap( point );
Vect_append_point( e->mPoints, point.x(), point.y(), 0.0 );
}
else
{
Vect_line_insert_point( e->mPoints, e->mSelectedPart, point.x(), point.y(), 0.0 );
}
Vect_line_prune( e->mPoints );
e->mProvider->rewriteLine( e->mSelectedLine, type, e->mPoints, e->mCats );
e->updateSymb();
e->displayUpdated();
e->mSelectedLine = 0;
Vect_reset_line( e->mEditPoints );
e->setCanvasPrompt( tr( "Select line segment" ), "", "" );
}
else
{
// Select new line
e->mSelectedLine = e->mProvider->findLine( point.x(), point.y(), GV_LINES, thresh );
if ( e->mSelectedLine ) // highlite
{
e->mProvider->readLine( e->mEditPoints, NULL, e->mSelectedLine );
e->displayElement( e->mSelectedLine, e->mSymb[QgsGrassEdit::SYMB_HIGHLIGHT], e->mSize );
double xl, yl; // nearest point on the line
// Note first segment is 1!
e->mSelectedPart = Vect_line_distance( e->mEditPoints, point.x(), point.y(), 0.0, 0,
&xl, &yl, NULL, NULL, NULL, NULL );
double dist1 = Vect_points_distance( xl, yl, 0.0, e->mEditPoints->x[e->mSelectedPart-1],
e->mEditPoints->y[e->mSelectedPart-1], 0.0, 0 );
double dist2 = Vect_points_distance( xl, yl, 0.0, e->mEditPoints->x[e->mSelectedPart],
e->mEditPoints->y[e->mSelectedPart], 0.0, 0 );
double maxdist = ( dist1 + dist2 ) / 4;
if ( e->mSelectedPart == 1 && dist1 < maxdist )
{
e->mSelectedPart = 0;
e->mAddVertexEnd = true;
}
else if ( e->mSelectedPart == e->mEditPoints->n_points - 1 && dist2 < maxdist )
{
e->mAddVertexEnd = true;
}
else
{
e->mAddVertexEnd = false;
}
e->setCanvasPrompt( tr( "New vertex position" ), "", tr( "Release" ) );
}
else
{
e->setCanvasPrompt( tr( "Select line segment" ), "", "" );
}
}
break;
case Qt::RightButton:
e->eraseDynamic();
e->displayElement( e->mSelectedLine, e->mSymb[e->mLineSymb[e->mSelectedLine]], e->mSize );
e->mSelectedLine = 0;
Vect_reset_line( e->mEditPoints );
e->setCanvasPrompt( tr( "Select line segment" ), "", "" );
break;
default:
// ignore others
break;
}
}
/**
* \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;
}
/* input line must be looped */
static void convolution_line(struct line_pnts *Points, double da, double db,
double dalpha, int side, int round, int caps,
double tol, struct line_pnts *nPoints)
{
int i, j, res, np;
double *x, *y;
double tx, ty, vx, vy, wx, wy, nx, ny, mx, my, rx, ry;
double vx1, vy1, wx1, wy1;
double a0, b0, c0, a1, b1, c1;
double phi1, phi2, delta_phi;
double nsegments, angular_tol, angular_step;
double angle0, angle1;
int inner_corner, turns360;
G_debug(3, "convolution_line() side = %d", side);
np = Points->n_points;
x = Points->x;
y = Points->y;
if ((np == 0) || (np == 1))
return;
if ((x[0] != x[np - 1]) || (y[0] != y[np - 1])) {
G_fatal_error(_("Line is not looped"));
return;
}
Vect_reset_line(nPoints);
if ((da == 0) || (db == 0)) {
Vect_copy_xyz_to_pnts(nPoints, x, y, NULL, np);
return;
}
side = (side >= 0) ? (1) : (-1); /* normalize variable */
dalpha *= PI / 180; /* convert dalpha from degrees to radians */
angular_tol = angular_tolerance(tol, da, db);
i = np - 2;
norm_vector(x[i], y[i], x[i + 1], y[i + 1], &tx, &ty);
elliptic_tangent(side * tx, side * ty, da, db, dalpha, &vx, &vy);
angle1 = atan2(ty, tx);
nx = x[i] + vx;
ny = y[i] + vy;
mx = x[i + 1] + vx;
my = y[i + 1] + vy;
if (!round)
line_coefficients(nx, ny, mx, my, &a1, &b1, &c1);
for (i = 0; i <= np - 2; i++) {
G_debug(4, "point %d, segment %d-%d", i, i, i + 1);
/* save the old values */
if (!round) {
a0 = a1;
b0 = b1;
c0 = c1;
}
wx = vx;
wy = vy;
angle0 = angle1;
norm_vector(x[i], y[i], x[i + 1], y[i + 1], &tx, &ty);
if ((tx == 0) && (ty == 0))
continue;
elliptic_tangent(side * tx, side * ty, da, db, dalpha, &vx, &vy);
angle1 = atan2(ty, tx);
nx = x[i] + vx;
ny = y[i] + vy;
mx = x[i + 1] + vx;
my = y[i + 1] + vy;
if (!round)
line_coefficients(nx, ny, mx, my, &a1, &b1, &c1);
delta_phi = angle1 - angle0;
if (delta_phi > PI)
delta_phi -= 2 * PI;
else if (delta_phi <= -PI)
delta_phi += 2 * PI;
/* now delta_phi is in [-pi;pi] */
turns360 = (fabs(fabs(delta_phi) - PI) < 1e-15);
inner_corner = (side * delta_phi <= 0) && (!turns360);
/* if <line turns 360> and (<caps> and <not round>) */
if (turns360 && caps && (!round)) {
norm_vector(0, 0, vx, vy, &tx, &ty);
elliptic_tangent(side * tx, side * ty, da, db, dalpha, &tx, &ty);
Vect_append_point(nPoints, x[i] + wx + tx, y[i] + wy + ty, 0);
G_debug(4, " append point (c) x=%.16f y=%.16f", x[i] + wx + tx,
y[i] + wy + ty);
Vect_append_point(nPoints, nx + tx, ny + ty, 0); /* nx == x[i] + vx, ny == y[i] + vy */
G_debug(4, " append point (c) x=%.16f y=%.16f", nx + tx, ny + ty);
}
if ((!turns360) && (!round) && (!inner_corner)) {
res = line_intersection(a0, b0, c0, a1, b1, c1, &rx, &ry);
if (res == 1) {
Vect_append_point(nPoints, rx, ry, 0);
G_debug(4, " append point (o) x=%.16f y=%.16f", rx, ry);
}
else if (res == 2) {
/* no need to append point in this case */
}
else
G_fatal_error
("unexpected result of line_intersection() res = %d",
res);
}
if (round && (!inner_corner) && (!turns360 || caps)) {
/* we should draw elliptical arc for outside corner */
/* inverse transforms */
elliptic_transform(wx, wy, 1 / da, 1 / db, dalpha, &wx1, &wy1);
elliptic_transform(vx, vy, 1 / da, 1 / db, dalpha, &vx1, &vy1);
phi1 = atan2(wy1, wx1);
phi2 = atan2(vy1, vx1);
delta_phi = side * (phi2 - phi1);
/* make delta_phi in [0, 2pi] */
if (delta_phi < 0)
delta_phi += 2 * PI;
nsegments = (int)(delta_phi / angular_tol) + 1;
angular_step = side * (delta_phi / nsegments);
phi1 += angular_step;
for (j = 1; j <= nsegments - 1; j++) {
elliptic_transform(cos(phi1), sin(phi1), da, db, dalpha, &tx,
&ty);
Vect_append_point(nPoints, x[i] + tx, y[i] + ty, 0);
G_debug(4, " append point (r) x=%.16f y=%.16f", x[i] + tx,
y[i] + ty);
phi1 += angular_step;
}
}
Vect_append_point(nPoints, nx, ny, 0);
G_debug(4, " append point (s) x=%.16f y=%.16f", nx, ny);
Vect_append_point(nPoints, mx, my, 0);
G_debug(4, " append point (s) x=%.16f y=%.16f", mx, my);
}
/* close the output line */
Vect_append_point(nPoints, nPoints->x[0], nPoints->y[0], nPoints->z[0]);
Vect_line_prune ( nPoints );
}
/*
* side: side >= 0 - extracts contour on right side of edge, side < 0 - extracts contour on left side of edge
* if the extracted contour is the outer contour, it is returned in ccw order
* else if it is inner contour, it is returned in cw order
*/
static void extract_contour(struct planar_graph *pg, struct pg_edge *first,
int side, int winding, int stop_at_line_end,
struct line_pnts *nPoints)
{
int j;
int v; /* current vertex number */
int v0;
int eside; /* side of the current edge */
double eangle; /* current edge angle with Ox (according to the current direction) */
struct pg_vertex *vert; /* current vertex */
struct pg_vertex *vert0; /* last vertex */
struct pg_edge *edge; /* current edge; must be edge of vert */
/* int cs; *//* on which side are we turning along the contour */
/* we will always turn right and dont need that one */
double opt_angle, tangle;
int opt_j, opt_side, opt_flag;
G_debug(3,
"extract_contour(): v1=%d, v2=%d, side=%d, stop_at_line_end=%d",
first->v1, first->v2, side, stop_at_line_end);
Vect_reset_line(nPoints);
edge = first;
if (side >= 0) {
eside = 1;
v0 = edge->v1;
v = edge->v2;
}
else {
eside = -1;
v0 = edge->v2;
v = edge->v1;
}
vert0 = &(pg->v[v0]);
vert = &(pg->v[v]);
eangle = atan2(vert->y - vert0->y, vert->x - vert0->x);
while (1) {
if (nPoints->n_points > 0 && (nPoints->x[nPoints->n_points - 1] != vert0->x ||
nPoints->y[nPoints->n_points - 1] != vert0->y))
Vect_append_point(nPoints, vert0->x, vert0->y, 0);
else
Vect_append_point(nPoints, vert0->x, vert0->y, 0);
G_debug(4, "ec: v0=%d, v=%d, eside=%d, edge->v1=%d, edge->v2=%d", v0,
v, eside, edge->v1, edge->v2);
G_debug(4, "ec: append point x=%.18f y=%.18f", vert0->x, vert0->y);
/* mark current edge as visited on the appropriate side */
if (eside == 1) {
edge->visited_right = 1;
edge->winding_right = winding;
}
else {
edge->visited_left = 1;
edge->winding_left = winding;
}
opt_flag = 1;
for (j = 0; j < vert->ecount; j++) {
/* exclude current edge */
if (vert->edges[j] != edge) {
tangle = vert->angles[j] - eangle;
if (tangle < -PI)
tangle += 2 * PI;
else if (tangle > PI)
tangle -= 2 * PI;
/* now tangle is in (-PI, PI) */
if (opt_flag || (tangle < opt_angle)) {
opt_j = j;
opt_side = (vert->edges[j]->v1 == v) ? (1) : (-1);
opt_angle = tangle;
opt_flag = 0;
}
}
}
/*
G_debug(4, "ec: opt: side=%d opt_flag=%d opt_angle=%.18f opt_j=%d opt_step=%d",
side, opt_flag, opt_angle, opt_j, opt_step);
*/
/* if line end is reached (no other edges at curr vertex) */
if (opt_flag) {
if (stop_at_line_end) {
G_debug(3, " end has been reached, will stop here");
break;
}
else {
opt_j = 0; /* the only edge of vert is vert->edges[0] */
opt_side = -eside; /* go to the other side of the current edge */
G_debug(3, " end has been reached, turning around");
}
}
/* break condition */
if ((vert->edges[opt_j] == first) && (opt_side == side))
break;
if (opt_side == 1) {
if (vert->edges[opt_j]->visited_right) {
G_warning(_("Next edge was visited but it is not the first one !!! breaking loop"));
G_debug(4,
"ec: v0=%d, v=%d, eside=%d, edge->v1=%d, edge->v2=%d",
v, (edge->v1 == v) ? (edge->v2) : (edge->v1),
opt_side, vert->edges[opt_j]->v1,
vert->edges[opt_j]->v2);
break;
}
}
else {
if (vert->edges[opt_j]->visited_left) {
G_warning(_("Next edge was visited but it is not the first one !!! breaking loop"));
G_debug(4,
"ec: v0=%d, v=%d, eside=%d, edge->v1=%d, edge->v2=%d",
v, (edge->v1 == v) ? (edge->v2) : (edge->v1),
opt_side, vert->edges[opt_j]->v1,
vert->edges[opt_j]->v2);
break;
}
}
edge = vert->edges[opt_j];
eside = opt_side;
v0 = v;
v = (edge->v1 == v) ? (edge->v2) : (edge->v1);
vert0 = vert;
vert = &(pg->v[v]);
eangle = vert0->angles[opt_j];
}
Vect_append_point(nPoints, vert->x, vert->y, 0);
Vect_line_prune(nPoints);
G_debug(4, "ec: append point x=%.18f y=%.18f", vert->x, vert->y);
return;
}
/*!
\brief Build area on given side of line (GV_LEFT or GV_RIGHT)
\param Map pointer to Map_info structure
\param iline line id
\param side side (GV_LEFT or GV_RIGHT)
\return > 0 area id
\return < 0 isle id
\return 0 not created (may also already exist)
*/
int Vect_build_line_area(struct Map_info *Map, int iline, int side)
{
int area, isle, n_lines;
struct Plus_head *plus;
struct bound_box box;
static struct line_pnts *APoints = NULL;
plus_t *lines;
double area_size;
plus = &(Map->plus);
G_debug(3, "Vect_build_line_area() line = %d, side = %d", iline, side);
if (!APoints)
APoints = Vect_new_line_struct();
/* get area */
area = dig_line_get_area(plus, iline, side);
if (area != 0) {
/* -> there is already an area on this side of the line, skip */
G_debug(3, " area/isle = %d -> skip", area);
return 0;
}
/* build an area with this line */
n_lines = dig_build_area_with_line(plus, iline, side, &lines);
G_debug(3, " n_lines = %d", n_lines);
if (n_lines < 1) {
return 0;
} /* area was not built */
/* get line points which forms a boundary of an area */
Vect__get_area_points(Map, lines, n_lines, APoints);
dig_line_box(APoints, &box);
Vect_line_prune(APoints);
if (APoints->n_points < 4) {
G_warning(_("Area of size = 0.0 (less than 4 vertices) ignored"));
return 0;
}
/* Area or island ? */
dig_find_area_poly(APoints, &area_size);
/* area_size = dig_find_poly_orientation(APoints); */
/* area_size is not real area size, we are only interested in the sign */
G_debug(3, " area/isle size = %f", area_size);
if (area_size > 0) { /* CW: area */
/* add area structure to plus */
area = dig_add_area(plus, n_lines, lines, &box);
if (area == -1) { /* error */
G_fatal_error(_("Unable to add area (map closed, topo saved)"));
}
G_debug(3, " -> area %d", area);
return area;
}
else if (area_size < 0) { /* CCW: island */
isle = dig_add_isle(plus, n_lines, lines, &box);
if (isle == -1) { /* error */
G_fatal_error(_("Unable to add isle (map closed, topo saved)"));
}
G_debug(3, " -> isle %d", isle);
return -isle;
}
else {
/* TODO: What to do with such areas? Should be areas/isles of size 0 stored,
* so that may be found and cleaned by some utility
* Note: it would be useful for vertical closed polygons, but such would be added twice
* as area */
G_warning(_("Area of size = 0.0 ignored"));
}
return 0;
}
/* 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 Create buffer around the line line.
Buffer is closed counter clockwise polygon.
Warning: output line may contain loops!
\param InPoints input line
\param distance create buffer in distance
\param tolerance maximum distance between theoretical arc and polygon segments
\param[out] OutPoints output line
*/
void
Vect_line_buffer(struct line_pnts *InPoints, double distance,
double tolerance, struct line_pnts *OutPoints)
{
double dangle;
int side, npoints;
static struct line_pnts *Points = NULL;
static struct line_pnts *PPoints = NULL;
distance = fabs(distance);
dangle = 2 * acos(1 - tolerance / fabs(distance)); /* angle step */
if (Points == NULL)
Points = Vect_new_line_struct();
if (PPoints == NULL)
PPoints = Vect_new_line_struct();
/* Copy and prune input */
Vect_reset_line(Points);
Vect_append_points(Points, InPoints, GV_FORWARD);
Vect_line_prune(Points);
Vect_reset_line(OutPoints);
npoints = Points->n_points;
if (npoints <= 0) {
return;
}
else if (npoints == 1) { /* make a circle */
double angle, x, y;
for (angle = 0; angle < 2 * PI; angle += dangle) {
x = Points->x[0] + distance * cos(angle);
y = Points->y[0] + distance * sin(angle);
Vect_append_point(OutPoints, x, y, 0);
}
/* Close polygon */
Vect_append_point(OutPoints, OutPoints->x[0], OutPoints->y[0], 0);
}
else { /* 2 and more points */
for (side = 0; side < 2; side++) {
double angle, sangle;
double lx1, ly1, lx2, ly2;
double x, y, nx, ny, sx, sy, ex, ey;
/* Parallel on one side */
if (side == 0) {
Vect_line_parallel(Points, distance, tolerance, 0, PPoints);
Vect_append_points(OutPoints, PPoints, GV_FORWARD);
}
else {
Vect_line_parallel(Points, -distance, tolerance, 0, PPoints);
Vect_append_points(OutPoints, PPoints, GV_BACKWARD);
}
/* Arc at the end */
/* 2 points at theend of original line */
if (side == 0) {
lx1 = Points->x[npoints - 2];
ly1 = Points->y[npoints - 2];
lx2 = Points->x[npoints - 1];
ly2 = Points->y[npoints - 1];
}
else {
lx1 = Points->x[1];
ly1 = Points->y[1];
lx2 = Points->x[0];
ly2 = Points->y[0];
}
/* normalized vector */
vect(lx1, ly1, lx2, ly2, &nx, &ny);
/* starting point */
sangle = atan2(-nx, ny); /* starting angle */
sx = lx2 + ny * distance;
sy = ly2 - nx * distance;
/* end point */
ex = lx2 - ny * distance;
ey = ly2 + nx * distance;
Vect_append_point(OutPoints, sx, sy, 0);
/* arc */
for (angle = dangle; angle < PI; angle += dangle) {
x = lx2 + distance * cos(sangle + angle);
y = ly2 + distance * sin(sangle + angle);
Vect_append_point(OutPoints, x, y, 0);
}
Vect_append_point(OutPoints, ex, ey, 0);
}
/* Close polygon */
Vect_append_point(OutPoints, OutPoints->x[0], OutPoints->y[0], 0);
}
Vect_line_prune(OutPoints);
return;
}
int
Vect_break_lines_list(struct Map_info *Map, struct ilist *List_break,
struct ilist *List_ref, int type, struct Map_info *Err)
{
struct line_pnts *APoints, *BPoints, *Points;
struct line_pnts **AXLines, **BXLines;
struct line_cats *ACats, *BCats, *Cats;
int j, k, l, ret, atype, btype, aline, bline, found, iline, nlines;
int naxlines, nbxlines, nx;
double *xx = NULL, *yx = NULL, *zx = NULL;
struct bound_box ABox, BBox;
struct boxlist *List;
int nbreaks;
int touch1_n = 0, touch1_s = 0, touch1_e = 0, touch1_w = 0; /* other vertices except node1 touching box */
int touch2_n = 0, touch2_s = 0, touch2_e = 0, touch2_w = 0; /* other vertices except node2 touching box */
int is3d;
int node, anode1, anode2, bnode1, bnode2;
double nodex, nodey;
APoints = Vect_new_line_struct();
BPoints = Vect_new_line_struct();
Points = Vect_new_line_struct();
ACats = Vect_new_cats_struct();
BCats = Vect_new_cats_struct();
Cats = Vect_new_cats_struct();
List = Vect_new_boxlist(1);
is3d = Vect_is_3d(Map);
if (List_break) {
nlines = List_break->n_values;
}
else {
nlines = Vect_get_num_lines(Map);
}
G_debug(3, "nlines = %d", nlines);
/* TODO: It seems that lines/boundaries are not broken at intersections
* with points/centroids. Check if true, if yes, skip GV_POINTS
*/
/* To find intersection of two lines (Vect_line_intersection) is quite slow.
* Fortunately usual lines/boundaries in GIS often forms a network where lines
* are connected by end points, and touch by MBR. This function checks and occasionaly
* skips such cases. This is currently done for 2D only
*/
/* Go through all lines in vector, for each select lines which overlap MBR of
* this line exclude those connected by one endpoint (see above)
* and try to intersect, if lines intersect write new lines at the end of
* the file, and process next line (remaining lines overlapping box are skipped)
*/
nbreaks = 0;
for (iline = 0; iline < nlines; iline++) {
G_percent(iline, nlines, 1);
if (List_break) {
aline = List_break->value[iline];
}
else {
aline = iline + 1;
}
if (List_ref && !Vect_val_in_list(List_ref, aline))
continue;
G_debug(3, "aline = %d", aline);
if (!Vect_line_alive(Map, aline))
continue;
atype = Vect_read_line(Map, APoints, ACats, aline);
if (!(atype & type))
continue;
Vect_line_box(APoints, &ABox);
/* Find which sides of the box are touched by intermediate (non-end) points of line */
if (!is3d) {
touch1_n = touch1_s = touch1_e = touch1_w = 0;
for (j = 1; j < APoints->n_points; j++) {
if (APoints->y[j] == ABox.N)
touch1_n = 1;
if (APoints->y[j] == ABox.S)
touch1_s = 1;
if (APoints->x[j] == ABox.E)
touch1_e = 1;
if (APoints->x[j] == ABox.W)
touch1_w = 1;
}
G_debug(3, "touch1: n = %d s = %d e = %d w = %d", touch1_n,
touch1_s, touch1_e, touch1_w);
touch2_n = touch2_s = touch2_e = touch2_w = 0;
for (j = 0; j < APoints->n_points - 1; j++) {
if (APoints->y[j] == ABox.N)
touch2_n = 1;
if (APoints->y[j] == ABox.S)
touch2_s = 1;
if (APoints->x[j] == ABox.E)
touch2_e = 1;
if (APoints->x[j] == ABox.W)
touch2_w = 1;
}
G_debug(3, "touch2: n = %d s = %d e = %d w = %d", touch2_n,
touch2_s, touch2_e, touch2_w);
}
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];
if (List_break && !Vect_val_in_list(List_break, bline)) {
continue;
}
G_debug(3, " j = %d bline = %d", j, bline);
btype = Vect_read_line(Map, BPoints, BCats, bline);
/* Check if thouch by end node only */
if (!is3d) {
Vect_get_line_nodes(Map, aline, &anode1, &anode2);
Vect_get_line_nodes(Map, bline, &bnode1, &bnode2);
BBox = List->box[j];
if (anode1 == bnode1 || anode1 == bnode2)
node = anode1;
else if (anode2 == bnode1 || anode2 == bnode2)
node = anode2;
else
node = 0;
if (node) {
Vect_get_node_coor(Map, node, &nodex, &nodey, NULL);
if ((node == anode1 && nodey == ABox.N &&
!touch1_n && nodey == BBox.S) ||
(node == anode2 && nodey == ABox.N &&
!touch2_n && nodey == BBox.S) ||
(node == anode1 && nodey == ABox.S &&
!touch1_s && nodey == BBox.N) ||
(node == anode2 && nodey == ABox.S &&
!touch2_s && nodey == BBox.N) ||
(node == anode1 && nodex == ABox.E &&
!touch1_e && nodex == BBox.W) ||
(node == anode2 && nodex == ABox.E &&
!touch2_e && nodex == BBox.W) ||
(node == anode1 && nodex == ABox.W &&
!touch1_w && nodex == BBox.E) ||
(node == anode2 && nodex == ABox.W &&
!touch2_w && nodex == BBox.E)) {
G_debug(3,
"lines %d and %d touching by end nodes only -> no intersection",
aline, bline);
continue;
}
}
}
AXLines = NULL;
BXLines = NULL;
Vect_line_intersection(APoints, BPoints, &AXLines, &BXLines,
&naxlines, &nbxlines, 0);
G_debug(3, " naxlines = %d nbxlines = %d", naxlines, nbxlines);
/* This part handles a special case when aline == bline, no other intersection was found
* and the line is forming collapsed loop, for example 0,0;1,0;0,0 should be broken at 1,0.
* ---> */
if (aline == bline && naxlines == 0 && nbxlines == 0 &&
APoints->n_points >= 3) {
int centre;
int i;
G_debug(3, " Check collapsed loop");
if (APoints->n_points % 2) { /* odd number of vertices */
centre = APoints->n_points / 2; /* index of centre */
if (APoints->x[centre - 1] == APoints->x[centre + 1] && APoints->y[centre - 1] == APoints->y[centre + 1] && APoints->z[centre - 1] == APoints->z[centre + 1]) { /* -> break */
AXLines =
(struct line_pnts **)G_malloc(2 *
sizeof(struct
line_pnts
*));
AXLines[0] = Vect_new_line_struct();
AXLines[1] = Vect_new_line_struct();
for (i = 0; i <= centre; i++)
Vect_append_point(AXLines[0], APoints->x[i],
APoints->y[i], APoints->z[i]);
for (i = centre; i < APoints->n_points; i++)
Vect_append_point(AXLines[1], APoints->x[i],
APoints->y[i], APoints->z[i]);
naxlines = 2;
}
}
}
/* <--- */
if (Err) { /* array for intersections (more than needed */
xx = (double *)G_malloc((naxlines + nbxlines) *
sizeof(double));
yx = (double *)G_malloc((naxlines + nbxlines) *
sizeof(double));
zx = (double *)G_malloc((naxlines + nbxlines) *
sizeof(double));
}
nx = 0; /* number of intersections to be written to Err */
if (naxlines > 0) { /* intersection -> write out */
Vect_delete_line(Map, aline);
for (k = 0; k < naxlines; k++) {
/* Write new line segments */
/* line may collapse, don't write zero length lines */
Vect_line_prune(AXLines[k]);
if ((atype & GV_POINTS) || AXLines[k]->n_points > 1) {
ret = Vect_write_line(Map, atype, AXLines[k], ACats);
if (List_ref) {
Vect_list_append(List_ref, ret);
}
G_debug(3, "Line %d written, npoints = %d", ret,
AXLines[k]->n_points);
if (List_break) {
Vect_list_append(List_break, ret);
}
}
/* Write intersection points */
if (Err) {
if (k > 0) {
xx[nx] = AXLines[k]->x[0];
yx[nx] = AXLines[k]->y[0];
zx[nx] = AXLines[k]->z[0];
nx++;
}
}
Vect_destroy_line_struct(AXLines[k]);
}
nbreaks += naxlines - 1;
}
if (AXLines)
G_free(AXLines);
if (nbxlines > 0) {
if (aline != bline) { /* Self intersection, do not write twice, TODO: is it OK? */
Vect_delete_line(Map, bline);
for (k = 0; k < nbxlines; k++) {
/* Write new line segments */
/* line may collapse, don't write zero length lines */
Vect_line_prune(BXLines[k]);
if ((btype & GV_POINTS) || BXLines[k]->n_points > 1) {
ret =
Vect_write_line(Map, btype, BXLines[k],
BCats);
G_debug(5, "Line %d written", ret);
if (List_break) {
Vect_list_append(List_break, ret);
}
}
/* Write intersection points */
if (Err) {
if (k > 0) {
found = 0;
for (l = 0; l < nx; l++) {
if (xx[l] == BXLines[k]->x[0] &&
yx[l] == BXLines[k]->y[0] &&
zx[l] == BXLines[k]->z[0]) {
found = 1;
break;
}
}
if (!found) {
xx[nx] = BXLines[k]->x[0];
yx[nx] = BXLines[k]->y[0];
zx[nx] = BXLines[k]->z[0];
nx++;
}
}
}
Vect_destroy_line_struct(BXLines[k]);
}
nbreaks += nbxlines - 1;
}
else {
for (k = 0; k < nbxlines; k++)
Vect_destroy_line_struct(BXLines[k]);
}
}
if (BXLines)
G_free(BXLines);
if (Err) {
for (l = 0; l < nx; l++) { /* Write out errors */
Vect_reset_line(Points);
Vect_append_point(Points, xx[l], yx[l], zx[l]);
ret = Vect_write_line(Err, GV_POINT, Points, Cats);
}
G_free(xx);
G_free(yx);
G_free(zx);
}
if (naxlines > 0)
break; /* first line was broken and deleted -> take the next one */
}
if (List_break) {
nlines = List_break->n_values;
}
else {
nlines = Vect_get_num_lines(Map);
}
G_debug(3, "nlines = %d", nlines);
} /* for each line */
G_percent(nlines, nlines, 1); /* finish it */
G_verbose_message(_("Intersections: %d"), nbreaks);
Vect_destroy_line_struct(APoints);
Vect_destroy_line_struct(BPoints);
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(ACats);
Vect_destroy_cats_struct(BCats);
Vect_destroy_cats_struct(Cats);
Vect_destroy_boxlist(List);
return nbreaks;
}
